1/* bfdlink.h -- header file for BFD link routines 2 Copyright (C) 1993-2022 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. */ 26enum 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. */ 36enum 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 45enum 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. */ 53enum 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. */ 63enum 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 72enum 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 84enum 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 92struct 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 101struct 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 203struct 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. */ 221extern 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 229extern 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 235extern 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. */ 239extern 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. */ 245extern 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. */ 249extern void bfd_link_repair_undef_list 250 (struct bfd_link_hash_table *table); 251 252/* Read symbols and cache symbol pointer array in outsymbols. */ 253extern 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. */ 258extern bool bfd_link_check_relocs (bfd *,struct bfd_link_info *); 259 260struct 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: */ 268enum 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 280enum 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 290typedef enum {with_flags, without_flags} flag_type; 291 292/* A section flag list. */ 293struct 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. */ 302struct 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 310struct bfd_elf_dynamic_list; 311struct bfd_elf_version_tree; 312 313/* Types of output. */ 314 315enum 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 333struct 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 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W|PF_X 488 flags. */ 489 unsigned int execstack: 1; 490 491 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W 492 flags. */ 493 unsigned int noexecstack: 1; 494 495 /* Tri-state variable: 496 0 => do not warn when creating an executable stack. 497 1 => always warn when creating an executable stack. 498 >1 => warn when creating an executable stack if execstack is 0. */ 499 unsigned int warn_execstack: 2; 500 501 /* TRUE if warnings should not be generated for TLS segments with eXecute 502 permission or LOAD segments with RWX permissions. */ 503 unsigned int no_warn_rwx_segments: 1; 504 505 /* TRUE if the stack can be made executable because of the absence of a 506 .note.GNU-stack section in an input file. Note - even if this field 507 is set, some targets may choose to ignore the setting and not create 508 an executable stack. */ 509 unsigned int default_execstack : 1; 510 511 /* TRUE if we want to produced optimized output files. This might 512 need much more time and therefore must be explicitly selected. */ 513 unsigned int optimize: 1; 514 515 /* TRUE if user should be informed of removed unreferenced sections. */ 516 unsigned int print_gc_sections: 1; 517 518 /* TRUE if we should warn alternate ELF machine code. */ 519 unsigned int warn_alternate_em: 1; 520 521 /* TRUE if the linker script contained an explicit PHDRS command. */ 522 unsigned int user_phdrs: 1; 523 524 /* TRUE if program headers ought to be loaded. */ 525 unsigned int load_phdrs: 1; 526 527 /* TRUE if we should check relocations after all input files have 528 been opened. */ 529 unsigned int check_relocs_after_open_input: 1; 530 531 /* TRUE if generation of .interp/PT_INTERP should be suppressed. */ 532 unsigned int nointerp: 1; 533 534 /* TRUE if common symbols should be treated as undefined. */ 535 unsigned int inhibit_common_definition : 1; 536 537 /* TRUE if "-Map map" is passed to linker. */ 538 unsigned int has_map_file : 1; 539 540 /* TRUE if "--enable-non-contiguous-regions" is passed to the 541 linker. */ 542 unsigned int non_contiguous_regions : 1; 543 544 /* TRUE if "--enable-non-contiguous-regions-warnings" is passed to 545 the linker. */ 546 unsigned int non_contiguous_regions_warnings : 1; 547 548 /* TRUE if all symbol names should be unique. */ 549 unsigned int unique_symbol : 1; 550 551 /* TRUE if maxpagesize is set on command-line. */ 552 unsigned int maxpagesize_is_set : 1; 553 554 /* TRUE if commonpagesize is set on command-line. */ 555 unsigned int commonpagesize_is_set : 1; 556 557 /* Char that may appear as the first char of a symbol, but should be 558 skipped (like symbol_leading_char) when looking up symbols in 559 wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ 560 char wrap_char; 561 562 /* Separator between archive and filename in linker script filespecs. */ 563 char path_separator; 564 565 /* Default stack size. Zero means default (often zero itself), -1 566 means explicitly zero-sized. */ 567 bfd_signed_vma stacksize; 568 569 /* Enable or disable target specific optimizations. 570 571 Not all targets have optimizations to enable. 572 573 Normally these optimizations are disabled by default but some targets 574 prefer to enable them by default. So this field is a tri-state variable. 575 The values are: 576 577 zero: Enable the optimizations (either from --relax being specified on 578 the command line or the backend's before_allocation emulation function. 579 580 positive: The user has requested that these optimizations be disabled. 581 (Via the --no-relax command line option). 582 583 negative: The optimizations are disabled. (Set when initializing the 584 args_type structure in ldmain.c:main. */ 585 signed int disable_target_specific_optimizations; 586 587 /* Function callbacks. */ 588 const struct bfd_link_callbacks *callbacks; 589 590 /* Hash table handled by BFD. */ 591 struct bfd_link_hash_table *hash; 592 593 /* Hash table of symbols to keep. This is NULL unless strip is 594 strip_some. */ 595 struct bfd_hash_table *keep_hash; 596 597 /* Hash table of symbols to report back via the notice callback. If 598 this is NULL, and notice_all is FALSE, then no symbols are 599 reported back. */ 600 struct bfd_hash_table *notice_hash; 601 602 /* Hash table of symbols which are being wrapped (the --wrap linker 603 option). If this is NULL, no symbols are being wrapped. */ 604 struct bfd_hash_table *wrap_hash; 605 606 /* Hash table of symbols which may be left unresolved during 607 a link. If this is NULL, no symbols can be left unresolved. */ 608 struct bfd_hash_table *ignore_hash; 609 610 /* The output BFD. */ 611 bfd *output_bfd; 612 613 /* The import library generated. */ 614 bfd *out_implib_bfd; 615 616 /* The list of input BFD's involved in the link. These are chained 617 together via the link.next field. */ 618 bfd *input_bfds; 619 bfd **input_bfds_tail; 620 621 /* If a symbol should be created for each input BFD, this is section 622 where those symbols should be placed. It must be a section in 623 the output BFD. It may be NULL, in which case no such symbols 624 will be created. This is to support CREATE_OBJECT_SYMBOLS in the 625 linker command language. */ 626 asection *create_object_symbols_section; 627 628 /* List of global symbol names that are starting points for marking 629 sections against garbage collection. */ 630 struct bfd_sym_chain *gc_sym_list; 631 632 /* If a base output file is wanted, then this points to it */ 633 void *base_file; 634 635 /* The function to call when the executable or shared object is 636 loaded. */ 637 const char *init_function; 638 639 /* The function to call when the executable or shared object is 640 unloaded. */ 641 const char *fini_function; 642 643 /* Number of relaxation passes. Usually only one relaxation pass 644 is needed. But a backend can have as many relaxation passes as 645 necessary. During bfd_relax_section call, it is set to the 646 current pass, starting from 0. */ 647 int relax_pass; 648 649 /* Number of relaxation trips. This number is incremented every 650 time the relaxation pass is restarted due to a previous 651 relaxation returning true in *AGAIN. */ 652 int relax_trip; 653 654 /* > 0 to treat protected data defined in the shared library as 655 reference external. 0 to treat it as internal. -1 to let 656 backend to decide. */ 657 int extern_protected_data; 658 659 /* 1 to make undefined weak symbols dynamic when building a dynamic 660 object. 0 to resolve undefined weak symbols to zero. -1 to let 661 the backend decide. */ 662 int dynamic_undefined_weak; 663 664 /* Non-zero if auto-import thunks for DATA items in pei386 DLLs 665 should be generated/linked against. Set to 1 if this feature 666 is explicitly requested by the user, -1 if enabled by default. */ 667 int pei386_auto_import; 668 669 /* Non-zero if runtime relocs for DATA items with non-zero addends 670 in pei386 DLLs should be generated. Set to 1 if this feature 671 is explicitly requested by the user, -1 if enabled by default. */ 672 int pei386_runtime_pseudo_reloc; 673 674 /* How many spare .dynamic DT_NULL entries should be added? */ 675 unsigned int spare_dynamic_tags; 676 677 /* GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS control: 678 > 1: Turn on by -z indirect-extern-access or by backend. 679 == 1: Turn on by an input. 680 0: Turn off. 681 < 0: Turn on if it is set on any inputs or let backend to 682 decide. */ 683 int indirect_extern_access; 684 685 /* Non-zero if executable should not contain copy relocs. 686 > 1: Implied by indirect_extern_access. 687 == 1: Turn on by -z nocopyreloc. 688 0: Turn off. 689 Setting this to non-zero may result in a non-sharable text 690 segment. */ 691 int nocopyreloc; 692 693 /* Pointer to the GNU_PROPERTY_1_NEEDED property in memory. */ 694 bfd_byte *needed_1_p; 695 696 /* May be used to set DT_FLAGS for ELF. */ 697 bfd_vma flags; 698 699 /* May be used to set DT_FLAGS_1 for ELF. */ 700 bfd_vma flags_1; 701 702 /* May be used to set DT_GNU_FLAGS_1 for ELF. */ 703 bfd_vma gnu_flags_1; 704 705 /* TRUE if references to __start_/__stop_ synthesized symbols do not 706 specially retain C identifier named sections. */ 707 int start_stop_gc; 708 709 /* May be used to set ELF visibility for __start_* / __stop_. */ 710 unsigned int start_stop_visibility; 711 712 /* The maximum page size for ELF. */ 713 bfd_vma maxpagesize; 714 715 /* The common page size for ELF. */ 716 bfd_vma commonpagesize; 717 718 /* Start and end of RELRO region. */ 719 bfd_vma relro_start, relro_end; 720 721 /* List of symbols should be dynamic. */ 722 struct bfd_elf_dynamic_list *dynamic_list; 723 724 /* The version information. */ 725 struct bfd_elf_version_tree *version_info; 726 727 /* Size of cache. Backend can use it to keep strace cache size. */ 728 bfd_size_type cache_size; 729 730 /* The maximum cache size. Backend can use cache_size and and 731 max_cache_size to decide if keep_memory should be honored. */ 732 bfd_size_type max_cache_size; 733}; 734 735/* Some forward-definitions used by some callbacks. */ 736 737struct elf_strtab_hash; 738struct elf_internal_sym; 739 740/* This structures holds a set of callback functions. These are called 741 by the BFD linker routines. */ 742 743struct bfd_link_callbacks 744{ 745 /* A function which is called when an object is added from an 746 archive. ABFD is the archive element being added. NAME is the 747 name of the symbol which caused the archive element to be pulled 748 in. This function may set *SUBSBFD to point to an alternative 749 BFD from which symbols should in fact be added in place of the 750 original BFD's symbols. Returns TRUE if the object should be 751 added, FALSE if it should be skipped. */ 752 bool (*add_archive_element) 753 (struct bfd_link_info *, bfd *abfd, const char *name, bfd **subsbfd); 754 /* A function which is called when a symbol is found with multiple 755 definitions. H is the symbol which is defined multiple times. 756 NBFD is the new BFD, NSEC is the new section, and NVAL is the new 757 value. NSEC may be bfd_com_section or bfd_ind_section. */ 758 void (*multiple_definition) 759 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 760 bfd *nbfd, asection *nsec, bfd_vma nval); 761 /* A function which is called when a common symbol is defined 762 multiple times. H is the symbol appearing multiple times. 763 NBFD is the BFD of the new symbol. NTYPE is the type of the new 764 symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 765 bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 766 is the size of the new symbol. */ 767 void (*multiple_common) 768 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 769 bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize); 770 /* A function which is called to add a symbol to a set. ENTRY is 771 the link hash table entry for the set itself (e.g., 772 __CTOR_LIST__). RELOC is the relocation to use for an entry in 773 the set when generating a relocatable file, and is also used to 774 get the size of the entry when generating an executable file. 775 ABFD, SEC and VALUE identify the value to add to the set. */ 776 void (*add_to_set) 777 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 778 bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value); 779 /* A function which is called when the name of a g++ constructor or 780 destructor is found. This is only called by some object file 781 formats. CONSTRUCTOR is TRUE for a constructor, FALSE for a 782 destructor. This will use BFD_RELOC_CTOR when generating a 783 relocatable file. NAME is the name of the symbol found. ABFD, 784 SECTION and VALUE are the value of the symbol. */ 785 void (*constructor) 786 (struct bfd_link_info *, bool constructor, const char *name, 787 bfd *abfd, asection *sec, bfd_vma value); 788 /* A function which is called to issue a linker warning. For 789 example, this is called when there is a reference to a warning 790 symbol. WARNING is the warning to be issued. SYMBOL is the name 791 of the symbol which triggered the warning; it may be NULL if 792 there is none. ABFD, SECTION and ADDRESS identify the location 793 which trigerred the warning; either ABFD or SECTION or both may 794 be NULL if the location is not known. */ 795 void (*warning) 796 (struct bfd_link_info *, const char *warning, const char *symbol, 797 bfd *abfd, asection *section, bfd_vma address); 798 /* A function which is called when a relocation is attempted against 799 an undefined symbol. NAME is the symbol which is undefined. 800 ABFD, SECTION and ADDRESS identify the location from which the 801 reference is made. IS_FATAL indicates whether an undefined symbol is 802 a fatal error or not. In some cases SECTION may be NULL. */ 803 void (*undefined_symbol) 804 (struct bfd_link_info *, const char *name, bfd *abfd, 805 asection *section, bfd_vma address, bool is_fatal); 806 /* A function which is called when a reloc overflow occurs. ENTRY is 807 the link hash table entry for the symbol the reloc is against. 808 NAME is the name of the local symbol or section the reloc is 809 against, RELOC_NAME is the name of the relocation, and ADDEND is 810 any addend that is used. ABFD, SECTION and ADDRESS identify the 811 location at which the overflow occurs; if this is the result of a 812 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 813 ABFD will be NULL. */ 814 void (*reloc_overflow) 815 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 816 const char *name, const char *reloc_name, bfd_vma addend, 817 bfd *abfd, asection *section, bfd_vma address); 818 /* A function which is called when a dangerous reloc is performed. 819 MESSAGE is an appropriate message. 820 ABFD, SECTION and ADDRESS identify the location at which the 821 problem occurred; if this is the result of a 822 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 823 ABFD will be NULL. */ 824 void (*reloc_dangerous) 825 (struct bfd_link_info *, const char *message, 826 bfd *abfd, asection *section, bfd_vma address); 827 /* A function which is called when a reloc is found to be attached 828 to a symbol which is not being written out. NAME is the name of 829 the symbol. ABFD, SECTION and ADDRESS identify the location of 830 the reloc; if this is the result of a 831 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 832 ABFD will be NULL. */ 833 void (*unattached_reloc) 834 (struct bfd_link_info *, const char *name, 835 bfd *abfd, asection *section, bfd_vma address); 836 /* A function which is called when a symbol in notice_hash is 837 defined or referenced. H is the symbol, INH the indirect symbol 838 if applicable. ABFD, SECTION and ADDRESS are the (new) value of 839 the symbol. If SECTION is bfd_und_section, this is a reference. 840 FLAGS are the symbol BSF_* flags. */ 841 bool (*notice) 842 (struct bfd_link_info *, struct bfd_link_hash_entry *h, 843 struct bfd_link_hash_entry *inh, 844 bfd *abfd, asection *section, bfd_vma address, flagword flags); 845 /* Error or warning link info message. */ 846 void (*einfo) 847 (const char *fmt, ...); 848 /* General link info message. */ 849 void (*info) 850 (const char *fmt, ...); 851 /* Message to be printed in linker map file. */ 852 void (*minfo) 853 (const char *fmt, ...); 854 /* This callback provides a chance for users of the BFD library to 855 override its decision about whether to place two adjacent sections 856 into the same segment. */ 857 bool (*override_segment_assignment) 858 (struct bfd_link_info *, bfd * abfd, 859 asection * current_section, asection * previous_section, 860 bool new_segment); 861 /* This callback provides a chance for callers of the BFD to examine the 862 ELF (dynamic) string table once it is complete. */ 863 void (*examine_strtab) 864 (struct elf_strtab_hash *symstrtab); 865 /* This callback is called just before a symbol is swapped out, so that the 866 CTF machinery can look up symbols during construction. The name is 867 already an external strtab offset at this point. */ 868 void (*ctf_new_symbol) 869 (int symidx, struct elf_internal_sym *sym); 870 /* Likewise, for dynamic symbols. */ 871 void (*ctf_new_dynsym) 872 (int symidx, struct elf_internal_sym *sym); 873 /* This callback should emit the CTF section into a non-loadable section in 874 the output BFD named .ctf or a name beginning with ".ctf.". */ 875 void (*emit_ctf) 876 (void); 877}; 878 879/* The linker builds link_order structures which tell the code how to 880 include input data in the output file. */ 881 882/* These are the types of link_order structures. */ 883 884enum bfd_link_order_type 885{ 886 bfd_undefined_link_order, /* Undefined. */ 887 bfd_indirect_link_order, /* Built from a section. */ 888 bfd_data_link_order, /* Set to explicit data. */ 889 bfd_section_reloc_link_order, /* Relocate against a section. */ 890 bfd_symbol_reloc_link_order /* Relocate against a symbol. */ 891}; 892 893/* This is the link_order structure itself. These form a chain 894 attached to the output section whose contents they are describing. */ 895 896struct bfd_link_order 897{ 898 /* Next link_order in chain. */ 899 struct bfd_link_order *next; 900 /* Type of link_order. */ 901 enum bfd_link_order_type type; 902 /* Offset within output section in bytes. */ 903 bfd_vma offset; 904 /* Size within output section in octets. */ 905 bfd_size_type size; 906 /* Type specific information. */ 907 union 908 { 909 struct 910 { 911 /* Section to include. If this is used, then 912 section->output_section must be the section the 913 link_order is attached to, section->output_offset must 914 equal the link_order offset field, and section->size 915 must equal the link_order size field. Maybe these 916 restrictions should be relaxed someday. */ 917 asection *section; 918 } indirect; 919 struct 920 { 921 /* Size of contents, or zero when contents should be filled by 922 the architecture-dependent fill function. 923 A non-zero value allows filling of the output section 924 with an arbitrary repeated pattern. */ 925 unsigned int size; 926 /* Data to put into file. */ 927 bfd_byte *contents; 928 } data; 929 struct 930 { 931 /* Description of reloc to generate. Used for 932 bfd_section_reloc_link_order and 933 bfd_symbol_reloc_link_order. */ 934 struct bfd_link_order_reloc *p; 935 } reloc; 936 } u; 937}; 938 939/* A linker order of type bfd_section_reloc_link_order or 940 bfd_symbol_reloc_link_order means to create a reloc against a 941 section or symbol, respectively. This is used to implement -Ur to 942 generate relocs for the constructor tables. The 943 bfd_link_order_reloc structure describes the reloc that BFD should 944 create. It is similar to a arelent, but I didn't use arelent 945 because the linker does not know anything about most symbols, and 946 any asymbol structure it creates will be partially meaningless. 947 This information could logically be in the bfd_link_order struct, 948 but I didn't want to waste the space since these types of relocs 949 are relatively rare. */ 950 951struct bfd_link_order_reloc 952{ 953 /* Reloc type. */ 954 bfd_reloc_code_real_type reloc; 955 956 union 957 { 958 /* For type bfd_section_reloc_link_order, this is the section 959 the reloc should be against. This must be a section in the 960 output BFD, not any of the input BFDs. */ 961 asection *section; 962 /* For type bfd_symbol_reloc_link_order, this is the name of the 963 symbol the reloc should be against. */ 964 const char *name; 965 } u; 966 967 /* Addend to use. The object file should contain zero. The BFD 968 backend is responsible for filling in the contents of the object 969 file correctly. For some object file formats (e.g., COFF) the 970 addend must be stored into in the object file, and for some 971 (e.g., SPARC a.out) it is kept in the reloc. */ 972 bfd_vma addend; 973}; 974 975/* Allocate a new link_order for a section. */ 976extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *); 977 978struct bfd_section_already_linked; 979 980extern bool bfd_section_already_linked_table_init (void); 981extern void bfd_section_already_linked_table_free (void); 982extern bool _bfd_handle_already_linked 983 (struct bfd_section *, struct bfd_section_already_linked *, 984 struct bfd_link_info *); 985 986extern struct bfd_section *_bfd_nearby_section 987 (bfd *, struct bfd_section *, bfd_vma); 988 989extern void _bfd_fix_excluded_sec_syms 990 (bfd *, struct bfd_link_info *); 991 992/* These structures are used to describe version information for the 993 ELF linker. These structures could be manipulated entirely inside 994 BFD, but it would be a pain. Instead, the regular linker sets up 995 these structures, and then passes them into BFD. */ 996 997/* Glob pattern for a version. */ 998 999struct bfd_elf_version_expr 1000{ 1001 /* Next glob pattern for this version. */ 1002 struct bfd_elf_version_expr *next; 1003 /* Glob pattern. */ 1004 const char *pattern; 1005 /* Set if pattern is not a glob. */ 1006 unsigned int literal : 1; 1007 /* Defined by ".symver". */ 1008 unsigned int symver : 1; 1009 /* Defined by version script. */ 1010 unsigned int script : 1; 1011 /* Pattern type. */ 1012#define BFD_ELF_VERSION_C_TYPE 1 1013#define BFD_ELF_VERSION_CXX_TYPE 2 1014#define BFD_ELF_VERSION_JAVA_TYPE 4 1015 unsigned int mask : 3; 1016}; 1017 1018struct bfd_elf_version_expr_head 1019{ 1020 /* List of all patterns, both wildcards and non-wildcards. */ 1021 struct bfd_elf_version_expr *list; 1022 /* Hash table for non-wildcards. */ 1023 void *htab; 1024 /* Remaining patterns. */ 1025 struct bfd_elf_version_expr *remaining; 1026 /* What kind of pattern types are present in list (bitmask). */ 1027 unsigned int mask; 1028}; 1029 1030/* Version dependencies. */ 1031 1032struct bfd_elf_version_deps 1033{ 1034 /* Next dependency for this version. */ 1035 struct bfd_elf_version_deps *next; 1036 /* The version which this version depends upon. */ 1037 struct bfd_elf_version_tree *version_needed; 1038}; 1039 1040/* A node in the version tree. */ 1041 1042struct bfd_elf_version_tree 1043{ 1044 /* Next version. */ 1045 struct bfd_elf_version_tree *next; 1046 /* Name of this version. */ 1047 const char *name; 1048 /* Version number. */ 1049 unsigned int vernum; 1050 /* Regular expressions for global symbols in this version. */ 1051 struct bfd_elf_version_expr_head globals; 1052 /* Regular expressions for local symbols in this version. */ 1053 struct bfd_elf_version_expr_head locals; 1054 /* List of versions which this version depends upon. */ 1055 struct bfd_elf_version_deps *deps; 1056 /* Index of the version name. This is used within BFD. */ 1057 unsigned int name_indx; 1058 /* Whether this version tree was used. This is used within BFD. */ 1059 int used; 1060 /* Matching hook. */ 1061 struct bfd_elf_version_expr *(*match) 1062 (struct bfd_elf_version_expr_head *head, 1063 struct bfd_elf_version_expr *prev, const char *sym); 1064}; 1065 1066struct bfd_elf_dynamic_list 1067{ 1068 struct bfd_elf_version_expr_head head; 1069 struct bfd_elf_version_expr *(*match) 1070 (struct bfd_elf_version_expr_head *head, 1071 struct bfd_elf_version_expr *prev, const char *sym); 1072}; 1073 1074#endif 1075