1 /* bfdlink.h -- header file for BFD link routines 2 Copyright (C) 1993-2024 Free Software Foundation, Inc. 3 Written by Steve Chamberlain and Ian Lance Taylor, 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 3 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., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #ifndef BFDLINK_H 23 #define BFDLINK_H 24 25 /* Which symbols to strip during a link. */ 26 enum bfd_link_strip 27 { 28 strip_none, /* Don't strip any symbols. */ 29 strip_debugger, /* Strip debugging symbols. */ 30 strip_some, /* keep_hash is the list of symbols to keep. */ 31 strip_all /* Strip all symbols. */ 32 }; 33 34 /* Which local symbols to discard during a link. This is irrelevant 35 if strip_all is used. */ 36 enum bfd_link_discard 37 { 38 discard_sec_merge, /* Discard local temporary symbols in SEC_MERGE 39 sections. */ 40 discard_none, /* Don't discard any locals. */ 41 discard_l, /* Discard local temporary symbols. */ 42 discard_all /* Discard all locals. */ 43 }; 44 45 enum notice_asneeded_action { 46 notice_as_needed, 47 notice_not_needed, 48 notice_needed 49 }; 50 51 /* Whether to generate ELF common symbols with the STT_COMMON type 52 during a relocatable link. */ 53 enum bfd_link_elf_stt_common 54 { 55 unchanged, 56 elf_stt_common, 57 no_elf_stt_common 58 }; 59 60 /* Describes the type of hash table entry structure being used. 61 Different hash table structure have different fields and so 62 support different linking features. */ 63 enum bfd_link_hash_table_type 64 { 65 bfd_link_generic_hash_table, 66 bfd_link_elf_hash_table 67 }; 68 69 /* These are the possible types of an entry in the BFD link hash 70 table. */ 71 72 enum bfd_link_hash_type 73 { 74 bfd_link_hash_new, /* Symbol is new. */ 75 bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ 76 bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ 77 bfd_link_hash_defined, /* Symbol is defined. */ 78 bfd_link_hash_defweak, /* Symbol is weak and defined. */ 79 bfd_link_hash_common, /* Symbol is common. */ 80 bfd_link_hash_indirect, /* Symbol is an indirect link. */ 81 bfd_link_hash_warning /* Like indirect, but warn if referenced. */ 82 }; 83 84 enum bfd_link_common_skip_ar_symbols 85 { 86 bfd_link_common_skip_none, 87 bfd_link_common_skip_text, 88 bfd_link_common_skip_data, 89 bfd_link_common_skip_all 90 }; 91 92 struct bfd_link_hash_common_entry 93 { 94 unsigned int alignment_power; /* Alignment. */ 95 asection *section; /* Symbol section. */ 96 }; 97 98 /* The linking routines use a hash table which uses this structure for 99 its elements. */ 100 101 struct bfd_link_hash_entry 102 { 103 /* Base hash table entry structure. */ 104 struct bfd_hash_entry root; 105 106 /* Type of this entry. */ 107 ENUM_BITFIELD (bfd_link_hash_type) type : 8; 108 109 /* Symbol is referenced in a normal regular object file, 110 as distinct from a LTO IR object file. */ 111 unsigned int non_ir_ref_regular : 1; 112 113 /* Symbol is referenced in a normal dynamic object file, 114 as distinct from a LTO IR object file. */ 115 unsigned int non_ir_ref_dynamic : 1; 116 117 /* The symbol, SYM, is referenced by __real_SYM in an object file. */ 118 unsigned int ref_real : 1; 119 120 /* Symbol is a built-in define. These will be overridden by PROVIDE 121 in a linker script. */ 122 unsigned int linker_def : 1; 123 124 /* Symbol defined in a linker script. */ 125 unsigned int ldscript_def : 1; 126 127 /* Symbol will be converted from absolute to section-relative. Set for 128 symbols defined by a script from "dot" (also SEGMENT_START or ORIGIN) 129 outside of an output section statement. */ 130 unsigned int rel_from_abs : 1; 131 132 /* A union of information depending upon the type. */ 133 union 134 { 135 /* Nothing is kept for bfd_hash_new. */ 136 /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ 137 struct 138 { 139 /* Undefined and common symbols are kept in a linked list through 140 this field. This field is present in all of the union element 141 so that we don't need to remove entries from the list when we 142 change their type. Removing entries would either require the 143 list to be doubly linked, which would waste more memory, or 144 require a traversal. When an undefined or common symbol is 145 created, it should be added to this list, the head of which is in 146 the link hash table itself. As symbols are defined, they need 147 not be removed from the list; anything which reads the list must 148 doublecheck the symbol type. 149 150 Weak symbols are not kept on this list. 151 152 Defined and defweak symbols use this field as a reference marker. 153 If the field is not NULL, or this structure is the tail of the 154 undefined symbol list, the symbol has been referenced. If the 155 symbol is undefined and becomes defined, this field will 156 automatically be non-NULL since the symbol will have been on the 157 undefined symbol list. */ 158 struct bfd_link_hash_entry *next; 159 /* BFD symbol was found in. */ 160 bfd *abfd; 161 } undef; 162 /* bfd_link_hash_defined, bfd_link_hash_defweak. */ 163 struct 164 { 165 struct bfd_link_hash_entry *next; 166 /* Symbol section. */ 167 asection *section; 168 /* Symbol value. */ 169 bfd_vma value; 170 } def; 171 /* bfd_link_hash_indirect, bfd_link_hash_warning. */ 172 struct 173 { 174 struct bfd_link_hash_entry *next; 175 /* Real symbol. */ 176 struct bfd_link_hash_entry *link; 177 /* Warning message (bfd_link_hash_warning only). */ 178 const char *warning; 179 } i; 180 /* bfd_link_hash_common. */ 181 struct 182 { 183 struct bfd_link_hash_entry *next; 184 /* The linker needs to know three things about common 185 symbols: the size, the alignment, and the section in 186 which the symbol should be placed. We store the size 187 here, and we allocate a small structure to hold the 188 section and the alignment. The alignment is stored as a 189 power of two. We don't store all the information 190 directly because we don't want to increase the size of 191 the union; this structure is a major space user in the 192 linker. */ 193 struct bfd_link_hash_common_entry *p; 194 /* Common symbol size. */ 195 bfd_size_type size; 196 } c; 197 } u; 198 }; 199 200 /* This is the link hash table. It is a derived class of 201 bfd_hash_table. */ 202 203 struct bfd_link_hash_table 204 { 205 /* The hash table itself. */ 206 struct bfd_hash_table table; 207 /* A linked list of undefined and common symbols, linked through the 208 next field in the bfd_link_hash_entry structure. */ 209 struct bfd_link_hash_entry *undefs; 210 /* Entries are added to the tail of the undefs list. */ 211 struct bfd_link_hash_entry *undefs_tail; 212 /* Function to free the hash table on closing BFD. */ 213 void (*hash_table_free) (bfd *); 214 /* The type of the link hash table. */ 215 enum bfd_link_hash_table_type type; 216 }; 217 218 /* Look up an entry in a link hash table. If FOLLOW is TRUE, this 219 follows bfd_link_hash_indirect and bfd_link_hash_warning links to 220 the real symbol. */ 221 extern struct bfd_link_hash_entry *bfd_link_hash_lookup 222 (struct bfd_link_hash_table *, const char *, bool create, 223 bool copy, bool follow); 224 225 /* Look up an entry in the main linker hash table if the symbol might 226 be wrapped. This should only be used for references to an 227 undefined symbol, not for definitions of a symbol. */ 228 229 extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup 230 (bfd *, struct bfd_link_info *, const char *, bool, bool, bool); 231 232 /* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_" 233 and the remainder is found in wrap_hash, return the real symbol. */ 234 235 extern struct bfd_link_hash_entry *unwrap_hash_lookup 236 (struct bfd_link_info *, bfd *, struct bfd_link_hash_entry *); 237 238 /* Traverse a link hash table. */ 239 extern void bfd_link_hash_traverse 240 (struct bfd_link_hash_table *, 241 bool (*) (struct bfd_link_hash_entry *, void *), 242 void *); 243 244 /* Add an entry to the undefs list. */ 245 extern void bfd_link_add_undef 246 (struct bfd_link_hash_table *, struct bfd_link_hash_entry *); 247 248 /* Remove symbols from the undefs list that don't belong there. */ 249 extern void bfd_link_repair_undef_list 250 (struct bfd_link_hash_table *table); 251 252 /* Read symbols and cache symbol pointer array in outsymbols. */ 253 extern bool bfd_generic_link_read_symbols (bfd *); 254 255 /* Check the relocs in the BFD. Called after all the input 256 files have been loaded, and garbage collection has tagged 257 any unneeded sections. */ 258 extern bool bfd_link_check_relocs (bfd *,struct bfd_link_info *); 259 260 struct bfd_sym_chain 261 { 262 struct bfd_sym_chain *next; 263 const char *name; 264 }; 265 266 /* How to handle unresolved symbols. 267 There are four possibilities which are enumerated below: */ 268 enum report_method 269 { 270 /* This is the initial value when then link_info structure is created. 271 It allows the various stages of the linker to determine whether they 272 allowed to set the value. */ 273 RM_NOT_YET_SET = 0, 274 RM_IGNORE, 275 RM_DIAGNOSE, 276 }; 277 278 /* How to handle DT_TEXTREL. */ 279 280 enum textrel_check_method 281 { 282 textrel_check_none, 283 textrel_check_warning, 284 textrel_check_error 285 }; 286 287 #define bfd_link_textrel_check(info) \ 288 (info->textrel_check != textrel_check_none) 289 290 typedef enum {with_flags, without_flags} flag_type; 291 292 /* A section flag list. */ 293 struct flag_info_list 294 { 295 flag_type with; 296 const char *name; 297 bool valid; 298 struct flag_info_list *next; 299 }; 300 301 /* Section flag info. */ 302 struct flag_info 303 { 304 flagword only_with_flags; 305 flagword not_with_flags; 306 struct flag_info_list *flag_list; 307 bool flags_initialized; 308 }; 309 310 struct bfd_elf_dynamic_list; 311 struct bfd_elf_version_tree; 312 313 /* Types of output. */ 314 315 enum output_type 316 { 317 type_pde, 318 type_pie, 319 type_relocatable, 320 type_dll, 321 }; 322 323 #define bfd_link_pde(info) ((info)->type == type_pde) 324 #define bfd_link_dll(info) ((info)->type == type_dll) 325 #define bfd_link_relocatable(info) ((info)->type == type_relocatable) 326 #define bfd_link_pie(info) ((info)->type == type_pie) 327 #define bfd_link_executable(info) (bfd_link_pde (info) || bfd_link_pie (info)) 328 #define bfd_link_pic(info) (bfd_link_dll (info) || bfd_link_pie (info)) 329 330 /* This structure holds all the information needed to communicate 331 between BFD and the linker when doing a link. */ 332 333 struct bfd_link_info 334 { 335 /* Output type. */ 336 ENUM_BITFIELD (output_type) type : 2; 337 338 /* TRUE if BFD should pre-bind symbols in a shared object. */ 339 unsigned int symbolic: 1; 340 341 /* TRUE if BFD should export all symbols in the dynamic symbol table 342 of an executable, rather than only those used. */ 343 unsigned int export_dynamic: 1; 344 345 /* TRUE if a default symbol version should be created and used for 346 exported symbols. */ 347 unsigned int create_default_symver: 1; 348 349 /* TRUE if unreferenced sections should be removed. */ 350 unsigned int gc_sections: 1; 351 352 /* TRUE if exported symbols should be kept during section gc. */ 353 unsigned int gc_keep_exported: 1; 354 355 /* TRUE if every symbol should be reported back via the notice 356 callback. */ 357 unsigned int notice_all: 1; 358 359 /* TRUE if the LTO plugin is active. */ 360 unsigned int lto_plugin_active: 1; 361 362 /* TRUE if all LTO IR symbols have been read. */ 363 unsigned int lto_all_symbols_read : 1; 364 365 /* TRUE if global symbols in discarded sections should be stripped. */ 366 unsigned int strip_discarded: 1; 367 368 /* TRUE if all data symbols should be dynamic. */ 369 unsigned int dynamic_data: 1; 370 371 /* TRUE if section groups should be resolved. */ 372 unsigned int resolve_section_groups: 1; 373 374 /* Set if output file is big-endian, or if that is unknown, from 375 the command line or first input file endianness. */ 376 unsigned int big_endian : 1; 377 378 /* Which symbols to strip. */ 379 ENUM_BITFIELD (bfd_link_strip) strip : 2; 380 381 /* Which local symbols to discard. */ 382 ENUM_BITFIELD (bfd_link_discard) discard : 2; 383 384 /* Whether to generate ELF common symbols with the STT_COMMON type. */ 385 ENUM_BITFIELD (bfd_link_elf_stt_common) elf_stt_common : 2; 386 387 /* Criteria for skipping symbols when determining 388 whether to include an object from an archive. */ 389 ENUM_BITFIELD (bfd_link_common_skip_ar_symbols) common_skip_ar_symbols : 2; 390 391 /* What to do with unresolved symbols in an object file. 392 When producing executables the default is GENERATE_ERROR. 393 When producing shared libraries the default is IGNORE. The 394 assumption with shared libraries is that the reference will be 395 resolved at load/execution time. */ 396 ENUM_BITFIELD (report_method) unresolved_syms_in_objects : 2; 397 398 /* What to do with unresolved symbols in a shared library. 399 The same defaults apply. */ 400 ENUM_BITFIELD (report_method) unresolved_syms_in_shared_libs : 2; 401 402 /* TRUE if unresolved symbols are to be warned, rather than errored. */ 403 unsigned int warn_unresolved_syms: 1; 404 405 /* TRUE if shared objects should be linked directly, not shared. */ 406 unsigned int static_link: 1; 407 408 /* TRUE if symbols should be retained in memory, FALSE if they 409 should be freed and reread. */ 410 unsigned int keep_memory: 1; 411 412 /* TRUE if BFD should generate relocation information in the final 413 executable. */ 414 unsigned int emitrelocations: 1; 415 416 /* TRUE if PT_GNU_RELRO segment should be created. */ 417 unsigned int relro: 1; 418 419 /* TRUE if DT_RELR should be enabled for compact relative 420 relocations. */ 421 unsigned int enable_dt_relr: 1; 422 423 /* TRUE if separate code segment should be created. */ 424 unsigned int separate_code: 1; 425 426 /* Nonzero if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment 427 should be created. 1 for DWARF2 tables, 2 for compact tables. */ 428 unsigned int eh_frame_hdr_type: 2; 429 430 /* What to do with DT_TEXTREL in output. */ 431 ENUM_BITFIELD (textrel_check_method) textrel_check: 2; 432 433 /* TRUE if .hash section should be created. */ 434 unsigned int emit_hash: 1; 435 436 /* TRUE if .gnu.hash section should be created. */ 437 unsigned int emit_gnu_hash: 1; 438 439 /* If TRUE reduce memory overheads, at the expense of speed. This will 440 cause map file generation to use an O(N^2) algorithm and disable 441 caching ELF symbol buffer. */ 442 unsigned int reduce_memory_overheads: 1; 443 444 /* TRUE if the output file should be in a traditional format. This 445 is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag 446 on the output file, but may be checked when reading the input 447 files. */ 448 unsigned int traditional_format: 1; 449 450 /* TRUE if non-PLT relocs should be merged into one reloc section 451 and sorted so that relocs against the same symbol come together. */ 452 unsigned int combreloc: 1; 453 454 /* TRUE if a default symbol version should be created and used for 455 imported symbols. */ 456 unsigned int default_imported_symver: 1; 457 458 /* TRUE if the new ELF dynamic tags are enabled. */ 459 unsigned int new_dtags: 1; 460 461 /* FALSE if .eh_frame unwind info should be generated for PLT and other 462 linker created sections, TRUE if it should be omitted. */ 463 unsigned int no_ld_generated_unwind_info: 1; 464 465 /* TRUE if BFD should generate a "task linked" object file, 466 similar to relocatable but also with globals converted to 467 statics. */ 468 unsigned int task_link: 1; 469 470 /* TRUE if ok to have multiple definitions, without warning. */ 471 unsigned int allow_multiple_definition: 1; 472 473 /* TRUE if multiple definition of absolute symbols (eg. from -R) should 474 be reported. */ 475 unsigned int prohibit_multiple_definition_absolute: 1; 476 477 /* TRUE if multiple definitions should only warn. */ 478 unsigned int warn_multiple_definition: 1; 479 480 /* TRUE if ok to have version with no definition. */ 481 unsigned int allow_undefined_version: 1; 482 483 /* TRUE if some symbols have to be dynamic, controlled by 484 --dynamic-list command line options. */ 485 unsigned int dynamic: 1; 486 487 /* Set if the "-z execstack" option has been used to request that a 488 PT_GNU_STACK segment should be created with PF_R, PF_W and PF_X 489 flags set. 490 491 Note - if performing a relocatable link then a .note.GNU-stack 492 section will be created instead, if one does not exist already. 493 The section will have the SHF_EXECINSTR flag bit set. */ 494 unsigned int execstack: 1; 495 496 /* Set if the "-z noexecstack" option has been used to request that a 497 PT_GNU_STACK segment should be created with PF_R and PF_W flags. Or 498 a non-executable .note.GNU-stack section for relocateable links. 499 500 Note - this flag is not quite orthogonal to execstack, since both 501 of these flags can be 0. In this case a stack segment can still 502 be created, but it will only have the PF_X flag bit set if one or 503 more of the input files contains a .note.GNU-stack section with the 504 SHF_EXECINSTR flag bit set, or if the default behaviour for the 505 architecture is to create executable stacks. 506 507 The execstack and noexecstack flags should never both be 1. */ 508 unsigned int noexecstack: 1; 509 510 /* Tri-state variable: 511 0 => do not warn when creating an executable stack. 512 1 => always warn when creating an executable stack (for any reason). 513 2 => only warn when an executable stack has been requested an object 514 file and execstack is 0 or noexecstack is 1. 515 3 => not used. */ 516 unsigned int warn_execstack: 2; 517 /* TRUE if a warning generated because of warn_execstack should be instead 518 be treated as an error. */ 519 unsigned int error_execstack: 1; 520 521 /* TRUE if warnings should NOT be generated for TLS segments with eXecute 522 permission or LOAD segments with RWX permissions. */ 523 unsigned int no_warn_rwx_segments: 1; 524 /* TRUE if the user gave either --warn-rwx-segments or 525 --no-warn-rwx-segments on the linker command line. */ 526 unsigned int user_warn_rwx_segments: 1; 527 /* TRUE if warnings generated when no_warn_rwx_segements is 0 should 528 instead be treated as errors. */ 529 unsigned int warn_is_error_for_rwx_segments: 1; 530 531 /* TRUE if the stack can be made executable because of the absence of a 532 .note.GNU-stack section in an input file. Note - even if this field 533 is set, some targets may choose to ignore the setting and not create 534 an executable stack. */ 535 unsigned int default_execstack : 1; 536 537 /* TRUE if we want to produced optimized output files. This might 538 need much more time and therefore must be explicitly selected. */ 539 unsigned int optimize: 1; 540 541 /* TRUE if user should be informed of removed unreferenced sections. */ 542 unsigned int print_gc_sections: 1; 543 544 /* TRUE if we should warn alternate ELF machine code. */ 545 unsigned int warn_alternate_em: 1; 546 547 /* TRUE if the linker script contained an explicit PHDRS command. */ 548 unsigned int user_phdrs: 1; 549 550 /* TRUE if program headers ought to be loaded. */ 551 unsigned int load_phdrs: 1; 552 553 /* TRUE if we should check relocations after all input files have 554 been opened. */ 555 unsigned int check_relocs_after_open_input: 1; 556 557 /* TRUE if generation of .interp/PT_INTERP should be suppressed. */ 558 unsigned int nointerp: 1; 559 560 /* TRUE if common symbols should be treated as undefined. */ 561 unsigned int inhibit_common_definition : 1; 562 563 /* TRUE if "-Map map" is passed to linker. */ 564 unsigned int has_map_file : 1; 565 566 /* TRUE if "--enable-non-contiguous-regions" is passed to the 567 linker. */ 568 unsigned int non_contiguous_regions : 1; 569 570 /* TRUE if "--enable-non-contiguous-regions-warnings" is passed to 571 the linker. */ 572 unsigned int non_contiguous_regions_warnings : 1; 573 574 /* TRUE if all symbol names should be unique. */ 575 unsigned int unique_symbol : 1; 576 577 /* TRUE if maxpagesize is set on command-line. */ 578 unsigned int maxpagesize_is_set : 1; 579 580 /* TRUE if commonpagesize is set on command-line. */ 581 unsigned int commonpagesize_is_set : 1; 582 583 /* Char that may appear as the first char of a symbol, but should be 584 skipped (like symbol_leading_char) when looking up symbols in 585 wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ 586 char wrap_char; 587 588 /* Separator between archive and filename in linker script filespecs. */ 589 char path_separator; 590 591 /* Default stack size. Zero means default (often zero itself), -1 592 means explicitly zero-sized. */ 593 bfd_signed_vma stacksize; 594 595 /* Enable or disable target specific optimizations. 596 597 Not all targets have optimizations to enable. 598 599 Normally these optimizations are disabled by default but some targets 600 prefer to enable them by default. So this field is a tri-state variable. 601 The values are: 602 603 zero: Enable the optimizations (either from --relax being specified on 604 the command line or the backend's before_allocation emulation function. 605 606 positive: The user has requested that these optimizations be disabled. 607 (Via the --no-relax command line option). 608 609 negative: The optimizations are disabled. (Set when initializing the 610 args_type structure in ldmain.c:main. */ 611 signed int disable_target_specific_optimizations; 612 613 /* Function callbacks. */ 614 const struct bfd_link_callbacks *callbacks; 615 616 /* Hash table handled by BFD. */ 617 struct bfd_link_hash_table *hash; 618 619 /* Hash table of symbols to keep. This is NULL unless strip is 620 strip_some. */ 621 struct bfd_hash_table *keep_hash; 622 623 /* Hash table of symbols to report back via the notice callback. If 624 this is NULL, and notice_all is FALSE, then no symbols are 625 reported back. */ 626 struct bfd_hash_table *notice_hash; 627 628 /* Hash table of symbols which are being wrapped (the --wrap linker 629 option). If this is NULL, no symbols are being wrapped. */ 630 struct bfd_hash_table *wrap_hash; 631 632 /* Hash table of symbols which may be left unresolved during 633 a link. If this is NULL, no symbols can be left unresolved. */ 634 struct bfd_hash_table *ignore_hash; 635 636 /* The output BFD. */ 637 bfd *output_bfd; 638 639 /* The import library generated. */ 640 bfd *out_implib_bfd; 641 642 /* The list of input BFD's involved in the link. These are chained 643 together via the link.next field. */ 644 bfd *input_bfds; 645 bfd **input_bfds_tail; 646 647 /* If a symbol should be created for each input BFD, this is section 648 where those symbols should be placed. It must be a section in 649 the output BFD. It may be NULL, in which case no such symbols 650 will be created. This is to support CREATE_OBJECT_SYMBOLS in the 651 linker command language. */ 652 asection *create_object_symbols_section; 653 654 /* List of global symbol names that are starting points for marking 655 sections against garbage collection. */ 656 struct bfd_sym_chain *gc_sym_list; 657 658 /* If a base output file is wanted, then this points to it */ 659 void *base_file; 660 661 /* The function to call when the executable or shared object is 662 loaded. */ 663 const char *init_function; 664 665 /* The function to call when the executable or shared object is 666 unloaded. */ 667 const char *fini_function; 668 669 /* Number of relaxation passes. Usually only one relaxation pass 670 is needed. But a backend can have as many relaxation passes as 671 necessary. During bfd_relax_section call, it is set to the 672 current pass, starting from 0. */ 673 int relax_pass; 674 675 /* Number of relaxation trips. This number is incremented every 676 time the relaxation pass is restarted due to a previous 677 relaxation returning true in *AGAIN. */ 678 int relax_trip; 679 680 /* > 0 to treat protected data defined in the shared library as 681 reference external. 0 to treat it as internal. -1 to let 682 backend to decide. */ 683 int extern_protected_data; 684 685 /* 1 to make undefined weak symbols dynamic when building a dynamic 686 object. 0 to resolve undefined weak symbols to zero. -1 to let 687 the backend decide. */ 688 int dynamic_undefined_weak; 689 690 /* Non-zero if auto-import thunks for DATA items in pei386 DLLs 691 should be generated/linked against. Set to 1 if this feature 692 is explicitly requested by the user, -1 if enabled by default. */ 693 int pei386_auto_import; 694 695 /* Non-zero if runtime relocs for DATA items with non-zero addends 696 in pei386 DLLs should be generated. Set to 1 if this feature 697 is explicitly requested by the user, -1 if enabled by default. */ 698 int pei386_runtime_pseudo_reloc; 699 700 /* How many spare .dynamic DT_NULL entries should be added? */ 701 unsigned int spare_dynamic_tags; 702 703 /* GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS control: 704 > 1: Turn on by -z indirect-extern-access or by backend. 705 == 1: Turn on by an input. 706 0: Turn off. 707 < 0: Turn on if it is set on any inputs or let backend to 708 decide. */ 709 int indirect_extern_access; 710 711 /* Non-zero if executable should not contain copy relocs. 712 > 1: Implied by indirect_extern_access. 713 == 1: Turn on by -z nocopyreloc. 714 0: Turn off. 715 Setting this to non-zero may result in a non-sharable text 716 segment. */ 717 int nocopyreloc; 718 719 /* Pointer to the GNU_PROPERTY_1_NEEDED property in memory. */ 720 bfd_byte *needed_1_p; 721 722 /* May be used to set DT_FLAGS for ELF. */ 723 bfd_vma flags; 724 725 /* May be used to set DT_FLAGS_1 for ELF. */ 726 bfd_vma flags_1; 727 728 /* May be used to set DT_GNU_FLAGS_1 for ELF. */ 729 bfd_vma gnu_flags_1; 730 731 /* TRUE if references to __start_/__stop_ synthesized symbols do not 732 specially retain C identifier named sections. */ 733 int start_stop_gc; 734 735 /* May be used to set ELF visibility for __start_* / __stop_. */ 736 unsigned int start_stop_visibility; 737 738 /* The maximum page size for ELF. */ 739 bfd_vma maxpagesize; 740 741 /* The common page size for ELF. */ 742 bfd_vma commonpagesize; 743 744 /* Start and end of RELRO region. */ 745 bfd_vma relro_start, relro_end; 746 747 /* List of symbols should be dynamic. */ 748 struct bfd_elf_dynamic_list *dynamic_list; 749 750 /* The version information. */ 751 struct bfd_elf_version_tree *version_info; 752 753 /* Size of cache. Backend can use it to keep strace cache size. */ 754 bfd_size_type cache_size; 755 756 /* The maximum cache size. Backend can use cache_size and and 757 max_cache_size to decide if keep_memory should be honored. */ 758 bfd_size_type max_cache_size; 759 }; 760 761 /* Some forward-definitions used by some callbacks. */ 762 763 struct elf_strtab_hash; 764 struct elf_internal_sym; 765 766 /* This structures holds a set of callback functions. These are called 767 by the BFD linker routines. */ 768 769 struct bfd_link_callbacks 770 { 771 /* A function which is called when an object is added from an 772 archive. ABFD is the archive element being added. NAME is the 773 name of the symbol which caused the archive element to be pulled 774 in. This function may set *SUBSBFD to point to an alternative 775 BFD from which symbols should in fact be added in place of the 776 original BFD's symbols. Returns TRUE if the object should be 777 added, FALSE if it should be skipped. */ 778 bool (*add_archive_element) 779 (struct bfd_link_info *, bfd *abfd, const char *name, bfd **subsbfd); 780 /* A function which is called when a symbol is found with multiple 781 definitions. H is the symbol which is defined multiple times. 782 NBFD is the new BFD, NSEC is the new section, and NVAL is the new 783 value. NSEC may be bfd_com_section or bfd_ind_section. */ 784 void (*multiple_definition) 785 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 786 bfd *nbfd, asection *nsec, bfd_vma nval); 787 /* A function which is called when a common symbol is defined 788 multiple times. H is the symbol appearing multiple times. 789 NBFD is the BFD of the new symbol. NTYPE is the type of the new 790 symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 791 bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 792 is the size of the new symbol. */ 793 void (*multiple_common) 794 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 795 bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize); 796 /* A function which is called to add a symbol to a set. ENTRY is 797 the link hash table entry for the set itself (e.g., 798 __CTOR_LIST__). RELOC is the relocation to use for an entry in 799 the set when generating a relocatable file, and is also used to 800 get the size of the entry when generating an executable file. 801 ABFD, SEC and VALUE identify the value to add to the set. */ 802 void (*add_to_set) 803 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 804 bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value); 805 /* A function which is called when the name of a g++ constructor or 806 destructor is found. This is only called by some object file 807 formats. CONSTRUCTOR is TRUE for a constructor, FALSE for a 808 destructor. This will use BFD_RELOC_CTOR when generating a 809 relocatable file. NAME is the name of the symbol found. ABFD, 810 SECTION and VALUE are the value of the symbol. */ 811 void (*constructor) 812 (struct bfd_link_info *, bool constructor, const char *name, 813 bfd *abfd, asection *sec, bfd_vma value); 814 /* A function which is called to issue a linker warning. For 815 example, this is called when there is a reference to a warning 816 symbol. WARNING is the warning to be issued. SYMBOL is the name 817 of the symbol which triggered the warning; it may be NULL if 818 there is none. ABFD, SECTION and ADDRESS identify the location 819 which trigerred the warning; either ABFD or SECTION or both may 820 be NULL if the location is not known. */ 821 void (*warning) 822 (struct bfd_link_info *, const char *warning, const char *symbol, 823 bfd *abfd, asection *section, bfd_vma address); 824 /* A function which is called when a relocation is attempted against 825 an undefined symbol. NAME is the symbol which is undefined. 826 ABFD, SECTION and ADDRESS identify the location from which the 827 reference is made. IS_FATAL indicates whether an undefined symbol is 828 a fatal error or not. In some cases SECTION may be NULL. */ 829 void (*undefined_symbol) 830 (struct bfd_link_info *, const char *name, bfd *abfd, 831 asection *section, bfd_vma address, bool is_fatal); 832 /* A function which is called when a reloc overflow occurs. ENTRY is 833 the link hash table entry for the symbol the reloc is against. 834 NAME is the name of the local symbol or section the reloc is 835 against, RELOC_NAME is the name of the relocation, and ADDEND is 836 any addend that is used. ABFD, SECTION and ADDRESS identify the 837 location at which the overflow occurs; if this is the result of a 838 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 839 ABFD will be NULL. */ 840 void (*reloc_overflow) 841 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 842 const char *name, const char *reloc_name, bfd_vma addend, 843 bfd *abfd, asection *section, bfd_vma address); 844 /* A function which is called when a dangerous reloc is performed. 845 MESSAGE is an appropriate message. 846 ABFD, SECTION and ADDRESS identify the location at which the 847 problem occurred; if this is the result of a 848 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 849 ABFD will be NULL. */ 850 void (*reloc_dangerous) 851 (struct bfd_link_info *, const char *message, 852 bfd *abfd, asection *section, bfd_vma address); 853 /* A function which is called when a reloc is found to be attached 854 to a symbol which is not being written out. NAME is the name of 855 the symbol. ABFD, SECTION and ADDRESS identify the location of 856 the reloc; if this is the result of a 857 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 858 ABFD will be NULL. */ 859 void (*unattached_reloc) 860 (struct bfd_link_info *, const char *name, 861 bfd *abfd, asection *section, bfd_vma address); 862 /* A function which is called when a symbol in notice_hash is 863 defined or referenced. H is the symbol, INH the indirect symbol 864 if applicable. ABFD, SECTION and ADDRESS are the (new) value of 865 the symbol. If SECTION is bfd_und_section, this is a reference. 866 FLAGS are the symbol BSF_* flags. */ 867 bool (*notice) 868 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 869 struct bfd_link_hash_entry *inh, 870 bfd *abfd, asection *section, bfd_vma address, flagword flags); 871 /* Error or warning link info message. */ 872 void (*einfo) 873 (const char *fmt, ...); 874 /* General link info message. */ 875 void (*info) 876 (const char *fmt, ...); 877 /* Message to be printed in linker map file. */ 878 void (*minfo) 879 (const char *fmt, ...); 880 /* This callback provides a chance for users of the BFD library to 881 override its decision about whether to place two adjacent sections 882 into the same segment. */ 883 bool (*override_segment_assignment) 884 (struct bfd_link_info *, bfd * abfd, 885 asection * current_section, asection * previous_section, 886 bool new_segment); 887 /* This callback provides a chance for callers of the BFD to examine the 888 ELF (dynamic) string table once it is complete. */ 889 void (*examine_strtab) 890 (struct elf_strtab_hash *symstrtab); 891 /* This callback is called just before a symbol is swapped out, so that the 892 CTF machinery can look up symbols during construction. The name is 893 already an external strtab offset at this point. */ 894 void (*ctf_new_symbol) 895 (int symidx, struct elf_internal_sym *sym); 896 /* Likewise, for dynamic symbols. */ 897 void (*ctf_new_dynsym) 898 (int symidx, struct elf_internal_sym *sym); 899 /* This callback should emit the CTF section into a non-loadable section in 900 the output BFD named .ctf or a name beginning with ".ctf.". */ 901 void (*emit_ctf) 902 (void); 903 }; 904 905 /* The linker builds link_order structures which tell the code how to 906 include input data in the output file. */ 907 908 /* These are the types of link_order structures. */ 909 910 enum bfd_link_order_type 911 { 912 bfd_undefined_link_order, /* Undefined. */ 913 bfd_indirect_link_order, /* Built from a section. */ 914 bfd_data_link_order, /* Set to explicit data. */ 915 bfd_section_reloc_link_order, /* Relocate against a section. */ 916 bfd_symbol_reloc_link_order /* Relocate against a symbol. */ 917 }; 918 919 /* This is the link_order structure itself. These form a chain 920 attached to the output section whose contents they are describing. */ 921 922 struct bfd_link_order 923 { 924 /* Next link_order in chain. */ 925 struct bfd_link_order *next; 926 /* Type of link_order. */ 927 enum bfd_link_order_type type; 928 /* Offset within output section in bytes. */ 929 bfd_vma offset; 930 /* Size within output section in octets. */ 931 bfd_size_type size; 932 /* Type specific information. */ 933 union 934 { 935 struct 936 { 937 /* Section to include. If this is used, then 938 section->output_section must be the section the 939 link_order is attached to, section->output_offset must 940 equal the link_order offset field, and section->size 941 must equal the link_order size field. Maybe these 942 restrictions should be relaxed someday. */ 943 asection *section; 944 } indirect; 945 struct 946 { 947 /* Size of contents, or zero when contents should be filled by 948 the architecture-dependent fill function. 949 A non-zero value allows filling of the output section 950 with an arbitrary repeated pattern. */ 951 unsigned int size; 952 /* Data to put into file. */ 953 bfd_byte *contents; 954 } data; 955 struct 956 { 957 /* Description of reloc to generate. Used for 958 bfd_section_reloc_link_order and 959 bfd_symbol_reloc_link_order. */ 960 struct bfd_link_order_reloc *p; 961 } reloc; 962 } u; 963 }; 964 965 /* A linker order of type bfd_section_reloc_link_order or 966 bfd_symbol_reloc_link_order means to create a reloc against a 967 section or symbol, respectively. This is used to implement -Ur to 968 generate relocs for the constructor tables. The 969 bfd_link_order_reloc structure describes the reloc that BFD should 970 create. It is similar to a arelent, but I didn't use arelent 971 because the linker does not know anything about most symbols, and 972 any asymbol structure it creates will be partially meaningless. 973 This information could logically be in the bfd_link_order struct, 974 but I didn't want to waste the space since these types of relocs 975 are relatively rare. */ 976 977 struct bfd_link_order_reloc 978 { 979 /* Reloc type. */ 980 bfd_reloc_code_real_type reloc; 981 982 union 983 { 984 /* For type bfd_section_reloc_link_order, this is the section 985 the reloc should be against. This must be a section in the 986 output BFD, not any of the input BFDs. */ 987 asection *section; 988 /* For type bfd_symbol_reloc_link_order, this is the name of the 989 symbol the reloc should be against. */ 990 const char *name; 991 } u; 992 993 /* Addend to use. The object file should contain zero. The BFD 994 backend is responsible for filling in the contents of the object 995 file correctly. For some object file formats (e.g., COFF) the 996 addend must be stored into in the object file, and for some 997 (e.g., SPARC a.out) it is kept in the reloc. */ 998 bfd_vma addend; 999 }; 1000 1001 /* Allocate a new link_order for a section. */ 1002 extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *); 1003 1004 struct bfd_section_already_linked; 1005 1006 extern bool bfd_section_already_linked_table_init (void); 1007 extern void bfd_section_already_linked_table_free (void); 1008 extern bool _bfd_handle_already_linked 1009 (struct bfd_section *, struct bfd_section_already_linked *, 1010 struct bfd_link_info *); 1011 1012 extern struct bfd_section *_bfd_nearby_section 1013 (bfd *, struct bfd_section *, bfd_vma); 1014 1015 extern void _bfd_fix_excluded_sec_syms 1016 (bfd *, struct bfd_link_info *); 1017 1018 /* These structures are used to describe version information for the 1019 ELF linker. These structures could be manipulated entirely inside 1020 BFD, but it would be a pain. Instead, the regular linker sets up 1021 these structures, and then passes them into BFD. */ 1022 1023 /* Glob pattern for a version. */ 1024 1025 struct bfd_elf_version_expr 1026 { 1027 /* Next glob pattern for this version. */ 1028 struct bfd_elf_version_expr *next; 1029 /* Glob pattern. */ 1030 const char *pattern; 1031 /* Set if pattern is not a glob. */ 1032 unsigned int literal : 1; 1033 /* Defined by ".symver". */ 1034 unsigned int symver : 1; 1035 /* Defined by version script. */ 1036 unsigned int script : 1; 1037 /* Pattern type. */ 1038 #define BFD_ELF_VERSION_C_TYPE 1 1039 #define BFD_ELF_VERSION_CXX_TYPE 2 1040 #define BFD_ELF_VERSION_JAVA_TYPE 4 1041 unsigned int mask : 3; 1042 }; 1043 1044 struct bfd_elf_version_expr_head 1045 { 1046 /* List of all patterns, both wildcards and non-wildcards. */ 1047 struct bfd_elf_version_expr *list; 1048 /* Hash table for non-wildcards. */ 1049 void *htab; 1050 /* Remaining patterns. */ 1051 struct bfd_elf_version_expr *remaining; 1052 /* What kind of pattern types are present in list (bitmask). */ 1053 unsigned int mask; 1054 }; 1055 1056 /* Version dependencies. */ 1057 1058 struct bfd_elf_version_deps 1059 { 1060 /* Next dependency for this version. */ 1061 struct bfd_elf_version_deps *next; 1062 /* The version which this version depends upon. */ 1063 struct bfd_elf_version_tree *version_needed; 1064 }; 1065 1066 /* A node in the version tree. */ 1067 1068 struct bfd_elf_version_tree 1069 { 1070 /* Next version. */ 1071 struct bfd_elf_version_tree *next; 1072 /* Name of this version. */ 1073 const char *name; 1074 /* Version number. */ 1075 unsigned int vernum; 1076 /* Regular expressions for global symbols in this version. */ 1077 struct bfd_elf_version_expr_head globals; 1078 /* Regular expressions for local symbols in this version. */ 1079 struct bfd_elf_version_expr_head locals; 1080 /* List of versions which this version depends upon. */ 1081 struct bfd_elf_version_deps *deps; 1082 /* Index of the version name. This is used within BFD. */ 1083 unsigned int name_indx; 1084 /* Whether this version tree was used. This is used within BFD. */ 1085 int used; 1086 /* Matching hook. */ 1087 struct bfd_elf_version_expr *(*match) 1088 (struct bfd_elf_version_expr_head *head, 1089 struct bfd_elf_version_expr *prev, const char *sym); 1090 }; 1091 1092 struct bfd_elf_dynamic_list 1093 { 1094 struct bfd_elf_version_expr_head head; 1095 struct bfd_elf_version_expr *(*match) 1096 (struct bfd_elf_version_expr_head *head, 1097 struct bfd_elf_version_expr *prev, const char *sym); 1098 }; 1099 1100 #endif 1101