X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=include%2Fbfdlink.h;h=c02a1e82046600befd54127f2f1567f66b76d4c8;hb=41ae02c9eaedd88a26c7772a54e50a03ee129f7c;hp=193e8285414d4f48da6289f055df27997caf527f;hpb=8a55336153f2043e8a3aef64b1cf192e2bc45054;p=deliverable%2Fbinutils-gdb.git diff --git a/include/bfdlink.h b/include/bfdlink.h index 193e828541..c02a1e8204 100644 --- a/include/bfdlink.h +++ b/include/bfdlink.h @@ -1,5 +1,6 @@ /* bfdlink.h -- header file for BFD link routines - Copyright 1993 Free Software Foundation, Inc. + Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 + Free Software Foundation, Inc. Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. This file is part of BFD, the Binary File Descriptor library. @@ -16,7 +17,7 @@ GNU General Public License for more details. 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. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef BFDLINK_H #define BFDLINK_H @@ -34,10 +35,21 @@ enum bfd_link_strip if strip_all is used. */ enum bfd_link_discard { + discard_sec_merge, /* Discard local temporary symbols in SEC_MERGE + sections. */ discard_none, /* Don't discard any locals. */ - discard_l, /* Discard locals with a certain prefix. */ + discard_l, /* Discard local temporary symbols. */ discard_all /* Discard all locals. */ }; + +/* Describes the type of hash table entry structure being used. + Different hash table structure have different fields and so + support different linking features. */ +enum bfd_link_hash_table_type + { + bfd_link_generic_hash_table, + bfd_link_elf_hash_table + }; /* These are the possible types of an entry in the BFD link hash table. */ @@ -143,6 +155,8 @@ struct bfd_link_hash_table struct bfd_link_hash_entry *undefs; /* Entries are added to the tail of the undefs list. */ struct bfd_link_hash_entry *undefs_tail; + /* The type of the ink hash table. */ + enum bfd_link_hash_table_type type; }; /* Look up an entry in a link hash table. If FOLLOW is true, this @@ -152,6 +166,14 @@ extern struct bfd_link_hash_entry *bfd_link_hash_lookup PARAMS ((struct bfd_link_hash_table *, const char *, boolean create, boolean copy, boolean follow)); +/* Look up an entry in the main linker hash table if the symbol might + be wrapped. This should only be used for references to an + undefined symbol, not for definitions of a symbol. */ + +extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup + PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean, + boolean)); + /* Traverse a link hash table. */ extern void bfd_link_hash_traverse PARAMS ((struct bfd_link_hash_table *, @@ -171,15 +193,48 @@ struct bfd_link_info const struct bfd_link_callbacks *callbacks; /* true if BFD should generate a relocateable object file. */ boolean relocateable; + /* true if BFD should generate relocation information in the final executable. */ + boolean emitrelocations; + /* true if BFD should generate a "task linked" object file, + similar to relocatable but also with globals converted to statics. */ + boolean task_link; /* true if BFD should generate a shared object. */ boolean shared; + /* true if BFD should pre-bind symbols in a shared object. */ + boolean symbolic; + /* true if BFD should export all symbols in the dynamic symbol table + of an executable, rather than only those used. */ + boolean export_dynamic; + /* true if shared objects should be linked directly, not shared. */ + boolean static_link; + /* true if the output file should be in a traditional format. This + is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag + on the output file, but may be checked when reading the input + files. */ + boolean traditional_format; + /* true if we want to produced optimized output files. This might + need much more time and therefore must be explicitly selected. */ + boolean optimize; + /* true if BFD should generate errors for undefined symbols + even if generating a shared object. */ + boolean no_undefined; + /* true if BFD should allow undefined symbols in shared objects even + when no_undefined is set to disallow undefined symbols. The net + result will be that undefined symbols in regular objects will + still trigger an error, but undefined symbols in shared objects + will be ignored. The implementation of no_undefined makes the + assumption that the runtime linker will choke on undefined + symbols. However there is at least one system (BeOS) where + undefined symbols in shared libraries is normal since the kernel + patches them at load time to select which function is most + appropriate for the current architecture. I.E. dynamically + select an appropriate memset function. Apparently it is also + normal for HPPA shared libraries to have undefined symbols. */ + boolean allow_shlib_undefined; /* Which symbols to strip. */ enum bfd_link_strip strip; /* Which local symbols to discard. */ enum bfd_link_discard discard; - /* The local symbol prefix to discard if using discard_l. */ - unsigned int lprefix_len; - const char *lprefix; /* true if symbols should be retained in memory, false if they should be freed and reread. */ boolean keep_memory; @@ -197,16 +252,58 @@ struct bfd_link_info /* Hash table of symbols to keep. This is NULL unless strip is strip_some. */ struct bfd_hash_table *keep_hash; - /* Hash table of symbols to report back via notice_callback. If - this is NULL no symbols are reported back. */ + /* true if every symbol should be reported back via the notice + callback. */ + boolean notice_all; + /* Hash table of symbols to report back via the notice callback. If + this is NULL, and notice_all is false, then no symbols are + reported back. */ struct bfd_hash_table *notice_hash; + /* Hash table of symbols which are being wrapped (the --wrap linker + option). If this is NULL, no symbols are being wrapped. */ + struct bfd_hash_table *wrap_hash; + /* If a base output file is wanted, then this points to it */ + PTR base_file; + /* If non-zero, specifies that branches which are problematic for the + MPC860 C0 (or earlier) should be checked for and modified. It gives the + number of bytes that should be checked at the end of each text page. */ + int mpc860c0; - enum bfd_link_subsystem subsystem; - bfd_link_stack_heap stack_heap_parameters; + /* The function to call when the executable or shared object is + loaded. */ + const char *init_function; + /* The function to call when the executable or shared object is + unloaded. */ + const char *fini_function; - /* If a base output file is wanted, then this points to it */ - PTR base_file; + /* true if the new ELF dynamic tags are enabled. */ + boolean new_dtags; + + /* May be used to set DT_FLAGS for ELF. */ + bfd_vma flags; + + /* May be used to set DT_FLAGS_1 for ELF. */ + bfd_vma flags_1; + + /* True if auto-import thunks for DATA items in pei386 DLLs + should be generated/linked against. */ + boolean pei386_auto_import; + + /* True if non-PLT relocs should be merged into one reloc section + and sorted so that relocs against the same symbol come together. */ + boolean combreloc; + + /* True if executable should not contain copy relocs. + Setting this true may result in a non-sharable text segment. */ + boolean nocopyreloc; + + /* True if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment + should be created. */ + boolean eh_frame_hdr; + + /* How many spare .dynamic DT_NULL entries should be added? */ + unsigned int spare_dynamic_tags; }; /* This structures holds a set of callback functions. These are @@ -278,17 +375,27 @@ struct bfd_link_callbacks boolean constructor, const char *name, bfd *abfd, asection *sec, bfd_vma value)); - /* A function which is called when there is a reference to a warning - symbol. WARNING is the warning to be issued. */ + /* A function which is called to issue a linker warning. For + example, this is called when there is a reference to a warning + symbol. WARNING is the warning to be issued. SYMBOL is the name + of the symbol which triggered the warning; it may be NULL if + there is none. ABFD, SECTION and ADDRESS identify the location + which trigerred the warning; either ABFD or SECTION or both may + be NULL if the location is not known. */ boolean (*warning) PARAMS ((struct bfd_link_info *, - const char *warning)); + const char *warning, const char *symbol, + bfd *abfd, asection *section, + bfd_vma address)); /* A function which is called when a relocation is attempted against an undefined symbol. NAME is the symbol which is undefined. ABFD, SECTION and ADDRESS identify the location from which the - reference is made. In some cases SECTION may be NULL. */ + reference is made. FATAL indicates whether an undefined symbol is + a fatal error or not. In some cases SECTION may be NULL. */ boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *, const char *name, bfd *abfd, - asection *section, bfd_vma address)); + asection *section, + bfd_vma address, + boolean fatal)); /* A function which is called when a reloc overflow occurs. NAME is the name of the symbol or section the reloc is against, RELOC_NAME is the name of the relocation, and ADDEND is any @@ -431,4 +538,53 @@ struct bfd_link_order_reloc /* Allocate a new link_order for a section. */ extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *)); +/* These structures are used to describe version information for the + ELF linker. These structures could be manipulated entirely inside + BFD, but it would be a pain. Instead, the regular linker sets up + these structures, and then passes them into BFD. */ + +/* Regular expressions for a version. */ + +struct bfd_elf_version_expr +{ + /* Next regular expression for this version. */ + struct bfd_elf_version_expr *next; + /* Regular expression. */ + const char *pattern; + /* Matching function. */ + int (*match) PARAMS((struct bfd_elf_version_expr *, const char *)); +}; + +/* Version dependencies. */ + +struct bfd_elf_version_deps +{ + /* Next dependency for this version. */ + struct bfd_elf_version_deps *next; + /* The version which this version depends upon. */ + struct bfd_elf_version_tree *version_needed; +}; + +/* A node in the version tree. */ + +struct bfd_elf_version_tree +{ + /* Next version. */ + struct bfd_elf_version_tree *next; + /* Name of this version. */ + const char *name; + /* Version number. */ + unsigned int vernum; + /* Regular expressions for global symbols in this version. */ + struct bfd_elf_version_expr *globals; + /* Regular expressions for local symbols in this version. */ + struct bfd_elf_version_expr *locals; + /* List of versions which this version depends upon. */ + struct bfd_elf_version_deps *deps; + /* Index of the version name. This is used within BFD. */ + unsigned int name_indx; + /* Whether this version tree was used. This is used within BFD. */ + int used; +}; + #endif