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