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