1
/* Generic symbol-table support for the BFD library.
2
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
Free Software Foundation, Inc.
5
Written by Cygnus Support.
7
This file is part of BFD, the Binary File Descriptor library.
9
This program is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 2 of the License, or
12
(at your option) any later version.
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
GNU General Public License for more details.
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27
BFD tries to maintain as much symbol information as it can when
28
it moves information from file to file. BFD passes information
29
to applications though the <<asymbol>> structure. When the
30
application requests the symbol table, BFD reads the table in
31
the native form and translates parts of it into the internal
32
format. To maintain more than the information passed to
33
applications, some targets keep some information ``behind the
34
scenes'' in a structure only the particular back end knows
35
about. For example, the coff back end keeps the original
36
symbol table structure as well as the canonical structure when
37
a BFD is read in. On output, the coff back end can reconstruct
38
the output symbol table so that no information is lost, even
39
information unique to coff which BFD doesn't know or
40
understand. If a coff symbol table were read, but were written
41
through an a.out back end, all the coff specific information
42
would be lost. The symbol table of a BFD
43
is not necessarily read in until a canonicalize request is
44
made. Then the BFD back end fills in a table provided by the
45
application with pointers to the canonical information. To
46
output symbols, the application provides BFD with a table of
47
pointers to pointers to <<asymbol>>s. This allows applications
48
like the linker to output a symbol as it was read, since the ``behind
49
the scenes'' information will be still available.
55
@* symbol handling functions::
59
Reading Symbols, Writing Symbols, Symbols, Symbols
63
There are two stages to reading a symbol table from a BFD:
64
allocating storage, and the actual reading process. This is an
65
excerpt from an application which reads the symbol table:
67
| long storage_needed;
68
| asymbol **symbol_table;
69
| long number_of_symbols;
72
| storage_needed = bfd_get_symtab_upper_bound (abfd);
74
| if (storage_needed < 0)
77
| if (storage_needed == 0) {
80
| symbol_table = (asymbol **) xmalloc (storage_needed);
83
| bfd_canonicalize_symtab (abfd, symbol_table);
85
| if (number_of_symbols < 0)
88
| for (i = 0; i < number_of_symbols; i++) {
89
| process_symbol (symbol_table[i]);
92
All storage for the symbols themselves is in an objalloc
93
connected to the BFD; it is freed when the BFD is closed.
96
Writing Symbols, Mini Symbols, Reading Symbols, Symbols
100
Writing of a symbol table is automatic when a BFD open for
101
writing is closed. The application attaches a vector of
102
pointers to pointers to symbols to the BFD being written, and
103
fills in the symbol count. The close and cleanup code reads
104
through the table provided and performs all the necessary
105
operations. The BFD output code must always be provided with an
106
``owned'' symbol: one which has come from another BFD, or one
107
which has been created using <<bfd_make_empty_symbol>>. Here is an
108
example showing the creation of a symbol table with only one element:
117
| abfd = bfd_openw("foo","a.out-sunos-big");
118
| bfd_set_format(abfd, bfd_object);
119
| new = bfd_make_empty_symbol(abfd);
120
| new->name = "dummy_symbol";
121
| new->section = bfd_make_section_old_way(abfd, ".text");
122
| new->flags = BSF_GLOBAL;
123
| new->value = 0x12345;
126
| ptrs[1] = (asymbol *)0;
128
| bfd_set_symtab(abfd, ptrs, 1);
134
| 00012345 A dummy_symbol
136
Many formats cannot represent arbitary symbol information; for
137
instance, the <<a.out>> object format does not allow an
138
arbitary number of sections. A symbol pointing to a section
139
which is not one of <<.text>>, <<.data>> or <<.bss>> cannot
143
Mini Symbols, typedef asymbol, Writing Symbols, Symbols
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.
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.
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.
169
typedef asymbol, symbol handling functions, Mini Symbols, Symbols
176
An <<asymbol>> has the form:
184
.typedef struct symbol_cache_entry
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
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. *}
197
. {* The text of the symbol. The name is left alone, and not copied; the
198
. application may not alter it. *}
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. *}
206
. {* Attributes of a symbol. *}
207
.#define BSF_NO_FLAGS 0x00
209
. {* The symbol has local scope; <<static>> in <<C>>. The value
210
. is the offset into the section of the data. *}
211
.#define BSF_LOCAL 0x01
213
. {* The symbol has global scope; initialized data in <<C>>. The
214
. value is the offset into the section of the data. *}
215
.#define BSF_GLOBAL 0x02
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. *}
221
. {* A normal C symbol would be one of:
222
. <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or
225
. {* The symbol is a debugging record. The value has an arbitary
226
. meaning, unless BSF_DEBUGGING_RELOC is also set. *}
227
.#define BSF_DEBUGGING 0x08
229
. {* The symbol denotes a function entry point. Used in ELF,
230
. perhaps others someday. *}
231
.#define BSF_FUNCTION 0x10
233
. {* Used by the linker. *}
234
.#define BSF_KEEP 0x20
235
.#define BSF_KEEP_G 0x40
237
. {* A weak global symbol, overridable without warnings by
238
. a regular global symbol of the same name. *}
239
.#define BSF_WEAK 0x80
241
. {* This symbol was created to point to a section, e.g. ELF's
242
. STT_SECTION symbols. *}
243
.#define BSF_SECTION_SYM 0x100
245
. {* The symbol used to be a common symbol, but now it is
247
.#define BSF_OLD_COMMON 0x200
249
. {* The default value for common data. *}
250
.#define BFD_FORT_COMM_DEFAULT_VALUE 0
252
. {* In some files the type of a symbol sometimes alters its
253
. location in an output file - ie in coff a <<ISFCN>> symbol
254
. which is also <<C_EXT>> symbol appears where it was
255
. declared and not at the end of a section. This bit is set
256
. by the target BFD part to convey this information. *}
257
.#define BSF_NOT_AT_END 0x400
259
. {* Signal that the symbol is the label of constructor section. *}
260
.#define BSF_CONSTRUCTOR 0x800
262
. {* Signal that the symbol is a warning symbol. The name is a
263
. warning. The name of the next symbol is the one to warn about;
264
. if a reference is made to a symbol with the same name as the next
265
. symbol, a warning is issued by the linker. *}
266
.#define BSF_WARNING 0x1000
268
. {* Signal that the symbol is indirect. This symbol is an indirect
269
. pointer to the symbol with the same name as the next symbol. *}
270
.#define BSF_INDIRECT 0x2000
272
. {* BSF_FILE marks symbols that contain a file name. This is used
273
. for ELF STT_FILE symbols. *}
274
.#define BSF_FILE 0x4000
276
. {* Symbol is from dynamic linking information. *}
277
.#define BSF_DYNAMIC 0x8000
279
. {* The symbol denotes a data object. Used in ELF, and perhaps
281
.#define BSF_OBJECT 0x10000
283
. {* This symbol is a debugging symbol. The value is the offset
284
. into the section of the data. BSF_DEBUGGING should be set
286
.#define BSF_DEBUGGING_RELOC 0x20000
288
. {* This symbol is thread local. Used in ELF. *}
289
.#define BSF_THREAD_LOCAL 0x40000
293
. {* A pointer to the section to which this symbol is
294
. relative. This will always be non NULL, there are special
295
. sections for undefined and absolute symbols. *}
296
. struct sec *section;
298
. {* Back end special data. *}
313
#include "safe-ctype.h"
315
#include "aout/stab_gnu.h"
317
static char coff_section_type PARAMS ((const char *));
318
static char decode_section_type PARAMS ((const struct sec *));
319
static int cmpindexentry PARAMS ((const PTR, const PTR));
324
symbol handling functions, , typedef asymbol, Symbols
326
Symbol handling functions
331
bfd_get_symtab_upper_bound
334
Return the number of bytes required to store a vector of pointers
335
to <<asymbols>> for all the symbols in the BFD @var{abfd},
336
including a terminal NULL pointer. If there are no symbols in
337
the BFD, then return 0. If an error occurs, return -1.
339
.#define bfd_get_symtab_upper_bound(abfd) \
340
. BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
349
boolean bfd_is_local_label(bfd *abfd, asymbol *sym);
352
Return true if the given symbol @var{sym} in the BFD @var{abfd} is
353
a compiler generated local label, else return false.
357
bfd_is_local_label (abfd, sym)
361
/* The BSF_SECTION_SYM check is needed for IA-64, where every label that
362
starts with '.' is local. This would accidentally catch section names
363
if we didn't reject them here. */
364
if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_SECTION_SYM)) != 0)
366
if (sym->name == NULL)
368
return bfd_is_local_label_name (abfd, sym->name);
373
bfd_is_local_label_name
376
boolean bfd_is_local_label_name(bfd *abfd, const char *name);
379
Return true if a symbol with the name @var{name} in the BFD
380
@var{abfd} is a compiler generated local label, else return
381
false. This just checks whether the name has the form of a
384
.#define bfd_is_local_label_name(abfd, name) \
385
. BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
391
bfd_canonicalize_symtab
394
Read the symbols from the BFD @var{abfd}, and fills in
395
the vector @var{location} with pointers to the symbols and
397
Return the actual number of symbol pointers, not
400
.#define bfd_canonicalize_symtab(abfd, location) \
401
. BFD_SEND (abfd, _bfd_canonicalize_symtab,\
411
boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count);
414
Arrange that when the output BFD @var{abfd} is closed,
415
the table @var{location} of @var{count} pointers to symbols
420
bfd_set_symtab (abfd, location, symcount)
423
unsigned int symcount;
425
if ((abfd->format != bfd_object) || (bfd_read_p (abfd)))
427
bfd_set_error (bfd_error_invalid_operation);
431
bfd_get_outsymbols (abfd) = location;
432
bfd_get_symcount (abfd) = symcount;
438
bfd_print_symbol_vandf
441
void bfd_print_symbol_vandf(bfd *abfd, PTR file, asymbol *symbol);
444
Print the value and flags of the @var{symbol} supplied to the
448
bfd_print_symbol_vandf (abfd, arg, symbol)
453
FILE *file = (FILE *) arg;
454
flagword type = symbol->flags;
455
if (symbol->section != (asection *) NULL)
457
bfd_fprintf_vma (abfd, file,
458
symbol->value + symbol->section->vma);
462
bfd_fprintf_vma (abfd, file, symbol->value);
465
/* This presumes that a symbol can not be both BSF_DEBUGGING and
466
BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
468
fprintf (file, " %c%c%c%c%c%c%c",
470
? (type & BSF_GLOBAL) ? '!' : 'l'
471
: (type & BSF_GLOBAL) ? 'g' : ' '),
472
(type & BSF_WEAK) ? 'w' : ' ',
473
(type & BSF_CONSTRUCTOR) ? 'C' : ' ',
474
(type & BSF_WARNING) ? 'W' : ' ',
475
(type & BSF_INDIRECT) ? 'I' : ' ',
476
(type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
477
((type & BSF_FUNCTION)
481
: ((type & BSF_OBJECT) ? 'O' : ' '))));
486
bfd_make_empty_symbol
489
Create a new <<asymbol>> structure for the BFD @var{abfd}
490
and return a pointer to it.
492
This routine is necessary because each back end has private
493
information surrounding the <<asymbol>>. Building your own
494
<<asymbol>> and pointing to it will not create the private
495
information, and will cause problems later on.
497
.#define bfd_make_empty_symbol(abfd) \
498
. BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
504
_bfd_generic_make_empty_symbol
507
asymbol *_bfd_generic_make_empty_symbol (bfd *);
510
Create a new <<asymbol>> structure for the BFD @var{abfd}
511
and return a pointer to it. Used by core file routines,
512
binary back-end and anywhere else where no private info
517
_bfd_generic_make_empty_symbol (abfd)
520
bfd_size_type amt = sizeof (asymbol);
521
asymbol *new = (asymbol *) bfd_zalloc (abfd, amt);
529
bfd_make_debug_symbol
532
Create a new <<asymbol>> structure for the BFD @var{abfd},
533
to be used as a debugging symbol. Further details of its use have
534
yet to be worked out.
536
.#define bfd_make_debug_symbol(abfd,ptr,size) \
537
. BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
541
struct section_to_type
547
/* Map section names to POSIX/BSD single-character symbol types.
548
This table is probably incomplete. It is sorted for convenience of
549
adding entries. Since it is so short, a linear search is used. */
550
static const struct section_to_type stt[] =
553
{"code", 't'}, /* MRI .text */
556
{".debug", 'N'}, /* MSVC's .debug (non-standard debug syms) */
557
{".drectve", 'i'}, /* MSVC's .drective section */
558
{".edata", 'e'}, /* MSVC's .edata (export) section */
559
{".fini", 't'}, /* ELF fini section */
560
{".idata", 'i'}, /* MSVC's .idata (import) section */
561
{".init", 't'}, /* ELF init section */
562
{".pdata", 'p'}, /* MSVC's .pdata (stack unwind) section */
563
{".rdata", 'r'}, /* Read only data. */
564
{".rodata", 'r'}, /* Read only data. */
565
{".sbss", 's'}, /* Small BSS (uninitialized data). */
566
{".scommon", 'c'}, /* Small common. */
567
{".sdata", 'g'}, /* Small initialized data. */
569
{"vars", 'd'}, /* MRI .data */
570
{"zerovars", 'b'}, /* MRI .bss */
574
/* Return the single-character symbol type corresponding to
575
section S, or '?' for an unknown COFF section.
577
Check for any leading string which matches, so .text5 returns
578
't' as well as .text */
581
coff_section_type (s)
584
const struct section_to_type *t;
586
for (t = &stt[0]; t->section; t++)
587
if (!strncmp (s, t->section, strlen (t->section)))
593
/* Return the single-character symbol type corresponding to section
594
SECTION, or '?' for an unknown section. This uses section flags to
597
FIXME These types are unhandled: c, i, e, p. If we handled these also,
598
we could perhaps obsolete coff_section_type. */
601
decode_section_type (section)
602
const struct sec *section;
604
if (section->flags & SEC_CODE)
606
if (section->flags & SEC_DATA)
608
if (section->flags & SEC_READONLY)
610
else if (section->flags & SEC_SMALL_DATA)
615
if ((section->flags & SEC_HAS_CONTENTS) == 0)
617
if (section->flags & SEC_SMALL_DATA)
622
if (section->flags & SEC_DEBUGGING)
633
Return a character corresponding to the symbol
634
class of @var{symbol}, or '?' for an unknown class.
637
int bfd_decode_symclass(asymbol *symbol);
640
bfd_decode_symclass (symbol)
645
if (bfd_is_com_section (symbol->section))
647
if (bfd_is_und_section (symbol->section))
649
if (symbol->flags & BSF_WEAK)
651
/* If weak, determine if it's specifically an object
652
or non-object weak. */
653
if (symbol->flags & BSF_OBJECT)
661
if (bfd_is_ind_section (symbol->section))
663
if (symbol->flags & BSF_WEAK)
665
/* If weak, determine if it's specifically an object
666
or non-object weak. */
667
if (symbol->flags & BSF_OBJECT)
672
if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
675
if (bfd_is_abs_section (symbol->section))
677
else if (symbol->section)
679
c = coff_section_type (symbol->section->name);
681
c = decode_section_type (symbol->section);
685
if (symbol->flags & BSF_GLOBAL)
689
/* We don't have to handle these cases just yet, but we will soon:
701
bfd_is_undefined_symclass
704
Returns non-zero if the class symbol returned by
705
bfd_decode_symclass represents an undefined symbol.
706
Returns zero otherwise.
709
boolean bfd_is_undefined_symclass (int symclass);
713
bfd_is_undefined_symclass (symclass)
716
return symclass == 'U' || symclass == 'w' || symclass == 'v';
724
Fill in the basic info about symbol that nm needs.
725
Additional info may be added by the back-ends after
726
calling this function.
729
void bfd_symbol_info(asymbol *symbol, symbol_info *ret);
733
bfd_symbol_info (symbol, ret)
737
ret->type = bfd_decode_symclass (symbol);
739
if (bfd_is_undefined_symclass (ret->type))
742
ret->value = symbol->value + symbol->section->vma;
744
ret->name = symbol->name;
749
bfd_copy_private_symbol_data
752
boolean bfd_copy_private_symbol_data(bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
755
Copy private symbol information from @var{isym} in the BFD
756
@var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
757
Return <<true>> on success, <<false>> on error. Possible error
760
o <<bfd_error_no_memory>> -
761
Not enough memory exists to create private data for @var{osec}.
763
.#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
764
. BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
765
. (ibfd, isymbol, obfd, osymbol))
769
/* The generic version of the function which returns mini symbols.
770
This is used when the backend does not provide a more efficient
771
version. It just uses BFD asymbol structures as mini symbols. */
774
_bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep)
781
asymbol **syms = NULL;
785
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
787
storage = bfd_get_symtab_upper_bound (abfd);
793
syms = (asymbol **) bfd_malloc ((bfd_size_type) storage);
798
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
800
symcount = bfd_canonicalize_symtab (abfd, syms);
804
*minisymsp = (PTR) syms;
805
*sizep = sizeof (asymbol *);
814
/* The generic version of the function which converts a minisymbol to
815
an asymbol. We don't worry about the sym argument we are passed;
816
we just return the asymbol the minisymbol points to. */
820
_bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
821
bfd *abfd ATTRIBUTE_UNUSED;
822
boolean dynamic ATTRIBUTE_UNUSED;
824
asymbol *sym ATTRIBUTE_UNUSED;
826
return *(asymbol **) minisym;
829
/* Look through stabs debugging information in .stab and .stabstr
830
sections to find the source file and line closest to a desired
831
location. This is used by COFF and ELF targets. It sets *pfound
832
to true if it finds some information. The *pinfo field is used to
833
pass cached information in and out of this routine; this first time
834
the routine is called for a BFD, *pinfo should be NULL. The value
835
placed in *pinfo should be saved with the BFD, and passed back each
836
time this function is called. */
838
/* We use a cache by default. */
840
#define ENABLE_CACHING
842
/* We keep an array of indexentry structures to record where in the
843
stabs section we should look to find line number information for a
844
particular address. */
851
char *directory_name;
856
/* Compare two indexentry structures. This is called via qsort. */
863
const struct indexentry *contestantA = (const struct indexentry *) a;
864
const struct indexentry *contestantB = (const struct indexentry *) b;
866
if (contestantA->val < contestantB->val)
868
else if (contestantA->val > contestantB->val)
874
/* A pointer to this structure is stored in *pinfo. */
876
struct stab_find_info
878
/* The .stab section. */
880
/* The .stabstr section. */
882
/* The contents of the .stab section. */
884
/* The contents of the .stabstr section. */
887
/* A table that indexes stabs by memory address. */
888
struct indexentry *indextable;
889
/* The number of entries in indextable. */
892
#ifdef ENABLE_CACHING
893
/* Cached values to restart quickly. */
894
struct indexentry *cached_indexentry;
895
bfd_vma cached_offset;
896
bfd_byte *cached_stab;
897
char *cached_file_name;
900
/* Saved ptr to malloc'ed filename. */
905
_bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, pfound,
906
pfilename, pfnname, pline, pinfo)
912
const char **pfilename;
913
const char **pfnname;
917
struct stab_find_info *info;
918
bfd_size_type stabsize, strsize;
919
bfd_byte *stab, *str;
920
bfd_byte *last_stab = NULL;
921
bfd_size_type stroff;
922
struct indexentry *indexentry;
924
char *directory_name;
926
boolean saw_line, saw_func;
929
*pfilename = bfd_get_filename (abfd);
933
/* Stabs entries use a 12 byte format:
934
4 byte string table index
936
1 byte stab other field
937
2 byte stab desc field
939
FIXME: This will have to change for a 64 bit object format.
941
The stabs symbols are divided into compilation units. For the
942
first entry in each unit, the type of 0, the value is the length
943
of the string table for this unit, and the desc field is the
944
number of stabs symbols for this unit. */
951
#define STABSIZE (12)
953
info = (struct stab_find_info *) *pinfo;
956
if (info->stabsec == NULL || info->strsec == NULL)
958
/* No stabs debugging information. */
962
stabsize = info->stabsec->_raw_size;
963
strsize = info->strsec->_raw_size;
967
long reloc_size, reloc_count;
968
arelent **reloc_vector;
972
bfd_size_type amt = sizeof *info;
974
info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
978
/* FIXME: When using the linker --split-by-file or
979
--split-by-reloc options, it is possible for the .stab and
980
.stabstr sections to be split. We should handle that. */
982
info->stabsec = bfd_get_section_by_name (abfd, ".stab");
983
info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
985
if (info->stabsec == NULL || info->strsec == NULL)
987
/* No stabs debugging information. Set *pinfo so that we
988
can return quickly in the info != NULL case above. */
993
stabsize = info->stabsec->_raw_size;
994
strsize = info->strsec->_raw_size;
996
info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
997
info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
998
if (info->stabs == NULL || info->strs == NULL)
1001
if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1002
(bfd_vma) 0, stabsize)
1003
|| ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1004
(bfd_vma) 0, strsize))
1007
/* If this is a relocateable object file, we have to relocate
1008
the entries in .stab. This should always be simple 32 bit
1009
relocations against symbols defined in this object file, so
1010
this should be no big deal. */
1011
reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1014
reloc_vector = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1015
if (reloc_vector == NULL && reloc_size != 0)
1017
reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1019
if (reloc_count < 0)
1021
if (reloc_vector != NULL)
1022
free (reloc_vector);
1025
if (reloc_count > 0)
1029
for (pr = reloc_vector; *pr != NULL; pr++)
1036
if (r->howto->rightshift != 0
1037
|| r->howto->size != 2
1038
|| r->howto->bitsize != 32
1039
|| r->howto->pc_relative
1040
|| r->howto->bitpos != 0
1041
|| r->howto->dst_mask != 0xffffffff)
1043
(*_bfd_error_handler)
1044
(_("Unsupported .stab relocation"));
1045
bfd_set_error (bfd_error_invalid_operation);
1046
if (reloc_vector != NULL)
1047
free (reloc_vector);
1051
val = bfd_get_32 (abfd, info->stabs + r->address);
1052
val &= r->howto->src_mask;
1053
sym = *r->sym_ptr_ptr;
1054
val += sym->value + sym->section->vma + r->addend;
1055
bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1059
if (reloc_vector != NULL)
1060
free (reloc_vector);
1062
/* First time through this function, build a table matching
1063
function VM addresses to stabs, then sort based on starting
1064
VM address. Do this in two passes: once to count how many
1065
table entries we'll need, and a second to actually build the
1068
info->indextablesize = 0;
1070
for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1072
if (stab[TYPEOFF] == N_SO)
1074
/* N_SO with null name indicates EOF */
1075
if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1078
/* if we did not see a function def, leave space for one. */
1080
++info->indextablesize;
1084
/* two N_SO's in a row is a filename and directory. Skip */
1085
if (stab + STABSIZE < info->stabs + stabsize
1086
&& *(stab + STABSIZE + TYPEOFF) == N_SO)
1091
else if (stab[TYPEOFF] == N_FUN)
1094
++info->indextablesize;
1099
++info->indextablesize;
1101
if (info->indextablesize == 0)
1103
++info->indextablesize;
1105
amt = info->indextablesize;
1106
amt *= sizeof (struct indexentry);
1107
info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1108
if (info->indextable == NULL)
1112
directory_name = NULL;
1115
for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1116
i < info->indextablesize && stab < info->stabs + stabsize;
1119
switch (stab[TYPEOFF])
1122
/* This is the first entry in a compilation unit. */
1123
if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1126
stroff = bfd_get_32 (abfd, stab + VALOFF);
1130
/* The main file name. */
1132
/* The following code creates a new indextable entry with
1133
a NULL function name if there were no N_FUNs in a file.
1134
Note that a N_SO without a file name is an EOF and
1135
there could be 2 N_SO following it with the new filename
1139
info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1140
info->indextable[i].stab = last_stab;
1141
info->indextable[i].str = str;
1142
info->indextable[i].directory_name = directory_name;
1143
info->indextable[i].file_name = file_name;
1144
info->indextable[i].function_name = NULL;
1149
file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1150
if (*file_name == '\0')
1152
directory_name = NULL;
1159
if (stab + STABSIZE >= info->stabs + stabsize
1160
|| *(stab + STABSIZE + TYPEOFF) != N_SO)
1162
directory_name = NULL;
1166
/* Two consecutive N_SOs are a directory and a
1169
directory_name = file_name;
1170
file_name = ((char *) str
1171
+ bfd_get_32 (abfd, stab + STRDXOFF));
1177
/* The name of an include file. */
1178
file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1182
/* A function name. */
1184
name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1189
function_name = name;
1194
info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1195
info->indextable[i].stab = stab;
1196
info->indextable[i].str = str;
1197
info->indextable[i].directory_name = directory_name;
1198
info->indextable[i].file_name = file_name;
1199
info->indextable[i].function_name = function_name;
1207
info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1208
info->indextable[i].stab = last_stab;
1209
info->indextable[i].str = str;
1210
info->indextable[i].directory_name = directory_name;
1211
info->indextable[i].file_name = file_name;
1212
info->indextable[i].function_name = NULL;
1216
info->indextable[i].val = (bfd_vma) -1;
1217
info->indextable[i].stab = info->stabs + stabsize;
1218
info->indextable[i].str = str;
1219
info->indextable[i].directory_name = NULL;
1220
info->indextable[i].file_name = NULL;
1221
info->indextable[i].function_name = NULL;
1224
info->indextablesize = i;
1225
qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1228
*pinfo = (PTR) info;
1231
/* We are passed a section relative offset. The offsets in the
1232
stabs information are absolute. */
1233
offset += bfd_get_section_vma (abfd, section);
1235
#ifdef ENABLE_CACHING
1236
if (info->cached_indexentry != NULL
1237
&& offset >= info->cached_offset
1238
&& offset < (info->cached_indexentry + 1)->val)
1240
stab = info->cached_stab;
1241
indexentry = info->cached_indexentry;
1242
file_name = info->cached_file_name;
1247
/* Cache non-existant or invalid. Do binary search on
1256
high = info->indextablesize - 1;
1259
mid = (high + low) / 2;
1260
if (offset >= info->indextable[mid].val
1261
&& offset < info->indextable[mid + 1].val)
1263
indexentry = &info->indextable[mid];
1267
if (info->indextable[mid].val > offset)
1273
if (indexentry == NULL)
1276
stab = indexentry->stab + STABSIZE;
1277
file_name = indexentry->file_name;
1280
directory_name = indexentry->directory_name;
1281
str = indexentry->str;
1285
for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1292
switch (stab[TYPEOFF])
1295
/* The name of an include file. */
1296
val = bfd_get_32 (abfd, stab + VALOFF);
1299
file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1307
/* A line number. The value is relative to the start of the
1308
current function. */
1309
val = indexentry->val + bfd_get_32 (abfd, stab + VALOFF);
1310
/* If this line starts before our desired offset, or if it's
1311
the first line we've been able to find, use it. The
1312
!saw_line check works around a bug in GCC 2.95.3, which emits
1313
the first N_SLINE late. */
1314
if (!saw_line || val <= offset)
1316
*pline = bfd_get_16 (abfd, stab + DESCOFF);
1318
#ifdef ENABLE_CACHING
1319
info->cached_stab = stab;
1320
info->cached_offset = val;
1321
info->cached_file_name = file_name;
1322
info->cached_indexentry = indexentry;
1332
if (saw_func || saw_line)
1344
if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1345
|| directory_name == NULL)
1346
*pfilename = file_name;
1351
dirlen = strlen (directory_name);
1352
if (info->filename == NULL
1353
|| strncmp (info->filename, directory_name, dirlen) != 0
1354
|| strcmp (info->filename + dirlen, file_name) != 0)
1358
if (info->filename != NULL)
1359
free (info->filename);
1360
len = strlen (file_name) + 1;
1361
info->filename = (char *) bfd_malloc ((bfd_size_type) dirlen + len);
1362
if (info->filename == NULL)
1364
memcpy (info->filename, directory_name, dirlen);
1365
memcpy (info->filename + dirlen, file_name, len);
1368
*pfilename = info->filename;
1371
if (indexentry->function_name != NULL)
1375
/* This will typically be something like main:F(0,1), so we want
1376
to clobber the colon. It's OK to change the name, since the
1377
string is in our own local storage anyhow. */
1379
s = strchr (indexentry->function_name, ':');
1383
*pfnname = indexentry->function_name;
added
removed
binutils/bfd/syms.c
