1 /* bfdlink.h -- header file for BFD link routines 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005 Free Software Foundation, Inc. 4 Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 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 /* Describes the type of hash table entry structure being used. 46 Different hash table structure have different fields and so 47 support different linking features. */ 48 enum bfd_link_hash_table_type 49 { 50 bfd_link_generic_hash_table, 51 bfd_link_elf_hash_table 52 }; 53 54 /* These are the possible types of an entry in the BFD link hash 56 table. */ 57 58 enum bfd_link_hash_type 59 { 60 bfd_link_hash_new, /* Symbol is new. */ 61 bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ 62 bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ 63 bfd_link_hash_defined, /* Symbol is defined. */ 64 bfd_link_hash_defweak, /* Symbol is weak and defined. */ 65 bfd_link_hash_common, /* Symbol is common. */ 66 bfd_link_hash_indirect, /* Symbol is an indirect link. */ 67 bfd_link_hash_warning /* Like indirect, but warn if referenced. */ 68 }; 69 70 enum bfd_link_common_skip_ar_aymbols 71 { 72 bfd_link_common_skip_none, 73 bfd_link_common_skip_text, 74 bfd_link_common_skip_data, 75 bfd_link_common_skip_all 76 }; 77 78 /* The linking routines use a hash table which uses this structure for 79 its elements. */ 80 81 struct bfd_link_hash_entry 82 { 83 /* Base hash table entry structure. */ 84 struct bfd_hash_entry root; 85 86 /* Type of this entry. */ 87 enum bfd_link_hash_type type; 88 89 /* A union of information depending upon the type. */ 90 union 91 { 92 /* Nothing is kept for bfd_hash_new. */ 93 /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ 94 struct 95 { 96 /* Undefined and common symbols are kept in a linked list through 97 this field. This field is present in all of the union element 98 so that we don't need to remove entries from the list when we 99 change their type. Removing entries would either require the 100 list to be doubly linked, which would waste more memory, or 101 require a traversal. When an undefined or common symbol is 102 created, it should be added to this list, the head of which is in 103 the link hash table itself. As symbols are defined, they need 104 not be removed from the list; anything which reads the list must 105 doublecheck the symbol type. 106 107 Weak symbols are not kept on this list. 108 109 Defined and defweak symbols use this field as a reference marker. 110 If the field is not NULL, or this structure is the tail of the 111 undefined symbol list, the symbol has been referenced. If the 112 symbol is undefined and becomes defined, this field will 113 automatically be non-NULL since the symbol will have been on the 114 undefined symbol list. */ 115 struct bfd_link_hash_entry *next; 116 bfd *abfd; /* BFD symbol was found in. */ 117 bfd *weak; /* BFD weak symbol was found in. */ 118 } undef; 119 /* bfd_link_hash_defined, bfd_link_hash_defweak. */ 120 struct 121 { 122 struct bfd_link_hash_entry *next; 123 asection *section; /* Symbol section. */ 124 bfd_vma value; /* Symbol value. */ 125 } def; 126 /* bfd_link_hash_indirect, bfd_link_hash_warning. */ 127 struct 128 { 129 struct bfd_link_hash_entry *next; 130 struct bfd_link_hash_entry *link; /* Real symbol. */ 131 const char *warning; /* Warning (bfd_link_hash_warning only). */ 132 } i; 133 /* bfd_link_hash_common. */ 134 struct 135 { 136 struct bfd_link_hash_entry *next; 137 /* The linker needs to know three things about common 138 symbols: the size, the alignment, and the section in 139 which the symbol should be placed. We store the size 140 here, and we allocate a small structure to hold the 141 section and the alignment. The alignment is stored as a 142 power of two. We don't store all the information 143 directly because we don't want to increase the size of 144 the union; this structure is a major space user in the 145 linker. */ 146 struct bfd_link_hash_common_entry 147 { 148 unsigned int alignment_power; /* Alignment. */ 149 asection *section; /* Symbol section. */ 150 } *p; 151 bfd_size_type size; /* Common symbol size. */ 152 } c; 153 } u; 154 }; 155 156 /* This is the link hash table. It is a derived class of 157 bfd_hash_table. */ 158 159 struct bfd_link_hash_table 160 { 161 /* The hash table itself. */ 162 struct bfd_hash_table table; 163 /* The back end which created this hash table. This indicates the 164 type of the entries in the hash table, which is sometimes 165 important information when linking object files of different 166 types together. */ 167 const bfd_target *creator; 168 /* A linked list of undefined and common symbols, linked through the 169 next field in the bfd_link_hash_entry structure. */ 170 struct bfd_link_hash_entry *undefs; 171 /* Entries are added to the tail of the undefs list. */ 172 struct bfd_link_hash_entry *undefs_tail; 173 /* The type of the link hash table. */ 174 enum bfd_link_hash_table_type type; 175 }; 176 177 /* Look up an entry in a link hash table. If FOLLOW is TRUE, this 178 follows bfd_link_hash_indirect and bfd_link_hash_warning links to 179 the real symbol. */ 180 extern struct bfd_link_hash_entry *bfd_link_hash_lookup 181 (struct bfd_link_hash_table *, const char *, bfd_boolean create, 182 bfd_boolean copy, bfd_boolean follow); 183 184 /* Look up an entry in the main linker hash table if the symbol might 185 be wrapped. This should only be used for references to an 186 undefined symbol, not for definitions of a symbol. */ 187 188 extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup 189 (bfd *, struct bfd_link_info *, const char *, bfd_boolean, 190 bfd_boolean, bfd_boolean); 191 192 /* Traverse a link hash table. */ 193 extern void bfd_link_hash_traverse 194 (struct bfd_link_hash_table *, 195 bfd_boolean (*) (struct bfd_link_hash_entry *, void *), 196 void *); 197 198 /* Add an entry to the undefs list. */ 199 extern void bfd_link_add_undef 200 (struct bfd_link_hash_table *, struct bfd_link_hash_entry *); 201 202 /* Remove symbols from the undefs list that don't belong there. */ 203 extern void bfd_link_repair_undef_list 204 (struct bfd_link_hash_table *table); 205 206 struct bfd_sym_chain 207 { 208 struct bfd_sym_chain *next; 209 const char *name; 210 }; 211 212 /* How to handle unresolved symbols. 214 There are four possibilities which are enumerated below: */ 215 enum report_method 216 { 217 /* This is the initial value when then link_info structure is created. 218 It allows the various stages of the linker to determine whether they 219 allowed to set the value. */ 220 RM_NOT_YET_SET = 0, 221 RM_IGNORE, 222 RM_GENERATE_WARNING, 223 RM_GENERATE_ERROR 224 }; 225 226 struct bfd_elf_dynamic_list; 227 228 /* This structure holds all the information needed to communicate 229 between BFD and the linker when doing a link. */ 230 231 struct bfd_link_info 232 { 233 /* TRUE if BFD should generate a relocatable object file. */ 234 unsigned int relocatable: 1; 235 236 /* TRUE if BFD should generate relocation information in the final 237 executable. */ 238 unsigned int emitrelocations: 1; 239 240 /* TRUE if BFD should generate a "task linked" object file, 241 similar to relocatable but also with globals converted to 242 statics. */ 243 unsigned int task_link: 1; 244 245 /* TRUE if BFD should generate a shared object. */ 246 unsigned int shared: 1; 247 248 /* TRUE if BFD should pre-bind symbols in a shared object. */ 249 unsigned int symbolic: 1; 250 251 /* TRUE if BFD should export all symbols in the dynamic symbol table 252 of an executable, rather than only those used. */ 253 unsigned int export_dynamic: 1; 254 255 /* TRUE if shared objects should be linked directly, not shared. */ 256 unsigned int static_link: 1; 257 258 /* TRUE if the output file should be in a traditional format. This 259 is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag 260 on the output file, but may be checked when reading the input 261 files. */ 262 unsigned int traditional_format: 1; 263 264 /* TRUE if we want to produced optimized output files. This might 265 need much more time and therefore must be explicitly selected. */ 266 unsigned int optimize: 1; 267 268 /* TRUE if ok to have multiple definition. */ 269 unsigned int allow_multiple_definition: 1; 270 271 /* TRUE if ok to have version with no definition. */ 272 unsigned int allow_undefined_version: 1; 273 274 /* TRUE if a default symbol version should be created and used for 275 exported symbols. */ 276 unsigned int create_default_symver: 1; 277 278 /* TRUE if a default symbol version should be created and used for 279 imported symbols. */ 280 unsigned int default_imported_symver: 1; 281 282 /* TRUE if symbols should be retained in memory, FALSE if they 283 should be freed and reread. */ 284 unsigned int keep_memory: 1; 285 286 /* TRUE if every symbol should be reported back via the notice 287 callback. */ 288 unsigned int notice_all: 1; 289 290 /* TRUE if executable should not contain copy relocs. 291 Setting this true may result in a non-sharable text segment. */ 292 unsigned int nocopyreloc: 1; 293 294 /* TRUE if the new ELF dynamic tags are enabled. */ 295 unsigned int new_dtags: 1; 296 297 /* TRUE if non-PLT relocs should be merged into one reloc section 298 and sorted so that relocs against the same symbol come together. */ 299 unsigned int combreloc: 1; 300 301 /* TRUE if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment 302 should be created. */ 303 unsigned int eh_frame_hdr: 1; 304 305 /* TRUE if global symbols in discarded sections should be stripped. */ 306 unsigned int strip_discarded: 1; 307 308 /* TRUE if generating a position independent executable. */ 309 unsigned int pie: 1; 310 311 /* TRUE if generating an executable, position independent or not. */ 312 unsigned int executable : 1; 313 314 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W|PF_X 315 flags. */ 316 unsigned int execstack: 1; 317 318 /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W 319 flags. */ 320 unsigned int noexecstack: 1; 321 322 /* TRUE if PT_GNU_RELRO segment should be created. */ 323 unsigned int relro: 1; 324 325 /* TRUE if we should warn when adding a DT_TEXTREL to a shared object. */ 326 unsigned int warn_shared_textrel: 1; 327 328 /* TRUE if unreferenced sections should be removed. */ 329 unsigned int gc_sections: 1; 330 331 /* TRUE if user shoudl be informed of removed unreferenced sections. */ 332 unsigned int print_gc_sections: 1; 333 334 /* TRUE if .hash section should be created. */ 335 unsigned int emit_hash: 1; 336 337 /* TRUE if .gnu.hash section should be created. */ 338 unsigned int emit_gnu_hash: 1; 339 340 /* If TRUE reduce memory overheads, at the expense of speed. This will 341 cause map file generation to use an O(N^2) algorithm and disable 342 caching ELF symbol buffer. */ 343 unsigned int reduce_memory_overheads: 1; 344 345 /* What to do with unresolved symbols in an object file. 346 When producing executables the default is GENERATE_ERROR. 347 When producing shared libraries the default is IGNORE. The 348 assumption with shared libraries is that the reference will be 349 resolved at load/execution time. */ 350 enum report_method unresolved_syms_in_objects; 351 352 /* What to do with unresolved symbols in a shared library. 353 The same defaults apply. */ 354 enum report_method unresolved_syms_in_shared_libs; 355 356 /* Which symbols to strip. */ 357 enum bfd_link_strip strip; 358 359 /* Which local symbols to discard. */ 360 enum bfd_link_discard discard; 361 362 /* Criteria for skipping symbols when detemining 363 whether to include an object from an archive. */ 364 enum bfd_link_common_skip_ar_aymbols common_skip_ar_aymbols; 365 366 /* Char that may appear as the first char of a symbol, but should be 367 skipped (like symbol_leading_char) when looking up symbols in 368 wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ 369 char wrap_char; 370 371 /* Function callbacks. */ 372 const struct bfd_link_callbacks *callbacks; 373 374 /* Hash table handled by BFD. */ 375 struct bfd_link_hash_table *hash; 376 377 /* Hash table of symbols to keep. This is NULL unless strip is 378 strip_some. */ 379 struct bfd_hash_table *keep_hash; 380 381 /* Hash table of symbols to report back via the notice callback. If 382 this is NULL, and notice_all is FALSE, then no symbols are 383 reported back. */ 384 struct bfd_hash_table *notice_hash; 385 386 /* Hash table of symbols which are being wrapped (the --wrap linker 387 option). If this is NULL, no symbols are being wrapped. */ 388 struct bfd_hash_table *wrap_hash; 389 390 /* The list of input BFD's involved in the link. These are chained 391 together via the link_next field. */ 392 bfd *input_bfds; 393 394 /* If a symbol should be created for each input BFD, this is section 395 where those symbols should be placed. It must be a section in 396 the output BFD. It may be NULL, in which case no such symbols 397 will be created. This is to support CREATE_OBJECT_SYMBOLS in the 398 linker command language. */ 399 asection *create_object_symbols_section; 400 401 /* List of global symbol names that are starting points for marking 402 sections against garbage collection. */ 403 struct bfd_sym_chain *gc_sym_list; 404 405 /* If a base output file is wanted, then this points to it */ 406 void *base_file; 407 408 /* The function to call when the executable or shared object is 409 loaded. */ 410 const char *init_function; 411 412 /* The function to call when the executable or shared object is 413 unloaded. */ 414 const char *fini_function; 415 416 /* Number of relaxation passes. Usually only one relaxation pass 417 is needed. But a backend can have as many relaxation passes as 418 necessary. During bfd_relax_section call, it is set to the 419 current pass, starting from 0. */ 420 int relax_pass; 421 422 /* Non-zero if auto-import thunks for DATA items in pei386 DLLs 423 should be generated/linked against. Set to 1 if this feature 424 is explicitly requested by the user, -1 if enabled by default. */ 425 int pei386_auto_import; 426 427 /* Non-zero if runtime relocs for DATA items with non-zero addends 428 in pei386 DLLs should be generated. Set to 1 if this feature 429 is explicitly requested by the user, -1 if enabled by default. */ 430 int pei386_runtime_pseudo_reloc; 431 432 /* How many spare .dynamic DT_NULL entries should be added? */ 433 unsigned int spare_dynamic_tags; 434 435 /* May be used to set DT_FLAGS for ELF. */ 436 bfd_vma flags; 437 438 /* May be used to set DT_FLAGS_1 for ELF. */ 439 bfd_vma flags_1; 440 441 /* Start and end of RELRO region. */ 442 bfd_vma relro_start, relro_end; 443 444 /* List of symbols should be dynamic. */ 445 struct bfd_elf_dynamic_list *dynamic; 446 }; 447 448 /* This structures holds a set of callback functions. These are 449 called by the BFD linker routines. Except for einfo, the first 450 argument to each callback function is the bfd_link_info structure 451 being used and each function returns a boolean value. If the 452 function returns FALSE, then the BFD function which called it should 453 return with a failure indication. */ 454 455 struct bfd_link_callbacks 456 { 457 /* A function which is called when an object is added from an 458 archive. ABFD is the archive element being added. NAME is the 459 name of the symbol which caused the archive element to be pulled 460 in. */ 461 bfd_boolean (*add_archive_element) 462 (struct bfd_link_info *, bfd *abfd, const char *name); 463 /* A function which is called when a symbol is found with multiple 464 definitions. NAME is the symbol which is defined multiple times. 465 OBFD is the old BFD, OSEC is the old section, OVAL is the old 466 value, NBFD is the new BFD, NSEC is the new section, and NVAL is 467 the new value. OBFD may be NULL. OSEC and NSEC may be 468 bfd_com_section or bfd_ind_section. */ 469 bfd_boolean (*multiple_definition) 470 (struct bfd_link_info *, const char *name, 471 bfd *obfd, asection *osec, bfd_vma oval, 472 bfd *nbfd, asection *nsec, bfd_vma nval); 473 /* A function which is called when a common symbol is defined 474 multiple times. NAME is the symbol appearing multiple times. 475 OBFD is the BFD of the existing symbol; it may be NULL if this is 476 not known. OTYPE is the type of the existing symbol, which may 477 be bfd_link_hash_defined, bfd_link_hash_defweak, 478 bfd_link_hash_common, or bfd_link_hash_indirect. If OTYPE is 479 bfd_link_hash_common, OSIZE is the size of the existing symbol. 480 NBFD is the BFD of the new symbol. NTYPE is the type of the new 481 symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 482 bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 483 is the size of the new symbol. */ 484 bfd_boolean (*multiple_common) 485 (struct bfd_link_info *, const char *name, 486 bfd *obfd, enum bfd_link_hash_type otype, bfd_vma osize, 487 bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize); 488 /* A function which is called to add a symbol to a set. ENTRY is 489 the link hash table entry for the set itself (e.g., 490 __CTOR_LIST__). RELOC is the relocation to use for an entry in 491 the set when generating a relocatable file, and is also used to 492 get the size of the entry when generating an executable file. 493 ABFD, SEC and VALUE identify the value to add to the set. */ 494 bfd_boolean (*add_to_set) 495 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 496 bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value); 497 /* A function which is called when the name of a g++ constructor or 498 destructor is found. This is only called by some object file 499 formats. CONSTRUCTOR is TRUE for a constructor, FALSE for a 500 destructor. This will use BFD_RELOC_CTOR when generating a 501 relocatable file. NAME is the name of the symbol found. ABFD, 502 SECTION and VALUE are the value of the symbol. */ 503 bfd_boolean (*constructor) 504 (struct bfd_link_info *, bfd_boolean constructor, const char *name, 505 bfd *abfd, asection *sec, bfd_vma value); 506 /* A function which is called to issue a linker warning. For 507 example, this is called when there is a reference to a warning 508 symbol. WARNING is the warning to be issued. SYMBOL is the name 509 of the symbol which triggered the warning; it may be NULL if 510 there is none. ABFD, SECTION and ADDRESS identify the location 511 which trigerred the warning; either ABFD or SECTION or both may 512 be NULL if the location is not known. */ 513 bfd_boolean (*warning) 514 (struct bfd_link_info *, const char *warning, const char *symbol, 515 bfd *abfd, asection *section, bfd_vma address); 516 /* A function which is called when a relocation is attempted against 517 an undefined symbol. NAME is the symbol which is undefined. 518 ABFD, SECTION and ADDRESS identify the location from which the 519 reference is made. FATAL indicates whether an undefined symbol is 520 a fatal error or not. In some cases SECTION may be NULL. */ 521 bfd_boolean (*undefined_symbol) 522 (struct bfd_link_info *, const char *name, bfd *abfd, 523 asection *section, bfd_vma address, bfd_boolean fatal); 524 /* A function which is called when a reloc overflow occurs. ENTRY is 525 the link hash table entry for the symbol the reloc is against. 526 NAME is the name of the local symbol or section the reloc is 527 against, RELOC_NAME is the name of the relocation, and ADDEND is 528 any addend that is used. ABFD, SECTION and ADDRESS identify the 529 location at which the overflow occurs; if this is the result of a 530 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 531 ABFD will be NULL. */ 532 bfd_boolean (*reloc_overflow) 533 (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 534 const char *name, const char *reloc_name, bfd_vma addend, 535 bfd *abfd, asection *section, bfd_vma address); 536 /* A function which is called when a dangerous reloc is performed. 537 MESSAGE is an appropriate message. 538 ABFD, SECTION and ADDRESS identify the location at which the 539 problem occurred; if this is the result of a 540 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 541 ABFD will be NULL. */ 542 bfd_boolean (*reloc_dangerous) 543 (struct bfd_link_info *, const char *message, 544 bfd *abfd, asection *section, bfd_vma address); 545 /* A function which is called when a reloc is found to be attached 546 to a symbol which is not being written out. NAME is the name of 547 the symbol. ABFD, SECTION and ADDRESS identify the location of 548 the reloc; if this is the result of a 549 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 550 ABFD will be NULL. */ 551 bfd_boolean (*unattached_reloc) 552 (struct bfd_link_info *, const char *name, 553 bfd *abfd, asection *section, bfd_vma address); 554 /* A function which is called when a symbol in notice_hash is 555 defined or referenced. NAME is the symbol. ABFD, SECTION and 556 ADDRESS are the value of the symbol. If SECTION is 557 bfd_und_section, this is a reference. */ 558 bfd_boolean (*notice) 559 (struct bfd_link_info *, const char *name, 560 bfd *abfd, asection *section, bfd_vma address); 561 /* General link info message. */ 562 void (*einfo) 563 (const char *fmt, ...); 564 }; 565 566 /* The linker builds link_order structures which tell the code how to 568 include input data in the output file. */ 569 570 /* These are the types of link_order structures. */ 571 572 enum bfd_link_order_type 573 { 574 bfd_undefined_link_order, /* Undefined. */ 575 bfd_indirect_link_order, /* Built from a section. */ 576 bfd_data_link_order, /* Set to explicit data. */ 577 bfd_section_reloc_link_order, /* Relocate against a section. */ 578 bfd_symbol_reloc_link_order /* Relocate against a symbol. */ 579 }; 580 581 /* This is the link_order structure itself. These form a chain 582 attached to the output section whose contents they are describing. */ 583 584 struct bfd_link_order 585 { 586 /* Next link_order in chain. */ 587 struct bfd_link_order *next; 588 /* Type of link_order. */ 589 enum bfd_link_order_type type; 590 /* Offset within output section. */ 591 bfd_vma offset; 592 /* Size within output section. */ 593 bfd_size_type size; 594 /* Type specific information. */ 595 union 596 { 597 struct 598 { 599 /* Section to include. If this is used, then 600 section->output_section must be the section the 601 link_order is attached to, section->output_offset must 602 equal the link_order offset field, and section->size 603 must equal the link_order size field. Maybe these 604 restrictions should be relaxed someday. */ 605 asection *section; 606 } indirect; 607 struct 608 { 609 /* Size of contents, or zero when contents size == size 610 within output section. 611 A non-zero value allows filling of the output section 612 with an arbitrary repeated pattern. */ 613 unsigned int size; 614 /* Data to put into file. */ 615 bfd_byte *contents; 616 } data; 617 struct 618 { 619 /* Description of reloc to generate. Used for 620 bfd_section_reloc_link_order and 621 bfd_symbol_reloc_link_order. */ 622 struct bfd_link_order_reloc *p; 623 } reloc; 624 } u; 625 }; 626 627 /* A linker order of type bfd_section_reloc_link_order or 628 bfd_symbol_reloc_link_order means to create a reloc against a 629 section or symbol, respectively. This is used to implement -Ur to 630 generate relocs for the constructor tables. The 631 bfd_link_order_reloc structure describes the reloc that BFD should 632 create. It is similar to a arelent, but I didn't use arelent 633 because the linker does not know anything about most symbols, and 634 any asymbol structure it creates will be partially meaningless. 635 This information could logically be in the bfd_link_order struct, 636 but I didn't want to waste the space since these types of relocs 637 are relatively rare. */ 638 639 struct bfd_link_order_reloc 640 { 641 /* Reloc type. */ 642 bfd_reloc_code_real_type reloc; 643 644 union 645 { 646 /* For type bfd_section_reloc_link_order, this is the section 647 the reloc should be against. This must be a section in the 648 output BFD, not any of the input BFDs. */ 649 asection *section; 650 /* For type bfd_symbol_reloc_link_order, this is the name of the 651 symbol the reloc should be against. */ 652 const char *name; 653 } u; 654 655 /* Addend to use. The object file should contain zero. The BFD 656 backend is responsible for filling in the contents of the object 657 file correctly. For some object file formats (e.g., COFF) the 658 addend must be stored into in the object file, and for some 659 (e.g., SPARC a.out) it is kept in the reloc. */ 660 bfd_vma addend; 661 }; 662 663 /* Allocate a new link_order for a section. */ 664 extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *); 665 666 /* These structures are used to describe version information for the 667 ELF linker. These structures could be manipulated entirely inside 668 BFD, but it would be a pain. Instead, the regular linker sets up 669 these structures, and then passes them into BFD. */ 670 671 /* Glob pattern for a version. */ 672 673 struct bfd_elf_version_expr 674 { 675 /* Next glob pattern for this version. */ 676 struct bfd_elf_version_expr *next; 677 /* Glob pattern. */ 678 const char *pattern; 679 /* NULL for a glob pattern, otherwise a straight symbol. */ 680 const char *symbol; 681 /* Defined by ".symver". */ 682 unsigned int symver : 1; 683 /* Defined by version script. */ 684 unsigned int script : 1; 685 /* Pattern type. */ 686 #define BFD_ELF_VERSION_C_TYPE 1 687 #define BFD_ELF_VERSION_CXX_TYPE 2 688 #define BFD_ELF_VERSION_JAVA_TYPE 4 689 unsigned int mask : 3; 690 }; 691 692 struct bfd_elf_version_expr_head 693 { 694 /* List of all patterns, both wildcards and non-wildcards. */ 695 struct bfd_elf_version_expr *list; 696 /* Hash table for non-wildcards. */ 697 void *htab; 698 /* Remaining patterns. */ 699 struct bfd_elf_version_expr *remaining; 700 /* What kind of pattern types are present in list (bitmask). */ 701 unsigned int mask; 702 }; 703 704 /* Version dependencies. */ 705 706 struct bfd_elf_version_deps 707 { 708 /* Next dependency for this version. */ 709 struct bfd_elf_version_deps *next; 710 /* The version which this version depends upon. */ 711 struct bfd_elf_version_tree *version_needed; 712 }; 713 714 /* A node in the version tree. */ 715 716 struct bfd_elf_version_tree 717 { 718 /* Next version. */ 719 struct bfd_elf_version_tree *next; 720 /* Name of this version. */ 721 const char *name; 722 /* Version number. */ 723 unsigned int vernum; 724 /* Regular expressions for global symbols in this version. */ 725 struct bfd_elf_version_expr_head globals; 726 /* Regular expressions for local symbols in this version. */ 727 struct bfd_elf_version_expr_head locals; 728 /* List of versions which this version depends upon. */ 729 struct bfd_elf_version_deps *deps; 730 /* Index of the version name. This is used within BFD. */ 731 unsigned int name_indx; 732 /* Whether this version tree was used. This is used within BFD. */ 733 int used; 734 /* Matching hook. */ 735 struct bfd_elf_version_expr *(*match) 736 (struct bfd_elf_version_expr_head *head, 737 struct bfd_elf_version_expr *prev, const char *sym); 738 }; 739 740 struct bfd_elf_dynamic_list 741 { 742 struct bfd_elf_version_expr_head head; 743 struct bfd_elf_version_expr *(*match) 744 (struct bfd_elf_version_expr_head *head, 745 struct bfd_elf_version_expr *prev, const char *sym); 746 }; 747 748 #endif 749