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