Commit | Line | Data |
---|---|---|
6724ff46 | 1 | /* Generic symbol-table support for the BFD library. |
c188b0be | 2 | Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. |
6724ff46 RP |
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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
0cda46cf SC |
21 | /* |
22 | SECTION | |
23 | Symbols | |
24 | ||
c188b0be | 25 | BFD tries to maintain as much symbol information as it can when |
0cda46cf SC |
26 | it moves information from file to file. BFD passes information |
27 | to applications though the <<asymbol>> structure. When the | |
e98e6ec1 | 28 | application requests the symbol table, BFD reads the table in |
0cda46cf | 29 | the native form and translates parts of it into the internal |
c188b0be DM |
30 | format. To maintain more than the information passed to |
31 | applications, some targets keep some information ``behind the | |
32 | scenes'' in a structure only the particular back end knows | |
0cda46cf SC |
33 | about. For example, the coff back end keeps the original |
34 | symbol table structure as well as the canonical structure when | |
35 | a BFD is read in. On output, the coff back end can reconstruct | |
36 | the output symbol table so that no information is lost, even | |
37 | information unique to coff which BFD doesn't know or | |
c188b0be | 38 | understand. If a coff symbol table were read, but were written |
0cda46cf | 39 | through an a.out back end, all the coff specific information |
e98e6ec1 | 40 | would be lost. The symbol table of a BFD |
0cda46cf SC |
41 | is not necessarily read in until a canonicalize request is |
42 | made. Then the BFD back end fills in a table provided by the | |
43 | application with pointers to the canonical information. To | |
44 | output symbols, the application provides BFD with a table of | |
45 | pointers to pointers to <<asymbol>>s. This allows applications | |
c188b0be DM |
46 | like the linker to output a symbol as it was read, since the ``behind |
47 | the scenes'' information will be still available. | |
6724ff46 | 48 | @menu |
151760d0 RP |
49 | @* Reading Symbols:: |
50 | @* Writing Symbols:: | |
51 | @* typedef asymbol:: | |
52 | @* symbol handling functions:: | |
6724ff46 RP |
53 | @end menu |
54 | ||
c188b0be DM |
55 | INODE |
56 | Reading Symbols, Writing Symbols, Symbols, Symbols | |
0cda46cf | 57 | SUBSECTION |
c91884b3 | 58 | Reading symbols |
0cda46cf | 59 | |
c188b0be | 60 | There are two stages to reading a symbol table from a BFD: |
0cda46cf | 61 | allocating storage, and the actual reading process. This is an |
c188b0be | 62 | excerpt from an application which reads the symbol table: |
0cda46cf | 63 | |
e98e6ec1 SC |
64 | | unsigned int storage_needed; |
65 | | asymbol **symbol_table; | |
66 | | unsigned int number_of_symbols; | |
67 | | unsigned int i; | |
68 | | | |
69 | | storage_needed = get_symtab_upper_bound (abfd); | |
70 | | | |
71 | | if (storage_needed == 0) { | |
72 | | return ; | |
73 | | } | |
74 | | symbol_table = (asymbol **) bfd_xmalloc (storage_needed); | |
75 | | ... | |
76 | | number_of_symbols = | |
77 | | bfd_canonicalize_symtab (abfd, symbol_table); | |
78 | | | |
79 | | for (i = 0; i < number_of_symbols; i++) { | |
80 | | process_symbol (symbol_table[i]); | |
81 | | } | |
0cda46cf SC |
82 | |
83 | All storage for the symbols themselves is in an obstack | |
c188b0be | 84 | connected to the BFD; it is freed when the BFD is closed. |
0cda46cf | 85 | |
6724ff46 | 86 | |
c188b0be DM |
87 | INODE |
88 | Writing Symbols, typedef asymbol, Reading Symbols, Symbols | |
0cda46cf | 89 | SUBSECTION |
c91884b3 | 90 | Writing symbols |
0cda46cf | 91 | |
0cda46cf SC |
92 | Writing of a symbol table is automatic when a BFD open for |
93 | writing is closed. The application attaches a vector of | |
94 | pointers to pointers to symbols to the BFD being written, and | |
95 | fills in the symbol count. The close and cleanup code reads | |
96 | through the table provided and performs all the necessary | |
c188b0be DM |
97 | operations. The BFD output code must always be provided with an |
98 | ``owned'' symbol: one which has come from another BFD, or one | |
99 | which has been created using <<bfd_make_empty_symbol>>. Here is an | |
0cda46cf SC |
100 | example showing the creation of a symbol table with only one element: |
101 | ||
e98e6ec1 SC |
102 | | #include "bfd.h" |
103 | | main() | |
104 | | { | |
105 | | bfd *abfd; | |
106 | | asymbol *ptrs[2]; | |
107 | | asymbol *new; | |
108 | | | |
109 | | abfd = bfd_openw("foo","a.out-sunos-big"); | |
110 | | bfd_set_format(abfd, bfd_object); | |
111 | | new = bfd_make_empty_symbol(abfd); | |
112 | | new->name = "dummy_symbol"; | |
113 | | new->section = bfd_make_section_old_way(abfd, ".text"); | |
114 | | new->flags = BSF_GLOBAL; | |
115 | | new->value = 0x12345; | |
116 | | | |
117 | | ptrs[0] = new; | |
118 | | ptrs[1] = (asymbol *)0; | |
119 | | | |
120 | | bfd_set_symtab(abfd, ptrs, 1); | |
121 | | bfd_close(abfd); | |
122 | | } | |
123 | | | |
124 | | ./makesym | |
125 | | nm foo | |
126 | | 00012345 A dummy_symbol | |
6724ff46 | 127 | |
0cda46cf | 128 | Many formats cannot represent arbitary symbol information; for |
c188b0be | 129 | instance, the <<a.out>> object format does not allow an |
0cda46cf SC |
130 | arbitary number of sections. A symbol pointing to a section |
131 | which is not one of <<.text>>, <<.data>> or <<.bss>> cannot | |
132 | be described. | |
6724ff46 | 133 | |
6724ff46 RP |
134 | */ |
135 | ||
136 | ||
c188b0be | 137 | |
e98e6ec1 | 138 | /* |
c188b0be DM |
139 | DOCDD |
140 | INODE | |
141 | typedef asymbol, symbol handling functions, Writing Symbols, Symbols | |
6724ff46 RP |
142 | |
143 | */ | |
0cda46cf | 144 | /* |
e98e6ec1 | 145 | SUBSECTION |
0cda46cf | 146 | typedef asymbol |
6724ff46 | 147 | |
0cda46cf | 148 | An <<asymbol>> has the form: |
6724ff46 | 149 | |
e98e6ec1 SC |
150 | */ |
151 | ||
152 | /* | |
153 | CODE_FRAGMENT | |
154 | ||
c188b0be | 155 | . |
0cda46cf SC |
156 | .typedef struct symbol_cache_entry |
157 | .{ | |
e98e6ec1 SC |
158 | . {* A pointer to the BFD which owns the symbol. This information |
159 | . is necessary so that a back end can work out what additional | |
c188b0be DM |
160 | . information (invisible to the application writer) is carried |
161 | . with the symbol. | |
162 | . | |
163 | . This field is *almost* redundant, since you can use section->owner | |
164 | . instead, except that some symbols point to the global sections | |
165 | . bfd_{abs,com,und}_section. This could be fixed by making | |
166 | . these globals be per-bfd (or per-target-flavor). FIXME. *} | |
e98e6ec1 | 167 | . |
c188b0be | 168 | . struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *} |
e98e6ec1 | 169 | . |
c188b0be | 170 | . {* The text of the symbol. The name is left alone, and not copied; the |
e98e6ec1 SC |
171 | . application may not alter it. *} |
172 | . CONST char *name; | |
173 | . | |
c188b0be DM |
174 | . {* The value of the symbol. This really should be a union of a |
175 | . numeric value with a pointer, since some flags indicate that | |
176 | . a pointer to another symbol is stored here. *} | |
e98e6ec1 SC |
177 | . symvalue value; |
178 | . | |
179 | . {* Attributes of a symbol: *} | |
180 | . | |
0cda46cf | 181 | .#define BSF_NO_FLAGS 0x00 |
e98e6ec1 SC |
182 | . |
183 | . {* The symbol has local scope; <<static>> in <<C>>. The value | |
184 | . is the offset into the section of the data. *} | |
0cda46cf | 185 | .#define BSF_LOCAL 0x01 |
e98e6ec1 SC |
186 | . |
187 | . {* The symbol has global scope; initialized data in <<C>>. The | |
188 | . value is the offset into the section of the data. *} | |
0cda46cf | 189 | .#define BSF_GLOBAL 0x02 |
e98e6ec1 | 190 | . |
c188b0be | 191 | . {* The symbol has global scope and is exported. The value is |
e98e6ec1 | 192 | . the offset into the section of the data. *} |
c188b0be | 193 | .#define BSF_EXPORT BSF_GLOBAL {* no real difference *} |
e98e6ec1 SC |
194 | . |
195 | . {* A normal C symbol would be one of: | |
196 | . <<BSF_LOCAL>>, <<BSF_FORT_COMM>>, <<BSF_UNDEFINED>> or | |
c188b0be | 197 | . <<BSF_GLOBAL>> *} |
e98e6ec1 SC |
198 | . |
199 | . {* The symbol is a debugging record. The value has an arbitary | |
200 | . meaning. *} | |
c188b0be | 201 | .#define BSF_DEBUGGING 0x08 |
e98e6ec1 | 202 | . |
c188b0be DM |
203 | . {* The symbol denotes a function entry point. Used in ELF, |
204 | . perhaps others someday. *} | |
205 | .#define BSF_FUNCTION 0x10 | |
e98e6ec1 | 206 | . |
c188b0be DM |
207 | . {* Used by the linker. *} |
208 | .#define BSF_KEEP 0x20 | |
209 | .#define BSF_KEEP_G 0x40 | |
e98e6ec1 | 210 | . |
c188b0be DM |
211 | . {* A weak global symbol, overridable without warnings by |
212 | . a regular global symbol of the same name. *} | |
213 | .#define BSF_WEAK 0x80 | |
214 | . | |
215 | . {* This symbol was created to point to a section, e.g. ELF's | |
216 | . STT_SECTION symbols. *} | |
217 | .#define BSF_SECTION_SYM 0x100 | |
e98e6ec1 SC |
218 | . |
219 | . {* The symbol used to be a common symbol, but now it is | |
220 | . allocated. *} | |
c188b0be | 221 | .#define BSF_OLD_COMMON 0x200 |
e98e6ec1 SC |
222 | . |
223 | . {* The default value for common data. *} | |
0cda46cf | 224 | .#define BFD_FORT_COMM_DEFAULT_VALUE 0 |
e98e6ec1 SC |
225 | . |
226 | . {* In some files the type of a symbol sometimes alters its | |
227 | . location in an output file - ie in coff a <<ISFCN>> symbol | |
228 | . which is also <<C_EXT>> symbol appears where it was | |
229 | . declared and not at the end of a section. This bit is set | |
230 | . by the target BFD part to convey this information. *} | |
231 | . | |
c188b0be | 232 | .#define BSF_NOT_AT_END 0x400 |
e98e6ec1 SC |
233 | . |
234 | . {* Signal that the symbol is the label of constructor section. *} | |
c188b0be | 235 | .#define BSF_CONSTRUCTOR 0x800 |
e98e6ec1 SC |
236 | . |
237 | . {* Signal that the symbol is a warning symbol. If the symbol | |
238 | . is a warning symbol, then the value field (I know this is | |
239 | . tacky) will point to the asymbol which when referenced will | |
240 | . cause the warning. *} | |
c188b0be | 241 | .#define BSF_WARNING 0x1000 |
e98e6ec1 SC |
242 | . |
243 | . {* Signal that the symbol is indirect. The value of the symbol | |
244 | . is a pointer to an undefined asymbol which contains the | |
245 | . name to use instead. *} | |
c188b0be DM |
246 | .#define BSF_INDIRECT 0x2000 |
247 | . | |
248 | . {* BSF_FILE marks symbols that contain a file name. This is used | |
249 | . for ELF STT_FILE symbols. *} | |
250 | .#define BSF_FILE 0x4000 | |
e98e6ec1 | 251 | . |
0cda46cf | 252 | . flagword flags; |
e98e6ec1 SC |
253 | . |
254 | . {* A pointer to the section to which this symbol is | |
255 | . relative. This will always be non NULL, there are special | |
256 | . sections for undefined and absolute symbols *} | |
0cda46cf | 257 | . struct sec *section; |
e98e6ec1 SC |
258 | . |
259 | . {* Back end special data. This is being phased out in favour | |
260 | . of making this a union. *} | |
c188b0be | 261 | . PTR udata; |
e98e6ec1 | 262 | . |
0cda46cf | 263 | .} asymbol; |
6724ff46 RP |
264 | */ |
265 | ||
6724ff46 | 266 | #include "bfd.h" |
7d68537f | 267 | #include "sysdep.h" |
c188b0be | 268 | |
6724ff46 | 269 | #include "libbfd.h" |
e98e6ec1 | 270 | #include "aout/stab_gnu.h" |
6724ff46 | 271 | |
0cda46cf | 272 | /* |
c188b0be DM |
273 | DOCDD |
274 | INODE | |
275 | symbol handling functions, , typedef asymbol, Symbols | |
0cda46cf | 276 | SUBSECTION |
c91884b3 | 277 | Symbol handling functions |
6724ff46 RP |
278 | */ |
279 | ||
0cda46cf SC |
280 | /* |
281 | FUNCTION | |
282 | get_symtab_upper_bound | |
283 | ||
284 | DESCRIPTION | |
c188b0be DM |
285 | Return the number of bytes required to store a vector of pointers |
286 | to <<asymbols>> for all the symbols in the BFD @var{abfd}, | |
0cda46cf | 287 | including a terminal NULL pointer. If there are no symbols in |
c188b0be | 288 | the BFD, then return 0. |
0cda46cf SC |
289 | |
290 | .#define get_symtab_upper_bound(abfd) \ | |
291 | . BFD_SEND (abfd, _get_symtab_upper_bound, (abfd)) | |
6724ff46 RP |
292 | |
293 | */ | |
294 | ||
0cda46cf SC |
295 | /* |
296 | FUNCTION | |
297 | bfd_canonicalize_symtab | |
298 | ||
299 | DESCRIPTION | |
c188b0be DM |
300 | Read the symbols from the BFD @var{abfd}, and fills in |
301 | the vector @var{location} with pointers to the symbols and | |
302 | a trailing NULL. | |
303 | Return the actual number of symbol pointers, not | |
0cda46cf | 304 | including the NULL. |
6724ff46 | 305 | |
6724ff46 | 306 | |
0cda46cf SC |
307 | .#define bfd_canonicalize_symtab(abfd, location) \ |
308 | . BFD_SEND (abfd, _bfd_canonicalize_symtab,\ | |
309 | . (abfd, location)) | |
310 | ||
6724ff46 RP |
311 | */ |
312 | ||
313 | ||
0cda46cf SC |
314 | /* |
315 | FUNCTION | |
316 | bfd_set_symtab | |
317 | ||
0cda46cf | 318 | SYNOPSIS |
c188b0be DM |
319 | boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); |
320 | ||
321 | DESCRIPTION | |
322 | Arrange that when the output BFD @var{abfd} is closed, | |
323 | the table @var{location} of @var{count} pointers to symbols | |
324 | will be written. | |
6724ff46 RP |
325 | */ |
326 | ||
327 | boolean | |
328 | bfd_set_symtab (abfd, location, symcount) | |
329 | bfd *abfd; | |
330 | asymbol **location; | |
331 | unsigned int symcount; | |
332 | { | |
333 | if ((abfd->format != bfd_object) || (bfd_read_p (abfd))) { | |
334 | bfd_error = invalid_operation; | |
335 | return false; | |
336 | } | |
337 | ||
338 | bfd_get_outsymbols (abfd) = location; | |
339 | bfd_get_symcount (abfd) = symcount; | |
340 | return true; | |
341 | } | |
342 | ||
0cda46cf SC |
343 | /* |
344 | FUNCTION | |
345 | bfd_print_symbol_vandf | |
6724ff46 | 346 | |
0cda46cf SC |
347 | SYNOPSIS |
348 | void bfd_print_symbol_vandf(PTR file, asymbol *symbol); | |
c188b0be DM |
349 | |
350 | DESCRIPTION | |
351 | Print the value and flags of the @var{symbol} supplied to the | |
352 | stream @var{file}. | |
6724ff46 RP |
353 | */ |
354 | void | |
355 | DEFUN(bfd_print_symbol_vandf,(file, symbol), | |
c91884b3 | 356 | FILE *file AND |
6724ff46 RP |
357 | asymbol *symbol) |
358 | { | |
359 | flagword type = symbol->flags; | |
360 | if (symbol->section != (asection *)NULL) | |
361 | { | |
362 | fprintf_vma(file, symbol->value+symbol->section->vma); | |
363 | } | |
364 | else | |
365 | { | |
366 | fprintf_vma(file, symbol->value); | |
367 | } | |
c188b0be | 368 | fprintf(file," %c%c%c%c%c%c%c", |
6724ff46 RP |
369 | (type & BSF_LOCAL) ? 'l':' ', |
370 | (type & BSF_GLOBAL) ? 'g' : ' ', | |
c188b0be | 371 | (type & BSF_WEAK) ? 'w' : ' ', |
6724ff46 RP |
372 | (type & BSF_CONSTRUCTOR) ? 'C' : ' ', |
373 | (type & BSF_WARNING) ? 'W' : ' ', | |
374 | (type & BSF_INDIRECT) ? 'I' : ' ', | |
375 | (type & BSF_DEBUGGING) ? 'd' :' '); | |
376 | ||
377 | } | |
378 | ||
379 | ||
0cda46cf SC |
380 | /* |
381 | FUNCTION | |
382 | bfd_make_empty_symbol | |
383 | ||
384 | DESCRIPTION | |
c188b0be DM |
385 | Create a new <<asymbol>> structure for the BFD @var{abfd} |
386 | and return a pointer to it. | |
6724ff46 | 387 | |
c188b0be | 388 | This routine is necessary because each back end has private |
0cda46cf SC |
389 | information surrounding the <<asymbol>>. Building your own |
390 | <<asymbol>> and pointing to it will not create the private | |
391 | information, and will cause problems later on. | |
392 | ||
393 | .#define bfd_make_empty_symbol(abfd) \ | |
394 | . BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) | |
6724ff46 | 395 | */ |
7d68537f | 396 | |
c188b0be DM |
397 | /* |
398 | FUNCTION | |
399 | bfd_make_debug_symbol | |
400 | ||
401 | DESCRIPTION | |
402 | Create a new <<asymbol>> structure for the BFD @var{abfd}, | |
403 | to be used as a debugging symbol. Further details of its use have | |
404 | yet to be worked out. | |
405 | ||
406 | .#define bfd_make_debug_symbol(abfd,ptr,size) \ | |
407 | . BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) | |
408 | */ | |
409 | ||
410 | struct section_to_type | |
411 | { | |
412 | CONST char *section; | |
413 | char type; | |
414 | }; | |
415 | ||
416 | /* Map section names to POSIX/BSD single-character symbol types. | |
417 | This table is probably incomplete. It is sorted for convenience of | |
418 | adding entries. Since it is so short, a linear search is used. */ | |
419 | static CONST struct section_to_type stt[] = { | |
420 | {"*DEBUG*", 'N'}, | |
421 | {".bss", 'b'}, | |
422 | {".data", 'd'}, | |
423 | {".sbss", 's'}, /* Small BSS (uninitialized data) */ | |
424 | {".scommon", 'c'}, /* Small common */ | |
425 | {".sdata", 'g'}, /* Small initialized data */ | |
426 | {".text", 't'}, | |
427 | {0, 0} | |
428 | }; | |
429 | ||
430 | /* Return the single-character symbol type corresponding to | |
431 | section S, or '?' for an unknown COFF section. */ | |
432 | ||
433 | static char | |
434 | coff_section_type (s) | |
435 | char *s; | |
436 | { | |
437 | CONST struct section_to_type *t; | |
438 | ||
439 | for (t = &stt[0]; t->section; t++) | |
440 | if (!strcmp (s, t->section)) | |
441 | return t->type; | |
442 | return '?'; | |
443 | } | |
444 | ||
445 | #ifndef islower | |
446 | #define islower(c) ((c) >= 'a' && (c) <= 'z') | |
447 | #endif | |
448 | #ifndef toupper | |
449 | #define toupper(c) (islower(c) ? ((c) & ~0x20) : (c)) | |
450 | #endif | |
451 | ||
0cda46cf SC |
452 | /* |
453 | FUNCTION | |
454 | bfd_decode_symclass | |
455 | ||
456 | DESCRIPTION | |
c188b0be DM |
457 | Return a character corresponding to the symbol |
458 | class of @var{symbol}, or '?' for an unknown class. | |
7d68537f | 459 | |
0cda46cf SC |
460 | SYNOPSIS |
461 | int bfd_decode_symclass(asymbol *symbol); | |
7d68537f FF |
462 | */ |
463 | int | |
464 | DEFUN(bfd_decode_symclass,(symbol), | |
465 | asymbol *symbol) | |
466 | { | |
c188b0be DM |
467 | char c; |
468 | ||
469 | if (bfd_is_com_section (symbol->section)) | |
470 | return 'C'; | |
471 | if (symbol->section == &bfd_und_section) | |
472 | return 'U'; | |
473 | if (symbol->section == &bfd_ind_section) | |
474 | return 'I'; | |
475 | if (!(symbol->flags & (BSF_GLOBAL|BSF_LOCAL))) | |
476 | return '?'; | |
477 | ||
478 | if (symbol->section == &bfd_abs_section) | |
479 | c = 'a'; | |
480 | else if (symbol->section) | |
481 | c = coff_section_type (symbol->section->name); | |
482 | else | |
483 | return '?'; | |
484 | if (symbol->flags & BSF_GLOBAL) | |
485 | c = toupper (c); | |
486 | return c; | |
7d68537f FF |
487 | |
488 | /* We don't have to handle these cases just yet, but we will soon: | |
489 | N_SETV: 'v'; | |
490 | N_SETA: 'l'; | |
491 | N_SETT: 'x'; | |
492 | N_SETD: 'z'; | |
493 | N_SETB: 's'; | |
494 | N_INDR: 'i'; | |
495 | */ | |
7d68537f | 496 | } |
e98e6ec1 | 497 | |
c188b0be DM |
498 | /* |
499 | FUNCTION | |
500 | bfd_symbol_info | |
501 | ||
502 | DESCRIPTION | |
503 | Fill in the basic info about symbol that nm needs. | |
504 | Additional info may be added by the back-ends after | |
505 | calling this function. | |
506 | ||
507 | SYNOPSIS | |
508 | void bfd_symbol_info(asymbol *symbol, symbol_info *ret); | |
509 | */ | |
e98e6ec1 | 510 | |
c188b0be DM |
511 | void |
512 | DEFUN(bfd_symbol_info,(symbol, ret), | |
513 | asymbol *symbol AND | |
514 | symbol_info *ret) | |
515 | { | |
516 | ret->type = bfd_decode_symclass (symbol); | |
517 | if (ret->type != 'U') | |
518 | ret->value = symbol->value+symbol->section->vma; | |
519 | else | |
520 | ret->value = 0; | |
521 | ret->name = symbol->name; | |
522 | } | |
523 | ||
524 | void | |
e98e6ec1 SC |
525 | bfd_symbol_is_absolute() |
526 | { | |
e98e6ec1 SC |
527 | abort(); |
528 | } | |
529 |