|
||||
File indexing completed on 2024-05-18 08:29:38
0001 /* bfdlink.h -- header file for BFD link routines 0002 Copyright (C) 1993-2022 Free Software Foundation, Inc. 0003 Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. 0004 0005 This file is part of BFD, the Binary File Descriptor library. 0006 0007 This program is free software; you can redistribute it and/or modify 0008 it under the terms of the GNU General Public License as published by 0009 the Free Software Foundation; either version 3 of the License, or 0010 (at your option) any later version. 0011 0012 This program is distributed in the hope that it will be useful, 0013 but WITHOUT ANY WARRANTY; without even the implied warranty of 0014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 0015 GNU General Public License for more details. 0016 0017 You should have received a copy of the GNU General Public License 0018 along with this program; if not, write to the Free Software 0019 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 0020 MA 02110-1301, USA. */ 0021 0022 #ifndef BFDLINK_H 0023 #define BFDLINK_H 0024 0025 /* Which symbols to strip during a link. */ 0026 enum bfd_link_strip 0027 { 0028 strip_none, /* Don't strip any symbols. */ 0029 strip_debugger, /* Strip debugging symbols. */ 0030 strip_some, /* keep_hash is the list of symbols to keep. */ 0031 strip_all /* Strip all symbols. */ 0032 }; 0033 0034 /* Which local symbols to discard during a link. This is irrelevant 0035 if strip_all is used. */ 0036 enum bfd_link_discard 0037 { 0038 discard_sec_merge, /* Discard local temporary symbols in SEC_MERGE 0039 sections. */ 0040 discard_none, /* Don't discard any locals. */ 0041 discard_l, /* Discard local temporary symbols. */ 0042 discard_all /* Discard all locals. */ 0043 }; 0044 0045 enum notice_asneeded_action { 0046 notice_as_needed, 0047 notice_not_needed, 0048 notice_needed 0049 }; 0050 0051 /* Whether to generate ELF common symbols with the STT_COMMON type 0052 during a relocatable link. */ 0053 enum bfd_link_elf_stt_common 0054 { 0055 unchanged, 0056 elf_stt_common, 0057 no_elf_stt_common 0058 }; 0059 0060 /* Describes the type of hash table entry structure being used. 0061 Different hash table structure have different fields and so 0062 support different linking features. */ 0063 enum bfd_link_hash_table_type 0064 { 0065 bfd_link_generic_hash_table, 0066 bfd_link_elf_hash_table 0067 }; 0068 0069 /* These are the possible types of an entry in the BFD link hash 0070 table. */ 0071 0072 enum bfd_link_hash_type 0073 { 0074 bfd_link_hash_new, /* Symbol is new. */ 0075 bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ 0076 bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ 0077 bfd_link_hash_defined, /* Symbol is defined. */ 0078 bfd_link_hash_defweak, /* Symbol is weak and defined. */ 0079 bfd_link_hash_common, /* Symbol is common. */ 0080 bfd_link_hash_indirect, /* Symbol is an indirect link. */ 0081 bfd_link_hash_warning /* Like indirect, but warn if referenced. */ 0082 }; 0083 0084 enum bfd_link_common_skip_ar_symbols 0085 { 0086 bfd_link_common_skip_none, 0087 bfd_link_common_skip_text, 0088 bfd_link_common_skip_data, 0089 bfd_link_common_skip_all 0090 }; 0091 0092 struct bfd_link_hash_common_entry 0093 { 0094 unsigned int alignment_power; /* Alignment. */ 0095 asection *section; /* Symbol section. */ 0096 }; 0097 0098 /* The linking routines use a hash table which uses this structure for 0099 its elements. */ 0100 0101 struct bfd_link_hash_entry 0102 { 0103 /* Base hash table entry structure. */ 0104 struct bfd_hash_entry root; 0105 0106 /* Type of this entry. */ 0107 ENUM_BITFIELD (bfd_link_hash_type) type : 8; 0108 0109 /* Symbol is referenced in a normal regular object file, 0110 as distinct from a LTO IR object file. */ 0111 unsigned int non_ir_ref_regular : 1; 0112 0113 /* Symbol is referenced in a normal dynamic object file, 0114 as distinct from a LTO IR object file. */ 0115 unsigned int non_ir_ref_dynamic : 1; 0116 0117 /* Symbol is a built-in define. These will be overridden by PROVIDE 0118 in a linker script. */ 0119 unsigned int linker_def : 1; 0120 0121 /* Symbol defined in a linker script. */ 0122 unsigned int ldscript_def : 1; 0123 0124 /* Symbol will be converted from absolute to section-relative. Set for 0125 symbols defined by a script from "dot" (also SEGMENT_START or ORIGIN) 0126 outside of an output section statement. */ 0127 unsigned int rel_from_abs : 1; 0128 0129 /* A union of information depending upon the type. */ 0130 union 0131 { 0132 /* Nothing is kept for bfd_hash_new. */ 0133 /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ 0134 struct 0135 { 0136 /* Undefined and common symbols are kept in a linked list through 0137 this field. This field is present in all of the union element 0138 so that we don't need to remove entries from the list when we 0139 change their type. Removing entries would either require the 0140 list to be doubly linked, which would waste more memory, or 0141 require a traversal. When an undefined or common symbol is 0142 created, it should be added to this list, the head of which is in 0143 the link hash table itself. As symbols are defined, they need 0144 not be removed from the list; anything which reads the list must 0145 doublecheck the symbol type. 0146 0147 Weak symbols are not kept on this list. 0148 0149 Defined and defweak symbols use this field as a reference marker. 0150 If the field is not NULL, or this structure is the tail of the 0151 undefined symbol list, the symbol has been referenced. If the 0152 symbol is undefined and becomes defined, this field will 0153 automatically be non-NULL since the symbol will have been on the 0154 undefined symbol list. */ 0155 struct bfd_link_hash_entry *next; 0156 /* BFD symbol was found in. */ 0157 bfd *abfd; 0158 } undef; 0159 /* bfd_link_hash_defined, bfd_link_hash_defweak. */ 0160 struct 0161 { 0162 struct bfd_link_hash_entry *next; 0163 /* Symbol section. */ 0164 asection *section; 0165 /* Symbol value. */ 0166 bfd_vma value; 0167 } def; 0168 /* bfd_link_hash_indirect, bfd_link_hash_warning. */ 0169 struct 0170 { 0171 struct bfd_link_hash_entry *next; 0172 /* Real symbol. */ 0173 struct bfd_link_hash_entry *link; 0174 /* Warning message (bfd_link_hash_warning only). */ 0175 const char *warning; 0176 } i; 0177 /* bfd_link_hash_common. */ 0178 struct 0179 { 0180 struct bfd_link_hash_entry *next; 0181 /* The linker needs to know three things about common 0182 symbols: the size, the alignment, and the section in 0183 which the symbol should be placed. We store the size 0184 here, and we allocate a small structure to hold the 0185 section and the alignment. The alignment is stored as a 0186 power of two. We don't store all the information 0187 directly because we don't want to increase the size of 0188 the union; this structure is a major space user in the 0189 linker. */ 0190 struct bfd_link_hash_common_entry *p; 0191 /* Common symbol size. */ 0192 bfd_size_type size; 0193 } c; 0194 } u; 0195 }; 0196 0197 /* This is the link hash table. It is a derived class of 0198 bfd_hash_table. */ 0199 0200 struct bfd_link_hash_table 0201 { 0202 /* The hash table itself. */ 0203 struct bfd_hash_table table; 0204 /* A linked list of undefined and common symbols, linked through the 0205 next field in the bfd_link_hash_entry structure. */ 0206 struct bfd_link_hash_entry *undefs; 0207 /* Entries are added to the tail of the undefs list. */ 0208 struct bfd_link_hash_entry *undefs_tail; 0209 /* Function to free the hash table on closing BFD. */ 0210 void (*hash_table_free) (bfd *); 0211 /* The type of the link hash table. */ 0212 enum bfd_link_hash_table_type type; 0213 }; 0214 0215 /* Look up an entry in a link hash table. If FOLLOW is TRUE, this 0216 follows bfd_link_hash_indirect and bfd_link_hash_warning links to 0217 the real symbol. */ 0218 extern struct bfd_link_hash_entry *bfd_link_hash_lookup 0219 (struct bfd_link_hash_table *, const char *, bool create, 0220 bool copy, bool follow); 0221 0222 /* Look up an entry in the main linker hash table if the symbol might 0223 be wrapped. This should only be used for references to an 0224 undefined symbol, not for definitions of a symbol. */ 0225 0226 extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup 0227 (bfd *, struct bfd_link_info *, const char *, bool, bool, bool); 0228 0229 /* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_" 0230 and the remainder is found in wrap_hash, return the real symbol. */ 0231 0232 extern struct bfd_link_hash_entry *unwrap_hash_lookup 0233 (struct bfd_link_info *, bfd *, struct bfd_link_hash_entry *); 0234 0235 /* Traverse a link hash table. */ 0236 extern void bfd_link_hash_traverse 0237 (struct bfd_link_hash_table *, 0238 bool (*) (struct bfd_link_hash_entry *, void *), 0239 void *); 0240 0241 /* Add an entry to the undefs list. */ 0242 extern void bfd_link_add_undef 0243 (struct bfd_link_hash_table *, struct bfd_link_hash_entry *); 0244 0245 /* Remove symbols from the undefs list that don't belong there. */ 0246 extern void bfd_link_repair_undef_list 0247 (struct bfd_link_hash_table *table); 0248 0249 /* Read symbols and cache symbol pointer array in outsymbols. */ 0250 extern bool bfd_generic_link_read_symbols (bfd *); 0251 0252 /* Check the relocs in the BFD. Called after all the input 0253 files have been loaded, and garbage collection has tagged 0254 any unneeded sections. */ 0255 extern bool bfd_link_check_relocs (bfd *,struct bfd_link_info *); 0256 0257 struct bfd_sym_chain 0258 { 0259 struct bfd_sym_chain *next; 0260 const char *name; 0261 }; 0262 0263 /* How to handle unresolved symbols. 0264 There are four possibilities which are enumerated below: */ 0265 enum report_method 0266 { 0267 /* This is the initial value when then link_info structure is created. 0268 It allows the various stages of the linker to determine whether they 0269 allowed to set the value. */ 0270 RM_NOT_YET_SET = 0, 0271 RM_IGNORE, 0272 RM_DIAGNOSE, 0273 }; 0274 0275 /* How to handle DT_TEXTREL. */ 0276 0277 enum textrel_check_method 0278 { 0279 textrel_check_none, 0280 textrel_check_warning, 0281 textrel_check_error 0282 }; 0283 0284 #define bfd_link_textrel_check(info) \ 0285 (info->textrel_check != textrel_check_none) 0286 0287 typedef enum {with_flags, without_flags} flag_type; 0288 0289 /* A section flag list. */ 0290 struct flag_info_list 0291 { 0292 flag_type with; 0293 const char *name; 0294 bool valid; 0295 struct flag_info_list *next; 0296 }; 0297 0298 /* Section flag info. */ 0299 struct flag_info 0300 { 0301 flagword only_with_flags; 0302 flagword not_with_flags; 0303 struct flag_info_list *flag_list; 0304 bool flags_initialized; 0305 }; 0306 0307 struct bfd_elf_dynamic_list; 0308 struct bfd_elf_version_tree; 0309 0310 /* Types of output. */ 0311 0312 enum output_type 0313 { 0314 type_pde, 0315 type_pie, 0316 type_relocatable, 0317 type_dll, 0318 }; 0319 0320 #define bfd_link_pde(info) ((info)->type == type_pde) 0321 #define bfd_link_dll(info) ((info)->type == type_dll) 0322 #define bfd_link_relocatable(info) ((info)->type == type_relocatable) 0323 #define bfd_link_pie(info) ((info)->type == type_pie) 0324 #define bfd_link_executable(info) (bfd_link_pde (info) || bfd_link_pie (info)) 0325 #define bfd_link_pic(info) (bfd_link_dll (info) || bfd_link_pie (info)) 0326 0327 /* This structure holds all the information needed to communicate 0328 between BFD and the linker when doing a link. */ 0329 0330 struct bfd_link_info 0331 { 0332 /* Output type. */ 0333 ENUM_BITFIELD (output_type) type : 2; 0334 0335 /* TRUE if BFD should pre-bind symbols in a shared object. */ 0336 unsigned int symbolic: 1; 0337 0338 /* TRUE if BFD should export all symbols in the dynamic symbol table 0339 of an executable, rather than only those used. */ 0340 unsigned int export_dynamic: 1; 0341 0342 /* TRUE if a default symbol version should be created and used for 0343 exported symbols. */ 0344 unsigned int create_default_symver: 1; 0345 0346 /* TRUE if unreferenced sections should be removed. */ 0347 unsigned int gc_sections: 1; 0348 0349 /* TRUE if exported symbols should be kept during section gc. */ 0350 unsigned int gc_keep_exported: 1; 0351 0352 /* TRUE if every symbol should be reported back via the notice 0353 callback. */ 0354 unsigned int notice_all: 1; 0355 0356 /* TRUE if the LTO plugin is active. */ 0357 unsigned int lto_plugin_active: 1; 0358 0359 /* TRUE if all LTO IR symbols have been read. */ 0360 unsigned int lto_all_symbols_read : 1; 0361 0362 /* TRUE if global symbols in discarded sections should be stripped. */ 0363 unsigned int strip_discarded: 1; 0364 0365 /* TRUE if all data symbols should be dynamic. */ 0366 unsigned int dynamic_data: 1; 0367 0368 /* TRUE if section groups should be resolved. */ 0369 unsigned int resolve_section_groups: 1; 0370 0371 /* Set if output file is big-endian, or if that is unknown, from 0372 the command line or first input file endianness. */ 0373 unsigned int big_endian : 1; 0374 0375 /* Which symbols to strip. */ 0376 ENUM_BITFIELD (bfd_link_strip) strip : 2; 0377 0378 /* Which local symbols to discard. */ 0379 ENUM_BITFIELD (bfd_link_discard) discard : 2; 0380 0381 /* Whether to generate ELF common symbols with the STT_COMMON type. */ 0382 ENUM_BITFIELD (bfd_link_elf_stt_common) elf_stt_common : 2; 0383 0384 /* Criteria for skipping symbols when determining 0385 whether to include an object from an archive. */ 0386 ENUM_BITFIELD (bfd_link_common_skip_ar_symbols) common_skip_ar_symbols : 2; 0387 0388 /* What to do with unresolved symbols in an object file. 0389 When producing executables the default is GENERATE_ERROR. 0390 When producing shared libraries the default is IGNORE. The 0391 assumption with shared libraries is that the reference will be 0392 resolved at load/execution time. */ 0393 ENUM_BITFIELD (report_method) unresolved_syms_in_objects : 2; 0394 0395 /* What to do with unresolved symbols in a shared library. 0396 The same defaults apply. */ 0397 ENUM_BITFIELD (report_method) unresolved_syms_in_shared_libs : 2; 0398 0399 /* TRUE if unresolved symbols are to be warned, rather than errored. */ 0400 unsigned int warn_unresolved_syms: 1; 0401 0402 /* TRUE if shared objects should be linked directly, not shared. */ 0403 unsigned int static_link: 1; 0404 0405 /* TRUE if symbols should be retained in memory, FALSE if they 0406 should be freed and reread. */ 0407 unsigned int keep_memory: 1; 0408 0409 /* TRUE if BFD should generate relocation information in the final 0410 executable. */ 0411 unsigned int emitrelocations: 1; 0412 0413 /* TRUE if PT_GNU_RELRO segment should be created. */ 0414 unsigned int relro: 1; 0415 0416 /* TRUE if DT_RELR should be enabled for compact relative 0417 relocations. */ 0418 unsigned int enable_dt_relr: 1; 0419 0420 /* TRUE if separate code segment should be created. */ 0421 unsigned int separate_code: 1; 0422 0423 /* Nonzero if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment 0424 should be created. 1 for DWARF2 tables, 2 for compact tables. */ 0425 unsigned int eh_frame_hdr_type: 2; 0426 0427 /* What to do with DT_TEXTREL in output. */ 0428 ENUM_BITFIELD (textrel_check_method) textrel_check: 2; 0429 0430 /* TRUE if .hash section should be created. */ 0431 unsigned int emit_hash: 1; 0432 0433 /* TRUE if .gnu.hash section should be created. */ 0434 unsigned int emit_gnu_hash: 1; 0435 0436 /* If TRUE reduce memory overheads, at the expense of speed. This will 0437 cause map file generation to use an O(N^2) algorithm and disable 0438 caching ELF symbol buffer. */ 0439 unsigned int reduce_memory_overheads: 1; 0440 0441 /* TRUE if the output file should be in a traditional format. This 0442 is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag 0443 on the output file, but may be checked when reading the input 0444 files. */ 0445 unsigned int traditional_format: 1; 0446 0447 /* TRUE if non-PLT relocs should be merged into one reloc section 0448 and sorted so that relocs against the same symbol come together. */ 0449 unsigned int combreloc: 1; 0450 0451 /* TRUE if a default symbol version should be created and used for 0452 imported symbols. */ 0453 unsigned int default_imported_symver: 1; 0454 0455 /* TRUE if the new ELF dynamic tags are enabled. */ 0456 unsigned int new_dtags: 1; 0457 0458 /* FALSE if .eh_frame unwind info should be generated for PLT and other 0459 linker created sections, TRUE if it should be omitted. */ 0460 unsigned int no_ld_generated_unwind_info: 1; 0461 0462 /* TRUE if BFD should generate a "task linked" object file, 0463 similar to relocatable but also with globals converted to 0464 statics. */ 0465 unsigned int task_link: 1; 0466 0467 /* TRUE if ok to have multiple definitions, without warning. */ 0468 unsigned int allow_multiple_definition: 1; 0469 0470 /* TRUE if multiple definition of absolute symbols (eg. from -R) should 0471 be reported. */ 0472 unsigned int prohibit_multiple_definition_absolute: 1; 0473 0474 /* TRUE if multiple definitions should only warn. */ 0475 unsigned int warn_multiple_definition: 1; 0476 0477 /* TRUE if ok to have version with no definition. */ 0478 unsigned int allow_undefined_version: 1; 0479 0480 /* TRUE if some symbols have to be dynamic, controlled by 0481 --dynamic-list command line options. */ 0482 unsigned int dynamic: 1; 0483 0484 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W|PF_X 0485 flags. */ 0486 unsigned int execstack: 1; 0487 0488 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W 0489 flags. */ 0490 unsigned int noexecstack: 1; 0491 0492 /* TRUE if we want to produced optimized output files. This might 0493 need much more time and therefore must be explicitly selected. */ 0494 unsigned int optimize: 1; 0495 0496 /* TRUE if user should be informed of removed unreferenced sections. */ 0497 unsigned int print_gc_sections: 1; 0498 0499 /* TRUE if we should warn alternate ELF machine code. */ 0500 unsigned int warn_alternate_em: 1; 0501 0502 /* TRUE if the linker script contained an explicit PHDRS command. */ 0503 unsigned int user_phdrs: 1; 0504 0505 /* TRUE if program headers ought to be loaded. */ 0506 unsigned int load_phdrs: 1; 0507 0508 /* TRUE if we should check relocations after all input files have 0509 been opened. */ 0510 unsigned int check_relocs_after_open_input: 1; 0511 0512 /* TRUE if generation of .interp/PT_INTERP should be suppressed. */ 0513 unsigned int nointerp: 1; 0514 0515 /* TRUE if common symbols should be treated as undefined. */ 0516 unsigned int inhibit_common_definition : 1; 0517 0518 /* TRUE if "-Map map" is passed to linker. */ 0519 unsigned int has_map_file : 1; 0520 0521 /* TRUE if "--enable-non-contiguous-regions" is passed to the 0522 linker. */ 0523 unsigned int non_contiguous_regions : 1; 0524 0525 /* TRUE if "--enable-non-contiguous-regions-warnings" is passed to 0526 the linker. */ 0527 unsigned int non_contiguous_regions_warnings : 1; 0528 0529 /* TRUE if all symbol names should be unique. */ 0530 unsigned int unique_symbol : 1; 0531 0532 /* TRUE if maxpagesize is set on command-line. */ 0533 unsigned int maxpagesize_is_set : 1; 0534 0535 /* TRUE if commonpagesize is set on command-line. */ 0536 unsigned int commonpagesize_is_set : 1; 0537 0538 /* Char that may appear as the first char of a symbol, but should be 0539 skipped (like symbol_leading_char) when looking up symbols in 0540 wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ 0541 char wrap_char; 0542 0543 /* Separator between archive and filename in linker script filespecs. */ 0544 char path_separator; 0545 0546 /* Compress DWARF debug sections. */ 0547 enum compressed_debug_section_type compress_debug; 0548 0549 /* Default stack size. Zero means default (often zero itself), -1 0550 means explicitly zero-sized. */ 0551 bfd_signed_vma stacksize; 0552 0553 /* Enable or disable target specific optimizations. 0554 0555 Not all targets have optimizations to enable. 0556 0557 Normally these optimizations are disabled by default but some targets 0558 prefer to enable them by default. So this field is a tri-state variable. 0559 The values are: 0560 0561 zero: Enable the optimizations (either from --relax being specified on 0562 the command line or the backend's before_allocation emulation function. 0563 0564 positive: The user has requested that these optimizations be disabled. 0565 (Via the --no-relax command line option). 0566 0567 negative: The optimizations are disabled. (Set when initializing the 0568 args_type structure in ldmain.c:main. */ 0569 signed int disable_target_specific_optimizations; 0570 0571 /* Function callbacks. */ 0572 const struct bfd_link_callbacks *callbacks; 0573 0574 /* Hash table handled by BFD. */ 0575 struct bfd_link_hash_table *hash; 0576 0577 /* Hash table of symbols to keep. This is NULL unless strip is 0578 strip_some. */ 0579 struct bfd_hash_table *keep_hash; 0580 0581 /* Hash table of symbols to report back via the notice callback. If 0582 this is NULL, and notice_all is FALSE, then no symbols are 0583 reported back. */ 0584 struct bfd_hash_table *notice_hash; 0585 0586 /* Hash table of symbols which are being wrapped (the --wrap linker 0587 option). If this is NULL, no symbols are being wrapped. */ 0588 struct bfd_hash_table *wrap_hash; 0589 0590 /* Hash table of symbols which may be left unresolved during 0591 a link. If this is NULL, no symbols can be left unresolved. */ 0592 struct bfd_hash_table *ignore_hash; 0593 0594 /* The output BFD. */ 0595 bfd *output_bfd; 0596 0597 /* The import library generated. */ 0598 bfd *out_implib_bfd; 0599 0600 /* The list of input BFD's involved in the link. These are chained 0601 together via the link.next field. */ 0602 bfd *input_bfds; 0603 bfd **input_bfds_tail; 0604 0605 /* If a symbol should be created for each input BFD, this is section 0606 where those symbols should be placed. It must be a section in 0607 the output BFD. It may be NULL, in which case no such symbols 0608 will be created. This is to support CREATE_OBJECT_SYMBOLS in the 0609 linker command language. */ 0610 asection *create_object_symbols_section; 0611 0612 /* List of global symbol names that are starting points for marking 0613 sections against garbage collection. */ 0614 struct bfd_sym_chain *gc_sym_list; 0615 0616 /* If a base output file is wanted, then this points to it */ 0617 void *base_file; 0618 0619 /* The function to call when the executable or shared object is 0620 loaded. */ 0621 const char *init_function; 0622 0623 /* The function to call when the executable or shared object is 0624 unloaded. */ 0625 const char *fini_function; 0626 0627 /* Number of relaxation passes. Usually only one relaxation pass 0628 is needed. But a backend can have as many relaxation passes as 0629 necessary. During bfd_relax_section call, it is set to the 0630 current pass, starting from 0. */ 0631 int relax_pass; 0632 0633 /* Number of relaxation trips. This number is incremented every 0634 time the relaxation pass is restarted due to a previous 0635 relaxation returning true in *AGAIN. */ 0636 int relax_trip; 0637 0638 /* > 0 to treat protected data defined in the shared library as 0639 reference external. 0 to treat it as internal. -1 to let 0640 backend to decide. */ 0641 int extern_protected_data; 0642 0643 /* 1 to make undefined weak symbols dynamic when building a dynamic 0644 object. 0 to resolve undefined weak symbols to zero. -1 to let 0645 the backend decide. */ 0646 int dynamic_undefined_weak; 0647 0648 /* Non-zero if auto-import thunks for DATA items in pei386 DLLs 0649 should be generated/linked against. Set to 1 if this feature 0650 is explicitly requested by the user, -1 if enabled by default. */ 0651 int pei386_auto_import; 0652 0653 /* Non-zero if runtime relocs for DATA items with non-zero addends 0654 in pei386 DLLs should be generated. Set to 1 if this feature 0655 is explicitly requested by the user, -1 if enabled by default. */ 0656 int pei386_runtime_pseudo_reloc; 0657 0658 /* How many spare .dynamic DT_NULL entries should be added? */ 0659 unsigned int spare_dynamic_tags; 0660 0661 /* GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS control: 0662 > 1: Turn on by -z indirect-extern-access or by backend. 0663 == 1: Turn on by an input. 0664 0: Turn off. 0665 < 0: Turn on if it is set on any inputs or let backend to 0666 decide. */ 0667 int indirect_extern_access; 0668 0669 /* Non-zero if executable should not contain copy relocs. 0670 > 1: Implied by indirect_extern_access. 0671 == 1: Turn on by -z nocopyreloc. 0672 0: Turn off. 0673 Setting this to non-zero may result in a non-sharable text 0674 segment. */ 0675 int nocopyreloc; 0676 0677 /* Pointer to the GNU_PROPERTY_1_NEEDED property in memory. */ 0678 bfd_byte *needed_1_p; 0679 0680 /* May be used to set DT_FLAGS for ELF. */ 0681 bfd_vma flags; 0682 0683 /* May be used to set DT_FLAGS_1 for ELF. */ 0684 bfd_vma flags_1; 0685 0686 /* May be used to set DT_GNU_FLAGS_1 for ELF. */ 0687 bfd_vma gnu_flags_1; 0688 0689 /* TRUE if references to __start_/__stop_ synthesized symbols do not 0690 specially retain C identifier named sections. */ 0691 int start_stop_gc; 0692 0693 /* May be used to set ELF visibility for __start_* / __stop_. */ 0694 unsigned int start_stop_visibility; 0695 0696 /* The maximum page size for ELF. */ 0697 bfd_vma maxpagesize; 0698 0699 /* The common page size for ELF. */ 0700 bfd_vma commonpagesize; 0701 0702 /* Start and end of RELRO region. */ 0703 bfd_vma relro_start, relro_end; 0704 0705 /* List of symbols should be dynamic. */ 0706 struct bfd_elf_dynamic_list *dynamic_list; 0707 0708 /* The version information. */ 0709 struct bfd_elf_version_tree *version_info; 0710 0711 /* Size of cache. Backend can use it to keep strace cache size. */ 0712 bfd_size_type cache_size; 0713 0714 /* The maximum cache size. Backend can use cache_size and and 0715 max_cache_size to decide if keep_memory should be honored. */ 0716 bfd_size_type max_cache_size; 0717 }; 0718 0719 /* Some forward-definitions used by some callbacks. */ 0720 0721 struct elf_strtab_hash; 0722 struct elf_internal_sym; 0723 0724 /* This structures holds a set of callback functions. These are called 0725 by the BFD linker routines. */ 0726 0727 struct bfd_link_callbacks 0728 { 0729 /* A function which is called when an object is added from an 0730 archive. ABFD is the archive element being added. NAME is the 0731 name of the symbol which caused the archive element to be pulled 0732 in. This function may set *SUBSBFD to point to an alternative 0733 BFD from which symbols should in fact be added in place of the 0734 original BFD's symbols. Returns TRUE if the object should be 0735 added, FALSE if it should be skipped. */ 0736 bool (*add_archive_element) 0737 (struct bfd_link_info *, bfd *abfd, const char *name, bfd **subsbfd); 0738 /* A function which is called when a symbol is found with multiple 0739 definitions. H is the symbol which is defined multiple times. 0740 NBFD is the new BFD, NSEC is the new section, and NVAL is the new 0741 value. NSEC may be bfd_com_section or bfd_ind_section. */ 0742 void (*multiple_definition) 0743 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 0744 bfd *nbfd, asection *nsec, bfd_vma nval); 0745 /* A function which is called when a common symbol is defined 0746 multiple times. H is the symbol appearing multiple times. 0747 NBFD is the BFD of the new symbol. NTYPE is the type of the new 0748 symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 0749 bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 0750 is the size of the new symbol. */ 0751 void (*multiple_common) 0752 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 0753 bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize); 0754 /* A function which is called to add a symbol to a set. ENTRY is 0755 the link hash table entry for the set itself (e.g., 0756 __CTOR_LIST__). RELOC is the relocation to use for an entry in 0757 the set when generating a relocatable file, and is also used to 0758 get the size of the entry when generating an executable file. 0759 ABFD, SEC and VALUE identify the value to add to the set. */ 0760 void (*add_to_set) 0761 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 0762 bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value); 0763 /* A function which is called when the name of a g++ constructor or 0764 destructor is found. This is only called by some object file 0765 formats. CONSTRUCTOR is TRUE for a constructor, FALSE for a 0766 destructor. This will use BFD_RELOC_CTOR when generating a 0767 relocatable file. NAME is the name of the symbol found. ABFD, 0768 SECTION and VALUE are the value of the symbol. */ 0769 void (*constructor) 0770 (struct bfd_link_info *, bool constructor, const char *name, 0771 bfd *abfd, asection *sec, bfd_vma value); 0772 /* A function which is called to issue a linker warning. For 0773 example, this is called when there is a reference to a warning 0774 symbol. WARNING is the warning to be issued. SYMBOL is the name 0775 of the symbol which triggered the warning; it may be NULL if 0776 there is none. ABFD, SECTION and ADDRESS identify the location 0777 which trigerred the warning; either ABFD or SECTION or both may 0778 be NULL if the location is not known. */ 0779 void (*warning) 0780 (struct bfd_link_info *, const char *warning, const char *symbol, 0781 bfd *abfd, asection *section, bfd_vma address); 0782 /* A function which is called when a relocation is attempted against 0783 an undefined symbol. NAME is the symbol which is undefined. 0784 ABFD, SECTION and ADDRESS identify the location from which the 0785 reference is made. IS_FATAL indicates whether an undefined symbol is 0786 a fatal error or not. In some cases SECTION may be NULL. */ 0787 void (*undefined_symbol) 0788 (struct bfd_link_info *, const char *name, bfd *abfd, 0789 asection *section, bfd_vma address, bool is_fatal); 0790 /* A function which is called when a reloc overflow occurs. ENTRY is 0791 the link hash table entry for the symbol the reloc is against. 0792 NAME is the name of the local symbol or section the reloc is 0793 against, RELOC_NAME is the name of the relocation, and ADDEND is 0794 any addend that is used. ABFD, SECTION and ADDRESS identify the 0795 location at which the overflow occurs; if this is the result of a 0796 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 0797 ABFD will be NULL. */ 0798 void (*reloc_overflow) 0799 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 0800 const char *name, const char *reloc_name, bfd_vma addend, 0801 bfd *abfd, asection *section, bfd_vma address); 0802 /* A function which is called when a dangerous reloc is performed. 0803 MESSAGE is an appropriate message. 0804 ABFD, SECTION and ADDRESS identify the location at which the 0805 problem occurred; if this is the result of a 0806 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 0807 ABFD will be NULL. */ 0808 void (*reloc_dangerous) 0809 (struct bfd_link_info *, const char *message, 0810 bfd *abfd, asection *section, bfd_vma address); 0811 /* A function which is called when a reloc is found to be attached 0812 to a symbol which is not being written out. NAME is the name of 0813 the symbol. ABFD, SECTION and ADDRESS identify the location of 0814 the reloc; if this is the result of a 0815 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 0816 ABFD will be NULL. */ 0817 void (*unattached_reloc) 0818 (struct bfd_link_info *, const char *name, 0819 bfd *abfd, asection *section, bfd_vma address); 0820 /* A function which is called when a symbol in notice_hash is 0821 defined or referenced. H is the symbol, INH the indirect symbol 0822 if applicable. ABFD, SECTION and ADDRESS are the (new) value of 0823 the symbol. If SECTION is bfd_und_section, this is a reference. 0824 FLAGS are the symbol BSF_* flags. */ 0825 bool (*notice) 0826 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 0827 struct bfd_link_hash_entry *inh, 0828 bfd *abfd, asection *section, bfd_vma address, flagword flags); 0829 /* Error or warning link info message. */ 0830 void (*einfo) 0831 (const char *fmt, ...); 0832 /* General link info message. */ 0833 void (*info) 0834 (const char *fmt, ...); 0835 /* Message to be printed in linker map file. */ 0836 void (*minfo) 0837 (const char *fmt, ...); 0838 /* This callback provides a chance for users of the BFD library to 0839 override its decision about whether to place two adjacent sections 0840 into the same segment. */ 0841 bool (*override_segment_assignment) 0842 (struct bfd_link_info *, bfd * abfd, 0843 asection * current_section, asection * previous_section, 0844 bool new_segment); 0845 /* This callback provides a chance for callers of the BFD to examine the 0846 ELF (dynamic) string table once it is complete. */ 0847 void (*examine_strtab) 0848 (struct elf_strtab_hash *symstrtab); 0849 /* This callback is called just before a symbol is swapped out, so that the 0850 CTF machinery can look up symbols during construction. The name is 0851 already an external strtab offset at this point. */ 0852 void (*ctf_new_symbol) 0853 (int symidx, struct elf_internal_sym *sym); 0854 /* Likewise, for dynamic symbols. */ 0855 void (*ctf_new_dynsym) 0856 (int symidx, struct elf_internal_sym *sym); 0857 /* This callback should emit the CTF section into a non-loadable section in 0858 the output BFD named .ctf or a name beginning with ".ctf.". */ 0859 void (*emit_ctf) 0860 (void); 0861 }; 0862 0863 /* The linker builds link_order structures which tell the code how to 0864 include input data in the output file. */ 0865 0866 /* These are the types of link_order structures. */ 0867 0868 enum bfd_link_order_type 0869 { 0870 bfd_undefined_link_order, /* Undefined. */ 0871 bfd_indirect_link_order, /* Built from a section. */ 0872 bfd_data_link_order, /* Set to explicit data. */ 0873 bfd_section_reloc_link_order, /* Relocate against a section. */ 0874 bfd_symbol_reloc_link_order /* Relocate against a symbol. */ 0875 }; 0876 0877 /* This is the link_order structure itself. These form a chain 0878 attached to the output section whose contents they are describing. */ 0879 0880 struct bfd_link_order 0881 { 0882 /* Next link_order in chain. */ 0883 struct bfd_link_order *next; 0884 /* Type of link_order. */ 0885 enum bfd_link_order_type type; 0886 /* Offset within output section in bytes. */ 0887 bfd_vma offset; 0888 /* Size within output section in octets. */ 0889 bfd_size_type size; 0890 /* Type specific information. */ 0891 union 0892 { 0893 struct 0894 { 0895 /* Section to include. If this is used, then 0896 section->output_section must be the section the 0897 link_order is attached to, section->output_offset must 0898 equal the link_order offset field, and section->size 0899 must equal the link_order size field. Maybe these 0900 restrictions should be relaxed someday. */ 0901 asection *section; 0902 } indirect; 0903 struct 0904 { 0905 /* Size of contents, or zero when contents should be filled by 0906 the architecture-dependent fill function. 0907 A non-zero value allows filling of the output section 0908 with an arbitrary repeated pattern. */ 0909 unsigned int size; 0910 /* Data to put into file. */ 0911 bfd_byte *contents; 0912 } data; 0913 struct 0914 { 0915 /* Description of reloc to generate. Used for 0916 bfd_section_reloc_link_order and 0917 bfd_symbol_reloc_link_order. */ 0918 struct bfd_link_order_reloc *p; 0919 } reloc; 0920 } u; 0921 }; 0922 0923 /* A linker order of type bfd_section_reloc_link_order or 0924 bfd_symbol_reloc_link_order means to create a reloc against a 0925 section or symbol, respectively. This is used to implement -Ur to 0926 generate relocs for the constructor tables. The 0927 bfd_link_order_reloc structure describes the reloc that BFD should 0928 create. It is similar to a arelent, but I didn't use arelent 0929 because the linker does not know anything about most symbols, and 0930 any asymbol structure it creates will be partially meaningless. 0931 This information could logically be in the bfd_link_order struct, 0932 but I didn't want to waste the space since these types of relocs 0933 are relatively rare. */ 0934 0935 struct bfd_link_order_reloc 0936 { 0937 /* Reloc type. */ 0938 bfd_reloc_code_real_type reloc; 0939 0940 union 0941 { 0942 /* For type bfd_section_reloc_link_order, this is the section 0943 the reloc should be against. This must be a section in the 0944 output BFD, not any of the input BFDs. */ 0945 asection *section; 0946 /* For type bfd_symbol_reloc_link_order, this is the name of the 0947 symbol the reloc should be against. */ 0948 const char *name; 0949 } u; 0950 0951 /* Addend to use. The object file should contain zero. The BFD 0952 backend is responsible for filling in the contents of the object 0953 file correctly. For some object file formats (e.g., COFF) the 0954 addend must be stored into in the object file, and for some 0955 (e.g., SPARC a.out) it is kept in the reloc. */ 0956 bfd_vma addend; 0957 }; 0958 0959 /* Allocate a new link_order for a section. */ 0960 extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *); 0961 0962 struct bfd_section_already_linked; 0963 0964 extern bool bfd_section_already_linked_table_init (void); 0965 extern void bfd_section_already_linked_table_free (void); 0966 extern bool _bfd_handle_already_linked 0967 (struct bfd_section *, struct bfd_section_already_linked *, 0968 struct bfd_link_info *); 0969 0970 extern struct bfd_section *_bfd_nearby_section 0971 (bfd *, struct bfd_section *, bfd_vma); 0972 0973 extern void _bfd_fix_excluded_sec_syms 0974 (bfd *, struct bfd_link_info *); 0975 0976 /* These structures are used to describe version information for the 0977 ELF linker. These structures could be manipulated entirely inside 0978 BFD, but it would be a pain. Instead, the regular linker sets up 0979 these structures, and then passes them into BFD. */ 0980 0981 /* Glob pattern for a version. */ 0982 0983 struct bfd_elf_version_expr 0984 { 0985 /* Next glob pattern for this version. */ 0986 struct bfd_elf_version_expr *next; 0987 /* Glob pattern. */ 0988 const char *pattern; 0989 /* Set if pattern is not a glob. */ 0990 unsigned int literal : 1; 0991 /* Defined by ".symver". */ 0992 unsigned int symver : 1; 0993 /* Defined by version script. */ 0994 unsigned int script : 1; 0995 /* Pattern type. */ 0996 #define BFD_ELF_VERSION_C_TYPE 1 0997 #define BFD_ELF_VERSION_CXX_TYPE 2 0998 #define BFD_ELF_VERSION_JAVA_TYPE 4 0999 unsigned int mask : 3; 1000 }; 1001 1002 struct bfd_elf_version_expr_head 1003 { 1004 /* List of all patterns, both wildcards and non-wildcards. */ 1005 struct bfd_elf_version_expr *list; 1006 /* Hash table for non-wildcards. */ 1007 void *htab; 1008 /* Remaining patterns. */ 1009 struct bfd_elf_version_expr *remaining; 1010 /* What kind of pattern types are present in list (bitmask). */ 1011 unsigned int mask; 1012 }; 1013 1014 /* Version dependencies. */ 1015 1016 struct bfd_elf_version_deps 1017 { 1018 /* Next dependency for this version. */ 1019 struct bfd_elf_version_deps *next; 1020 /* The version which this version depends upon. */ 1021 struct bfd_elf_version_tree *version_needed; 1022 }; 1023 1024 /* A node in the version tree. */ 1025 1026 struct bfd_elf_version_tree 1027 { 1028 /* Next version. */ 1029 struct bfd_elf_version_tree *next; 1030 /* Name of this version. */ 1031 const char *name; 1032 /* Version number. */ 1033 unsigned int vernum; 1034 /* Regular expressions for global symbols in this version. */ 1035 struct bfd_elf_version_expr_head globals; 1036 /* Regular expressions for local symbols in this version. */ 1037 struct bfd_elf_version_expr_head locals; 1038 /* List of versions which this version depends upon. */ 1039 struct bfd_elf_version_deps *deps; 1040 /* Index of the version name. This is used within BFD. */ 1041 unsigned int name_indx; 1042 /* Whether this version tree was used. This is used within BFD. */ 1043 int used; 1044 /* Matching hook. */ 1045 struct bfd_elf_version_expr *(*match) 1046 (struct bfd_elf_version_expr_head *head, 1047 struct bfd_elf_version_expr *prev, const char *sym); 1048 }; 1049 1050 struct bfd_elf_dynamic_list 1051 { 1052 struct bfd_elf_version_expr_head head; 1053 struct bfd_elf_version_expr *(*match) 1054 (struct bfd_elf_version_expr_head *head, 1055 struct bfd_elf_version_expr *prev, const char *sym); 1056 }; 1057 1058 #endif
[ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
This page was automatically generated by the 2.3.5 LXR engine. The LXR team |