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, 2006, 2007 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 3 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, 21: MA 02110-1301, USA. */ 22: 23: #ifndef BFDLINK_H 24: #define BFDLINK_H 25: 26: /* Which symbols to strip during a link. */ 27: enum bfd_link_strip 28: { 29: strip_none, /* Don't strip any symbols. */ 30: strip_debugger, /* Strip debugging symbols. */ 31: strip_some, /* keep_hash is the list of symbols to keep. */ 32: strip_all /* Strip all symbols. */ 33: }; 34: 35: /* Which local symbols to discard during a link. This is irrelevant 36: if strip_all is used. */ 37: enum bfd_link_discard 38: { 39: discard_sec_merge, /* Discard local temporary symbols in SEC_MERGE 40: sections. */ 41: discard_none, /* Don't discard any locals. */ 42: discard_l, /* Discard local temporary symbols. */ 43: discard_all /* Discard all locals. */ 44: }; 45: 46: /* Describes the type of hash table entry structure being used. 47: Different hash table structure have different fields and so 48: support different linking features. */ 49: enum bfd_link_hash_table_type 50: { 51: bfd_link_generic_hash_table, 52: bfd_link_elf_hash_table 53: }; 54: ^L 55: /* 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: ^L 212: /* How to handle unresolved symbols. 213: There are four possibilities which are enumerated below: */ 214: enum report_method 215: { 216: /* This is the initial value when then link_info structure is created. 217: It allows the various stages of the linker to determine whether they 218: allowed to set the value. */ 219: RM_NOT_YET_SET = 0, 220: RM_IGNORE, 221: RM_GENERATE_WARNING, 222: RM_GENERATE_ERROR 223: }; 224: 225: struct bfd_elf_dynamic_list; 226: 227: /* This structure holds all the information needed to communicate 228: between BFD and the linker when doing a link. */ 229: 230: struct bfd_link_info 231: { 232: /* TRUE if BFD should generate a relocatable object file. */ 233: unsigned int relocatable: 1; 234: 235: /* TRUE if BFD should generate relocation information in the final 236: executable. */ 237: unsigned int emitrelocations: 1; 238: 239: /* TRUE if BFD should generate a "task linked" object file, 240: similar to relocatable but also with globals converted to 241: statics. */ 242: unsigned int task_link: 1; 243: 244: /* TRUE if BFD should generate a shared object. */ 245: unsigned int shared: 1; 246: 247: /* TRUE if BFD should pre-bind symbols in a shared object. */ 248: unsigned int symbolic: 1; 249: 250: /* TRUE if BFD should export all symbols in the dynamic symbol table 251: of an executable, rather than only those used. */ 252: unsigned int export_dynamic: 1; 253: 254: /* TRUE if shared objects should be linked directly, not shared. */ 255: unsigned int static_link: 1; 256: 257: /* TRUE if the output file should be in a traditional format. This 258: is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag 259: on the output file, but may be checked when reading the input 260: files. */ 261: unsigned int traditional_format: 1; 262: 263: /* TRUE if we want to produced optimized output files. This might 264: need much more time and therefore must be explicitly selected. */ 265: unsigned int optimize: 1; 266: 267: /* TRUE if ok to have multiple definition. */ 268: unsigned int allow_multiple_definition: 1; 269: 270: /* TRUE if ok to have version with no definition. */ 271: unsigned int allow_undefined_version: 1; 272: 273: /* TRUE if a default symbol version should be created and used for 274: exported symbols. */ 275: unsigned int create_default_symver: 1; 276: 277: /* TRUE if a default symbol version should be created and used for 278: imported symbols. */ 279: unsigned int default_imported_symver: 1; 280: 281: /* TRUE if symbols should be retained in memory, FALSE if they 282: should be freed and reread. */ 283: unsigned int keep_memory: 1; 284: 285: /* TRUE if every symbol should be reported back via the notice 286: callback. */ 287: unsigned int notice_all: 1; 288: 289: /* TRUE if executable should not contain copy relocs. 290: Setting this true may result in a non-sharable text segment. */ 291: unsigned int nocopyreloc: 1; 292: 293: /* TRUE if the new ELF dynamic tags are enabled. */ 294: unsigned int new_dtags: 1; 295: 296: /* TRUE if non-PLT relocs should be merged into one reloc section 297: and sorted so that relocs against the same symbol come together. */ 298: unsigned int combreloc: 1; 299: 300: /* TRUE if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment 301: should be created. */ 302: unsigned int eh_frame_hdr: 1; 303: 304: /* TRUE if global symbols in discarded sections should be stripped. */ 305: unsigned int strip_discarded: 1; 306: 307: /* TRUE if generating a position independent executable. */ 308: unsigned int pie: 1; 309: 310: /* TRUE if generating an executable, position independent or not. */ 311: unsigned int executable : 1; 312: 313: /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W|PF_X 314: flags. */ 315: unsigned int execstack: 1; 316: 317: /* TRUE if PT_GNU_STACK segment should be created with PF_R|PF_W 318: flags. */ 319: unsigned int noexecstack: 1; 320: 321: /* TRUE if PT_GNU_RELRO segment should be created. */ 322: unsigned int relro: 1; 323: 324: /* TRUE if we should warn when adding a DT_TEXTREL to a shared object. */ 325: unsigned int warn_shared_textrel: 1; 326: 327: /* TRUE if unreferenced sections should be removed. */ 328: unsigned int gc_sections: 1; 329: 330: /* TRUE if user shoudl be informed of removed unreferenced sections. */ 331: unsigned int print_gc_sections: 1; 332: 333: /* TRUE if .hash section should be created. */ 334: unsigned int emit_hash: 1; 335: 336: /* TRUE if .gnu.hash section should be created. */ 337: unsigned int emit_gnu_hash: 1; 338: 339: /* If TRUE reduce memory overheads, at the expense of speed. This will 340: cause map file generation to use an O(N^2) algorithm and disable 341: caching ELF symbol buffer. */ 342: unsigned int reduce_memory_overheads: 1; 343: 344: /* TRUE if all data symbols should be dynamic. */ 345: unsigned int dynamic_data: 1; 346: 347: /* TRUE if some symbols have to be dynamic, controlled by 348: --dynamic-list command line options. */ 349: unsigned int dynamic: 1; 350: 351: /* Non-NULL if .note.gnu.build-id section should be created. */ 352: char *emit_note_gnu_build_id; 353: 354: /* What to do with unresolved symbols in an object file. 355: When producing executables the default is GENERATE_ERROR. 356: When producing shared libraries the default is IGNORE. The 357: assumption with shared libraries is that the reference will be 358: resolved at load/execution time. */ 359: enum report_method unresolved_syms_in_objects; 360: 361: /* What to do with unresolved symbols in a shared library. 362: The same defaults apply. */ 363: enum report_method unresolved_syms_in_shared_libs; 364: 365: /* Which symbols to strip. */ 366: enum bfd_link_strip strip; 367: 368: /* Which local symbols to discard. */ 369: enum bfd_link_discard discard; 370: 371: /* Criteria for skipping symbols when detemining 372: whether to include an object from an archive. */ 373: enum bfd_link_common_skip_ar_aymbols common_skip_ar_aymbols; 374: 375: /* Char that may appear as the first char of a symbol, but should be 376: skipped (like symbol_leading_char) when looking up symbols in 377: wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ 378: char wrap_char; 379: 380: /* Function callbacks. */ 381: const struct bfd_link_callbacks *callbacks; 382: 383: /* Hash table handled by BFD. */ 384: struct bfd_link_hash_table *hash; 385: 386: /* Hash table of symbols to keep. This is NULL unless strip is 387: strip_some. */ 388: struct bfd_hash_table *keep_hash; 389: 390: /* Hash table of symbols to report back via the notice callback. If 391: this is NULL, and notice_all is FALSE, then no symbols are 392: reported back. */ 393: struct bfd_hash_table *notice_hash; 394: 395: /* Hash table of symbols which are being wrapped (the --wrap linker 396: option). If this is NULL, no symbols are being wrapped. */ 397: struct bfd_hash_table *wrap_hash; 398: 399: /* The list of input BFD's involved in the link. These are chained 400: together via the link_next field. */ 401: bfd *input_bfds; 402: bfd **input_bfds_tail; 403: 404: /* If a symbol should be created for each input BFD, this is section 405: where those symbols should be placed. It must be a section in 406: the output BFD. It may be NULL, in which case no such symbols 407: will be created. This is to support CREATE_OBJECT_SYMBOLS in the 408: linker command language. */ 409: asection *create_object_symbols_section; 410: 411: /* List of global symbol names that are starting points for marking 412: sections against garbage collection. */ 413: struct bfd_sym_chain *gc_sym_list; 414: 415: /* If a base output file is wanted, then this points to it */ 416: void *base_file; 417: 418: /* The function to call when the executable or shared object is 419: loaded. */ 420: const char *init_function; 421: 422: /* The function to call when the executable or shared object is 423: unloaded. */ 424: const char *fini_function; 425: 426: /* Number of relaxation passes. Usually only one relaxation pass 427: is needed. But a backend can have as many relaxation passes as 428: necessary. During bfd_relax_section call, it is set to the 429: current pass, starting from 0. */ 430: int relax_pass; 431: 432: /* Number of relaxation trips. This number is incremented every 433: time the relaxation pass is restarted due to a previous 434: relaxation returning true in *AGAIN. */ 435: int relax_trip; 436: 437: /* Non-zero if auto-import thunks for DATA items in pei386 DLLs 438: should be generated/linked against. Set to 1 if this feature 439: is explicitly requested by the user, -1 if enabled by default. */ 440: int pei386_auto_import; 441: 442: /* Non-zero if runtime relocs for DATA items with non-zero addends 443: in pei386 DLLs should be generated. Set to 1 if this feature 444: is explicitly requested by the user, -1 if enabled by default. */ 445: int pei386_runtime_pseudo_reloc; 446: 447: /* How many spare .dynamic DT_NULL entries should be added? */ 448: unsigned int spare_dynamic_tags; 449: 450: /* May be used to set DT_FLAGS for ELF. */ 451: bfd_vma flags; 452: 453: /* May be used to set DT_FLAGS_1 for ELF. */ 454: bfd_vma flags_1; 455: 456: /* Start and end of RELRO region. */ 457: bfd_vma relro_start, relro_end; 458: 459: /* List of symbols should be dynamic. */ 460: struct bfd_elf_dynamic_list *dynamic_list; 461: }; 462: 463: /* This structures holds a set of callback functions. These are called 464: by the BFD linker routines. Except for the info functions, the first 465: argument to each callback function is the bfd_link_info structure 466: being used and each function returns a boolean value. If the 467: function returns FALSE, then the BFD function which called it should 468: return with a failure indication. */ 469: 470: struct bfd_link_callbacks 471: { 472: /* A function which is called when an object is added from an 473: archive. ABFD is the archive element being added. NAME is the 474: name of the symbol which caused the archive element to be pulled 475: in. */ 476: bfd_boolean (*add_archive_element) 477: (struct bfd_link_info *, bfd *abfd, const char *name); 478: /* A function which is called when a symbol is found with multiple 479: definitions. NAME is the symbol which is defined multiple times. 480: OBFD is the old BFD, OSEC is the old section, OVAL is the old 481: value, NBFD is the new BFD, NSEC is the new section, and NVAL is 482: the new value. OBFD may be NULL. OSEC and NSEC may be 483: bfd_com_section or bfd_ind_section. */ 484: bfd_boolean (*multiple_definition) 485: (struct bfd_link_info *, const char *name, 486: bfd *obfd, asection *osec, bfd_vma oval, 487: bfd *nbfd, asection *nsec, bfd_vma nval); 488: /* A function which is called when a common symbol is defined 489: multiple times. NAME is the symbol appearing multiple times. 490: OBFD is the BFD of the existing symbol; it may be NULL if this is 491: not known. OTYPE is the type of the existing symbol, which may 492: be bfd_link_hash_defined, bfd_link_hash_defweak, 493: bfd_link_hash_common, or bfd_link_hash_indirect. If OTYPE is 494: bfd_link_hash_common, OSIZE is the size of the existing symbol. 495: NBFD is the BFD of the new symbol. NTYPE is the type of the new 496: symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 497: bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 498: is the size of the new symbol. */ 499: bfd_boolean (*multiple_common) 500: (struct bfd_link_info *, const char *name, 501: bfd *obfd, enum bfd_link_hash_type otype, bfd_vma osize, 502: bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize); 503: /* A function which is called to add a symbol to a set. ENTRY is 504: the link hash table entry for the set itself (e.g., 505: __CTOR_LIST__). RELOC is the relocation to use for an entry in 506: the set when generating a relocatable file, and is also used to 507: get the size of the entry when generating an executable file. 508: ABFD, SEC and VALUE identify the value to add to the set. */ 509: bfd_boolean (*add_to_set) 510: (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 511: bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value); 512: /* A function which is called when the name of a g++ constructor or 513: destructor is found. This is only called by some object file 514: formats. CONSTRUCTOR is TRUE for a constructor, FALSE for a 515: destructor. This will use BFD_RELOC_CTOR when generating a 516: relocatable file. NAME is the name of the symbol found. ABFD, 517: SECTION and VALUE are the value of the symbol. */ 518: bfd_boolean (*constructor) 519: (struct bfd_link_info *, bfd_boolean constructor, const char *name, 520: bfd *abfd, asection *sec, bfd_vma value); 521: /* A function which is called to issue a linker warning. For 522: example, this is called when there is a reference to a warning 523: symbol. WARNING is the warning to be issued. SYMBOL is the name 524: of the symbol which triggered the warning; it may be NULL if 525: there is none. ABFD, SECTION and ADDRESS identify the location 526: which trigerred the warning; either ABFD or SECTION or both may 527: be NULL if the location is not known. */ 528: bfd_boolean (*warning) 529: (struct bfd_link_info *, const char *warning, const char *symbol, 530: bfd *abfd, asection *section, bfd_vma address); 531: /* A function which is called when a relocation is attempted against 532: an undefined symbol. NAME is the symbol which is undefined. 533: ABFD, SECTION and ADDRESS identify the location from which the 534: reference is made. FATAL indicates whether an undefined symbol is 535: a fatal error or not. In some cases SECTION may be NULL. */ 536: bfd_boolean (*undefined_symbol) 537: (struct bfd_link_info *, const char *name, bfd *abfd, 538: asection *section, bfd_vma address, bfd_boolean fatal); 539: /* A function which is called when a reloc overflow occurs. ENTRY is 540: the link hash table entry for the symbol the reloc is against. 541: NAME is the name of the local symbol or section the reloc is 542: against, RELOC_NAME is the name of the relocation, and ADDEND is 543: any addend that is used. ABFD, SECTION and ADDRESS identify the 544: location at which the overflow occurs; if this is the result of a 545: bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 546: ABFD will be NULL. */ 547: bfd_boolean (*reloc_overflow) 548: (struct bfd_link_info *, struct bfd_link_hash_entry *entry, 549: const char *name, const char *reloc_name, bfd_vma addend, 550: bfd *abfd, asection *section, bfd_vma address); 551: /* A function which is called when a dangerous reloc is performed. 552: MESSAGE is an appropriate message. 553: ABFD, SECTION and ADDRESS identify the location at which the 554: problem occurred; if this is the result of a 555: bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 556: ABFD will be NULL. */ 557: bfd_boolean (*reloc_dangerous) 558: (struct bfd_link_info *, const char *message, 559: bfd *abfd, asection *section, bfd_vma address); 560: /* A function which is called when a reloc is found to be attached 561: to a symbol which is not being written out. NAME is the name of 562: the symbol. ABFD, SECTION and ADDRESS identify the location of 563: the reloc; if this is the result of a 564: bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 565: ABFD will be NULL. */ 566: bfd_boolean (*unattached_reloc) 567: (struct bfd_link_info *, const char *name, 568: bfd *abfd, asection *section, bfd_vma address); 569: /* A function which is called when a symbol in notice_hash is 570: defined or referenced. NAME is the symbol. ABFD, SECTION and 571: ADDRESS are the value of the symbol. If SECTION is 572: bfd_und_section, this is a reference. */ 573: bfd_boolean (*notice) 574: (struct bfd_link_info *, const char *name, 575: bfd *abfd, asection *section, bfd_vma address); 576: /* Error or warning link info message. */ 577: void (*einfo) 578: (const char *fmt, ...); 579: /* General link info message. */ 580: void (*info) 581: (const char *fmt, ...); 582: /* Message to be printed in linker map file. */ 583: void (*minfo) 584: (const char *fmt, ...); 585: /* This callback provides a chance for users of the BFD library to 586: override its decision about whether to place two adjacent sections 587: into the same segment. */ 588: bfd_boolean (*override_segment_assignment) 589: