X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fsyms.c;h=07d5b05fea97568b28f40cf2a5fa8090d6557927;hb=9560e662d0ee99ec96e326929459b6447bb2f80c;hp=ec1df2a11203d93566d1f073da9f9a89cb3d609f;hpb=6724ff46c812880323b37d7bcf039866b02c882b;p=binutils-gdb.git diff --git a/bfd/syms.c b/bfd/syms.c index ec1df2a1120..07d5b05fea9 100644 --- a/bfd/syms.c +++ b/bfd/syms.c @@ -1,5 +1,5 @@ /* Generic symbol-table support for the BFD library. - Copyright (C) 1990-1991 Free Software Foundation, Inc. + Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc. Written by Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -18,355 +18,542 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -/*doc* -@section Symbols -BFD trys to maintain as much symbol information as it can when it -moves information from file to file. BFD passes information to -applications though the @code{asymbol} structure. When the application -requests the symbol table, BFD reads the table in the native form and -translates parts of it into the internal format. To maintain more than -the infomation passed to applications some targets keep -some information 'behind the sceans', in a structure only the -particular back end knows about. For example, the coff back end keeps -the original symbol table structure as well as the canonical structure -when a BFD is read in. On output, the coff back end can reconstruct -the output symbol table so that no information is lost, even -information unique to coff which BFD doesn't know or understand. If a -coff symbol table was read, but was written through an a.out back end, -all the coff specific information would be lost. (.. until BFD 2 :). - -The symbol table of a BFD is not necessarily read in until a -canonicalize request is made. Then the BFD back end fills in a table -provided by the application with pointers to the canonical -information. - -To output symbols, the application provides BFD with a table of -pointers to pointers to @code{asymbol}s. This allows applications like -the linker to output a symbol as read, since the 'behind the sceens' -information will be still available. - +/* +SECTION + Symbols + + BFD tries to maintain as much symbol information as it can when + it moves information from file to file. BFD passes information + to applications though the <> structure. When the + application requests the symbol table, BFD reads the table in + the native form and translates parts of it into the internal + format. To maintain more than the information passed to + applications, some targets keep some information ``behind the + scenes'' in a structure only the particular back end knows + about. For example, the coff back end keeps the original + symbol table structure as well as the canonical structure when + a BFD is read in. On output, the coff back end can reconstruct + the output symbol table so that no information is lost, even + information unique to coff which BFD doesn't know or + understand. If a coff symbol table were read, but were written + through an a.out back end, all the coff specific information + would be lost. The symbol table of a BFD + is not necessarily read in until a canonicalize request is + made. Then the BFD back end fills in a table provided by the + application with pointers to the canonical information. To + output symbols, the application provides BFD with a table of + pointers to pointers to <>s. This allows applications + like the linker to output a symbol as it was read, since the ``behind + the scenes'' information will be still available. @menu -* Reading Symbols:: -* Writing Symbols:: -* typedef asymbol:: -* symbol handling functions:: +@* Reading Symbols:: +@* Writing Symbols:: +@* typedef asymbol:: +@* symbol handling functions:: @end menu -@node Reading Symbols, Writing Symbols, Symbols, Symbols -@subsection Reading Symbols -There are two stages to reading a symbol table from a BFD; allocating -storage, and the actual reading process. This is an excerpt from an -appliction which reads the symbol table: - -*+ - unsigned int storage_needed; - asymbol **symbol_table; - unsigned int number_of_symbols; - unsigned int i; - - storage_needed = get_symtab_upper_bound (abfd); - - if (storage_needed == 0) { - return ; - } - symbol_table = (asymbol **) malloc (storage_needed); - ... - number_of_symbols = - bfd_canonicalize_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) { - process_symbol (symbol_table[i]); - } -*- - -All storage for the symbols themselves is in an obstack connected to -the BFD, and is freed when the BFD is closed. - -@node Writing Symbols, typedef asymbol, Reading Symbols, Symbols -@subsection Writing Symbols -Writing of a symbol table is automatic when a BFD open for writing -is closed. The application attatches a vector of pointers to pointers to symbols -to the BFD being written, and fills in the symbol count. The close and -cleanup code reads through the table provided and performs all the -necessary operations. The outputing code must always be provided with -an 'owned' symbol; one which has come from another BFD, or one which -has been created using @code{bfd_make_empty_symbol}. - -An example showing the creation of a symbol table with only one -element: - -*+ -#include "bfd.h" -main() -{ - bfd *abfd; - asymbol *ptrs[2]; - asymbol *new; - - abfd = bfd_openw("foo","a.out-sunos-big"); - bfd_set_format(abfd, bfd_object); - new = bfd_make_empty_symbol(abfd); - new->name = "dummy_symbol"; - new->section = (asection *)0; - new->flags = BSF_ABSOLUTE | BSF_GLOBAL; - new->value = 0x12345; - - ptrs[0] = new; - ptrs[1] = (asymbol *)0; - - bfd_set_symtab(abfd, ptrs, 1); - bfd_close(abfd); -} - -./makesym -nm foo -00012345 A dummy_symbol - - -*- - -Many formats cannot represent arbitary symbol information; for -instance the @code{a.out} object format does not allow an arbitary -number of sections. A symbol pointing to a section which is not one of -@code{.text}, @code{.data} or @code{.bss} cannot be described. -*/ - - -/*doc* -@node typedef asymbol, symbol handling functions, Writing Symbols, Symbols +INODE +Reading Symbols, Writing Symbols, Symbols, Symbols +SUBSECTION + Reading symbols + + There are two stages to reading a symbol table from a BFD: + allocating storage, and the actual reading process. This is an + excerpt from an application which reads the symbol table: + +| long storage_needed; +| asymbol **symbol_table; +| long number_of_symbols; +| long i; +| +| storage_needed = bfd_get_symtab_upper_bound (abfd); +| +| if (storage_needed < 0) +| FAIL +| +| if (storage_needed == 0) { +| return ; +| } +| symbol_table = (asymbol **) xmalloc (storage_needed); +| ... +| number_of_symbols = +| bfd_canonicalize_symtab (abfd, symbol_table); +| +| if (number_of_symbols < 0) +| FAIL +| +| for (i = 0; i < number_of_symbols; i++) { +| process_symbol (symbol_table[i]); +| } + + All storage for the symbols themselves is in an obstack + connected to the BFD; it is freed when the BFD is closed. + + +INODE +Writing Symbols, typedef asymbol, Reading Symbols, Symbols +SUBSECTION + Writing symbols + + Writing of a symbol table is automatic when a BFD open for + writing is closed. The application attaches a vector of + pointers to pointers to symbols to the BFD being written, and + fills in the symbol count. The close and cleanup code reads + through the table provided and performs all the necessary + operations. The BFD output code must always be provided with an + ``owned'' symbol: one which has come from another BFD, or one + which has been created using <>. Here is an + example showing the creation of a symbol table with only one element: + +| #include "bfd.h" +| main() +| { +| bfd *abfd; +| asymbol *ptrs[2]; +| asymbol *new; +| +| abfd = bfd_openw("foo","a.out-sunos-big"); +| bfd_set_format(abfd, bfd_object); +| new = bfd_make_empty_symbol(abfd); +| new->name = "dummy_symbol"; +| new->section = bfd_make_section_old_way(abfd, ".text"); +| new->flags = BSF_GLOBAL; +| new->value = 0x12345; +| +| ptrs[0] = new; +| ptrs[1] = (asymbol *)0; +| +| bfd_set_symtab(abfd, ptrs, 1); +| bfd_close(abfd); +| } +| +| ./makesym +| nm foo +| 00012345 A dummy_symbol + + Many formats cannot represent arbitary symbol information; for + instance, the <> object format does not allow an + arbitary number of sections. A symbol pointing to a section + which is not one of <<.text>>, <<.data>> or <<.bss>> cannot + be described. */ -/*proto* -@subsection typedef asymbol -An @code{asymbol} has the form: - -*+++ - -$typedef struct symbol_cache_entry -${ -A pointer to the BFD which owns the symbol. This information is -necessary so that a back end can work out what additional (invisible to -the application writer) information is carried with the symbol. - -$ struct _bfd *the_bfd; - -The text of the symbol. The name is left alone, and not copied - the -application may not alter it. - -$ CONST char *name; - -The value of the symbol. - -$ symvalue value; - -Attributes of a symbol: - -$#define BSF_NO_FLAGS 0x00 -The symbol has local scope; @code{static} in @code{C}. The value is -the offset into the section of the data. -$#define BSF_LOCAL 0x01 -The symbol has global scope; initialized data in @code{C}. The value -is the offset into the section of the data. +/* +DOCDD +INODE +typedef asymbol, symbol handling functions, Writing Symbols, Symbols -$#define BSF_GLOBAL 0x02 - -Obsolete +*/ +/* +SUBSECTION + typedef asymbol -$#define BSF_IMPORT 0x04 + An <> has the form: -The symbol has global scope, and is exported. The value is the offset -into the section of the data. +*/ -$#define BSF_EXPORT 0x08 +/* +CODE_FRAGMENT + +. +.typedef struct symbol_cache_entry +.{ +. {* A pointer to the BFD which owns the symbol. This information +. is necessary so that a back end can work out what additional +. information (invisible to the application writer) is carried +. with the symbol. +. +. This field is *almost* redundant, since you can use section->owner +. instead, except that some symbols point to the global sections +. bfd_{abs,com,und}_section. This could be fixed by making +. these globals be per-bfd (or per-target-flavor). FIXME. *} +. +. struct _bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field. *} +. +. {* The text of the symbol. The name is left alone, and not copied; the +. application may not alter it. *} +. CONST char *name; +. +. {* The value of the symbol. This really should be a union of a +. numeric value with a pointer, since some flags indicate that +. a pointer to another symbol is stored here. *} +. symvalue value; +. +. {* Attributes of a symbol: *} +. +.#define BSF_NO_FLAGS 0x00 +. +. {* The symbol has local scope; <> in <>. The value +. is the offset into the section of the data. *} +.#define BSF_LOCAL 0x01 +. +. {* The symbol has global scope; initialized data in <>. The +. value is the offset into the section of the data. *} +.#define BSF_GLOBAL 0x02 +. +. {* The symbol has global scope and is exported. The value is +. the offset into the section of the data. *} +.#define BSF_EXPORT BSF_GLOBAL {* no real difference *} +. +. {* A normal C symbol would be one of: +. <>, <>, <> or +. <> *} +. +. {* The symbol is a debugging record. The value has an arbitary +. meaning. *} +.#define BSF_DEBUGGING 0x08 +. +. {* The symbol denotes a function entry point. Used in ELF, +. perhaps others someday. *} +.#define BSF_FUNCTION 0x10 +. +. {* Used by the linker. *} +.#define BSF_KEEP 0x20 +.#define BSF_KEEP_G 0x40 +. +. {* A weak global symbol, overridable without warnings by +. a regular global symbol of the same name. *} +.#define BSF_WEAK 0x80 +. +. {* This symbol was created to point to a section, e.g. ELF's +. STT_SECTION symbols. *} +.#define BSF_SECTION_SYM 0x100 +. +. {* The symbol used to be a common symbol, but now it is +. allocated. *} +.#define BSF_OLD_COMMON 0x200 +. +. {* The default value for common data. *} +.#define BFD_FORT_COMM_DEFAULT_VALUE 0 +. +. {* In some files the type of a symbol sometimes alters its +. location in an output file - ie in coff a <> symbol +. which is also <> symbol appears where it was +. declared and not at the end of a section. This bit is set +. by the target BFD part to convey this information. *} +. +.#define BSF_NOT_AT_END 0x400 +. +. {* Signal that the symbol is the label of constructor section. *} +.#define BSF_CONSTRUCTOR 0x800 +. +. {* Signal that the symbol is a warning symbol. If the symbol +. is a warning symbol, then the value field (I know this is +. tacky) will point to the asymbol which when referenced will +. cause the warning. *} +.#define BSF_WARNING 0x1000 +. +. {* Signal that the symbol is indirect. The value of the symbol +. is a pointer to an undefined asymbol which contains the +. name to use instead. *} +.#define BSF_INDIRECT 0x2000 +. +. {* BSF_FILE marks symbols that contain a file name. This is used +. for ELF STT_FILE symbols. *} +.#define BSF_FILE 0x4000 +. +. {* Symbol is from dynamic linking information. *} +.#define BSF_DYNAMIC 0x8000 +. +. flagword flags; +. +. {* A pointer to the section to which this symbol is +. relative. This will always be non NULL, there are special +. sections for undefined and absolute symbols *} +. struct sec *section; +. +. {* Back end special data. This is being phased out in favour +. of making this a union. *} +. PTR udata; +. +.} asymbol; +*/ -The symbol is undefined. @code{extern} in @code{C}. The value has no meaning. +#include "bfd.h" +#include "sysdep.h" -$#define BSF_UNDEFINED 0x10 +#include "libbfd.h" +#include "aout/stab_gnu.h" + +/* +DOCDD +INODE +symbol handling functions, , typedef asymbol, Symbols +SUBSECTION + Symbol handling functions +*/ -The symbol is common, initialized to zero; default in @code{C}. The -value is the size of the object in bytes. +/* +FUNCTION + bfd_get_symtab_upper_bound -$#define BSF_FORT_COMM 0x20 +DESCRIPTION + Return the number of bytes required to store a vector of pointers + to <> for all the symbols in the BFD @var{abfd}, + including a terminal NULL pointer. If there are no symbols in + the BFD, then return 0. If an error occurs, return -1. -A normal @code{C} symbol would be one of: -@code{BSF_LOCAL}, @code{BSF_FORT_COMM}, @code{BSF_UNDEFINED} or @code{BSF_EXPORT|BSD_GLOBAL} +.#define bfd_get_symtab_upper_bound(abfd) \ +. BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd)) -The symbol is a debugging record. The value has an arbitary meaning. +*/ -$#define BSF_DEBUGGING 0x40 +/* +FUNCTION + bfd_is_local_label -The symbol has no section attached, any value is the actual value and -is not a relative offset to a section. +SYNOPSIS + boolean bfd_is_local_label(bfd *abfd, asymbol *sym); -$#define BSF_ABSOLUTE 0x80 +DESCRIPTION + Return true if the given symbol @var{sym} in the BFD @var{abfd} is + a compiler generated local label, else return false. +.#define bfd_is_local_label(abfd, sym) \ +. BFD_SEND (abfd, _bfd_is_local_label,(abfd, sym)) +*/ -Used by the linker +/* +FUNCTION + bfd_canonicalize_symtab -$#define BSF_KEEP 0x10000 -$#define BSF_KEEP_G 0x80000 +DESCRIPTION + Read the symbols from the BFD @var{abfd}, and fills in + the vector @var{location} with pointers to the symbols and + a trailing NULL. + Return the actual number of symbol pointers, not + including the NULL. -Unused -$#define BSF_WEAK 0x100000 -$#define BSF_CTOR 0x200000 -$#define BSF_FAKE 0x400000 +.#define bfd_canonicalize_symtab(abfd, location) \ +. BFD_SEND (abfd, _bfd_canonicalize_symtab,\ +. (abfd, location)) -The symbol used to be a common symbol, but now it is allocated. +*/ -$#define BSF_OLD_COMMON 0x800000 -The default value for common data. +/* +FUNCTION + bfd_set_symtab -$#define BFD_FORT_COMM_DEFAULT_VALUE 0 +SYNOPSIS + boolean bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int count); -In some files the type of a symbol sometimes alters its location -in an output file - ie in coff a @code{ISFCN} symbol which is also @code{C_EXT} -symbol appears where it was declared and not at the end of a section. -This bit is set by the target BFD part to convey this information. +DESCRIPTION + Arrange that when the output BFD @var{abfd} is closed, + the table @var{location} of @var{count} pointers to symbols + will be written. +*/ -$#define BSF_NOT_AT_END 0x40000 +boolean +bfd_set_symtab (abfd, location, symcount) + bfd *abfd; + asymbol **location; + unsigned int symcount; +{ + if ((abfd->format != bfd_object) || (bfd_read_p (abfd))) + { + bfd_set_error (bfd_error_invalid_operation); + return false; + } -Signal that the symbol is the label of constructor section. + bfd_get_outsymbols (abfd) = location; + bfd_get_symcount (abfd) = symcount; + return true; +} -$#define BSF_CONSTRUCTOR 0x1000000 +/* +FUNCTION + bfd_print_symbol_vandf -Signal that the symbol is a warning symbol. If the symbol is a warning -symbol, then the value field (I know this is tacky) will point to the -asymbol which when referenced will cause the warning. +SYNOPSIS + void bfd_print_symbol_vandf(PTR file, asymbol *symbol); -$#define BSF_WARNING 0x2000000 +DESCRIPTION + Print the value and flags of the @var{symbol} supplied to the + stream @var{file}. +*/ +void +bfd_print_symbol_vandf (arg, symbol) + PTR arg; + asymbol *symbol; +{ + FILE *file = (FILE *) arg; + flagword type = symbol->flags; + if (symbol->section != (asection *) NULL) + { + fprintf_vma (file, symbol->value + symbol->section->vma); + } + else + { + fprintf_vma (file, symbol->value); + } + + /* This presumes that a symbol can not be both BSF_DEBUGGING and + BSF_DYNAMIC. */ + fprintf (file, " %c%c%c%c%c%c%c", + (type & BSF_LOCAL) ? 'l' : ' ', + (type & BSF_GLOBAL) ? 'g' : ' ', + (type & BSF_WEAK) ? 'w' : ' ', + (type & BSF_CONSTRUCTOR) ? 'C' : ' ', + (type & BSF_WARNING) ? 'W' : ' ', + (type & BSF_INDIRECT) ? 'I' : ' ', + (type & BSF_DEBUGGING) ? 'd' + : (type & BSF_DYNAMIC) ? 'D' : ' '); +} -Signal that the symbol is indirect. The value of the symbol is a -pointer to an undefined asymbol which contains the name to use -instead. -$#define BSF_INDIRECT 0x4000000 +/* +FUNCTION + bfd_make_empty_symbol -$ flagword flags; +DESCRIPTION + Create a new <> structure for the BFD @var{abfd} + and return a pointer to it. -Aointer to the section to which this symbol is relative, or 0 if the -symbol is absolute or undefined. Note that it is not sufficient to set -this location to 0 to mark a symbol as absolute - the flag -@code{BSF_ABSOLUTE} must be set also. + This routine is necessary because each back end has private + information surrounding the <>. Building your own + <> and pointing to it will not create the private + information, and will cause problems later on. -$ struct sec *section; +.#define bfd_make_empty_symbol(abfd) \ +. BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) +*/ -Back end special data. This is being phased out in favour of making -this a union. +/* +FUNCTION + bfd_make_debug_symbol -$ PTR udata; -$} asymbol; -*--- +DESCRIPTION + Create a new <> structure for the BFD @var{abfd}, + to be used as a debugging symbol. Further details of its use have + yet to be worked out. +.#define bfd_make_debug_symbol(abfd,ptr,size) \ +. BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size)) */ -#include "sysdep.h" -#include "bfd.h" -#include "libbfd.h" - -/*doc* -@node symbol handling functions, Symbols, typedef asymbol, Symbols -@subsection Symbol Handling Functions - -*/ +struct section_to_type +{ + CONST char *section; + char type; +}; + +/* Map section names to POSIX/BSD single-character symbol types. + This table is probably incomplete. It is sorted for convenience of + adding entries. Since it is so short, a linear search is used. */ +static CONST struct section_to_type stt[] = +{ + {"*DEBUG*", 'N'}, + {".bss", 'b'}, + {".data", 'd'}, + {".rdata", 'r'}, /* Read only data. */ + {".rodata", 'r'}, /* Read only data. */ + {".sbss", 's'}, /* Small BSS (uninitialized data). */ + {".scommon", 'c'}, /* Small common. */ + {".sdata", 'g'}, /* Small initialized data. */ + {".text", 't'}, + {0, 0} +}; + +/* Return the single-character symbol type corresponding to + section S, or '?' for an unknown COFF section. */ + +static char +coff_section_type (s) + char *s; +{ + CONST struct section_to_type *t; -/*proto* get_symtab_upper_bound -Returns the number of bytes required in a vector of pointers to -@code{asymbols} for all the symbols in the supplied BFD, including a -terminal NULL pointer. If there are no symbols in the BFD, then 0 is -returned. -*+ -#define get_symtab_upper_bound(abfd) \ - BFD_SEND (abfd, _get_symtab_upper_bound, (abfd)) -*- + for (t = &stt[0]; t->section; t++) + if (!strcmp (s, t->section)) + return t->type; + return '?'; +} -*/ +#ifndef islower +#define islower(c) ((c) >= 'a' && (c) <= 'z') +#endif +#ifndef toupper +#define toupper(c) (islower(c) ? ((c) & ~0x20) : (c)) +#endif -/*proto* bfd_canonicalize_symtab -Supplied a BFD and a pointer to an uninitialized vector of pointers. -This reads in the symbols from the BFD, and fills in the table with -pointers to the symbols, and a trailing NULL. The routine returns the -actual number of symbol pointers not including the NULL. +/* +FUNCTION + bfd_decode_symclass -*+ -#define bfd_canonicalize_symtab(abfd, location) \ - BFD_SEND (abfd, _bfd_canonicalize_symtab,\ - (abfd, location)) +DESCRIPTION + Return a character corresponding to the symbol + class of @var{symbol}, or '?' for an unknown class. -*- +SYNOPSIS + int bfd_decode_symclass(asymbol *symbol); */ +int +bfd_decode_symclass (symbol) + asymbol *symbol; +{ + char c; + + if (bfd_is_com_section (symbol->section)) + return 'C'; + if (bfd_is_und_section (symbol->section)) + return 'U'; + if (bfd_is_ind_section (symbol->section)) + return 'I'; + if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL))) + return '?'; + + if (bfd_is_abs_section (symbol->section)) + c = 'a'; + else if (symbol->section) + c = coff_section_type (symbol->section->name); + else + return '?'; + if (symbol->flags & BSF_GLOBAL) + c = toupper (c); + return c; + + /* We don't have to handle these cases just yet, but we will soon: + N_SETV: 'v'; + N_SETA: 'l'; + N_SETT: 'x'; + N_SETD: 'z'; + N_SETB: 's'; + N_INDR: 'i'; + */ +} +/* +FUNCTION + bfd_symbol_info -/*proto* bfd_set_symtab -Provided a table of pointers to to symbols and a count, writes to the -output BFD the symbols when closed. +DESCRIPTION + Fill in the basic info about symbol that nm needs. + Additional info may be added by the back-ends after + calling this function. -*; PROTO(boolean, bfd_set_symtab, (bfd *, asymbol **, unsigned int )); +SYNOPSIS + void bfd_symbol_info(asymbol *symbol, symbol_info *ret); */ -boolean -bfd_set_symtab (abfd, location, symcount) - bfd *abfd; - asymbol **location; - unsigned int symcount; +void +bfd_symbol_info (symbol, ret) + asymbol *symbol; + symbol_info *ret; { - if ((abfd->format != bfd_object) || (bfd_read_p (abfd))) { - bfd_error = invalid_operation; - return false; - } - - bfd_get_outsymbols (abfd) = location; - bfd_get_symcount (abfd) = symcount; - return true; + ret->type = bfd_decode_symclass (symbol); + if (ret->type != 'U') + ret->value = symbol->value + symbol->section->vma; + else + ret->value = 0; + ret->name = symbol->name; } -/*proto* bfd_print_symbol_vandf -Prints the value and flags of the symbol supplied to the stream file. - -*; PROTO(void, bfd_print_symbol_vandf, (PTR file, asymbol *symbol)); -*/ void -DEFUN(bfd_print_symbol_vandf,(file, symbol), -PTR file AND -asymbol *symbol) +bfd_symbol_is_absolute () { - flagword type = symbol->flags; - if (symbol->section != (asection *)NULL) - { - fprintf_vma(file, symbol->value+symbol->section->vma); - } - else - { - fprintf_vma(file, symbol->value); - } - fprintf(file," %c%c%c%c%c%c%c%c%c%c", - (type & BSF_LOCAL) ? 'l':' ', - (type & BSF_GLOBAL) ? 'g' : ' ', - (type & BSF_IMPORT) ? 'i' : ' ', - (type & BSF_EXPORT) ? 'e' : ' ', - (type & BSF_UNDEFINED) ? 'u' : ' ', - (type & BSF_FORT_COMM) ? 'c' : ' ', - (type & BSF_CONSTRUCTOR) ? 'C' : ' ', - (type & BSF_WARNING) ? 'W' : ' ', - (type & BSF_INDIRECT) ? 'I' : ' ', - (type & BSF_DEBUGGING) ? 'd' :' '); - + abort (); } - - -/*proto* bfd_make_empty_symbol -This function creates a new @code{asymbol} structure for the BFD, and -returns a pointer to it. - -This routine is necessary, since each back end has private information -surrounding the @code{asymbol}. Building your own @code{asymbol} and -pointing to it will not create the private information, and will cause -problems later on. -*+ -#define bfd_make_empty_symbol(abfd) \ - BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd)) -*- -*/