bfdlink.h revision 1.2
1/* bfdlink.h -- header file for BFD link routines 2 Copyright 1993 Free Software Foundation, Inc. 3 Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#ifndef BFDLINK_H 22#define BFDLINK_H 23 24/* Which symbols to strip during a link. */ 25enum bfd_link_strip 26{ 27 strip_none, /* Don't strip any symbols. */ 28 strip_debugger, /* Strip debugging symbols. */ 29 strip_some, /* keep_hash is the list of symbols to keep. */ 30 strip_all /* Strip all symbols. */ 31}; 32 33/* Which local symbols to discard during a link. This is irrelevant 34 if strip_all is used. */ 35enum bfd_link_discard 36{ 37 discard_none, /* Don't discard any locals. */ 38 discard_l, /* Discard locals with a certain prefix. */ 39 discard_all /* Discard all locals. */ 40}; 41 42/* These are the possible types of an entry in the BFD link hash 43 table. */ 44 45enum bfd_link_hash_type 46{ 47 bfd_link_hash_new, /* Symbol is new. */ 48 bfd_link_hash_undefined, /* Symbol seen before, but undefined. */ 49 bfd_link_hash_undefweak, /* Symbol is weak and undefined. */ 50 bfd_link_hash_defined, /* Symbol is defined. */ 51 bfd_link_hash_defweak, /* Symbol is weak and defined. */ 52 bfd_link_hash_common, /* Symbol is common. */ 53 bfd_link_hash_indirect, /* Symbol is an indirect link. */ 54 bfd_link_hash_warning /* Like indirect, but warn if referenced. */ 55}; 56 57/* The linking routines use a hash table which uses this structure for 58 its elements. */ 59 60struct bfd_link_hash_entry 61{ 62 /* Base hash table entry structure. */ 63 struct bfd_hash_entry root; 64 /* Type of this entry. */ 65 enum bfd_link_hash_type type; 66 67 /* Undefined and common symbols are kept in a linked list through 68 this field. This field is not in the union because that would 69 force us to remove entries from the list when we changed their 70 type, which would force the list to be doubly linked, which would 71 waste more memory. When an undefined or common symbol is 72 created, it should be added to this list, the head of which is in 73 the link hash table itself. As symbols are defined, they need 74 not be removed from the list; anything which reads the list must 75 doublecheck the symbol type. 76 77 Weak symbols are not kept on this list. 78 79 Defined and defweak symbols use this field as a reference marker. 80 If the field is not NULL, or this structure is the tail of the 81 undefined symbol list, the symbol has been referenced. If the 82 symbol is undefined and becomes defined, this field will 83 automatically be non-NULL since the symbol will have been on the 84 undefined symbol list. */ 85 struct bfd_link_hash_entry *next; 86 /* A union of information depending upon the type. */ 87 union 88 { 89 /* Nothing is kept for bfd_hash_new. */ 90 /* bfd_link_hash_undefined, bfd_link_hash_undefweak. */ 91 struct 92 { 93 bfd *abfd; /* BFD symbol was found in. */ 94 } undef; 95 /* bfd_link_hash_defined, bfd_link_hash_defweak. */ 96 struct 97 { 98 bfd_vma value; /* Symbol value. */ 99 asection *section; /* Symbol section. */ 100 } def; 101 /* bfd_link_hash_indirect, bfd_link_hash_warning. */ 102 struct 103 { 104 struct bfd_link_hash_entry *link; /* Real symbol. */ 105 const char *warning; /* Warning (bfd_link_hash_warning only). */ 106 } i; 107 /* bfd_link_hash_common. */ 108 struct 109 { 110 /* The linker needs to know three things about common 111 symbols: the size, the alignment, and the section in 112 which the symbol should be placed. We store the size 113 here, and we allocate a small structure to hold the 114 section and the alignment. The alignment is stored as a 115 power of two. We don't store all the information 116 directly because we don't want to increase the size of 117 the union; this structure is a major space user in the 118 linker. */ 119 bfd_size_type size; /* Common symbol size. */ 120 struct bfd_link_hash_common_entry 121 { 122 unsigned int alignment_power; /* Alignment. */ 123 asection *section; /* Symbol section. */ 124 } *p; 125 } c; 126 } u; 127}; 128 129/* This is the link hash table. It is a derived class of 130 bfd_hash_table. */ 131 132struct bfd_link_hash_table 133{ 134 /* The hash table itself. */ 135 struct bfd_hash_table table; 136 /* The back end which created this hash table. This indicates the 137 type of the entries in the hash table, which is sometimes 138 important information when linking object files of different 139 types together. */ 140 const bfd_target *creator; 141 /* A linked list of undefined and common symbols, linked through the 142 next field in the bfd_link_hash_entry structure. */ 143 struct bfd_link_hash_entry *undefs; 144 /* Entries are added to the tail of the undefs list. */ 145 struct bfd_link_hash_entry *undefs_tail; 146}; 147 148/* Look up an entry in a link hash table. If FOLLOW is true, this 149 follows bfd_link_hash_indirect and bfd_link_hash_warning links to 150 the real symbol. */ 151extern struct bfd_link_hash_entry *bfd_link_hash_lookup 152 PARAMS ((struct bfd_link_hash_table *, const char *, boolean create, 153 boolean copy, boolean follow)); 154 155/* Look up an entry in the main linker hash table if the symbol might 156 be wrapped. This should only be used for references to an 157 undefined symbol, not for definitions of a symbol. */ 158 159extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup 160 PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean, 161 boolean)); 162 163/* Traverse a link hash table. */ 164extern void bfd_link_hash_traverse 165 PARAMS ((struct bfd_link_hash_table *, 166 boolean (*) (struct bfd_link_hash_entry *, PTR), 167 PTR)); 168 169/* Add an entry to the undefs list. */ 170extern void bfd_link_add_undef 171 PARAMS ((struct bfd_link_hash_table *, struct bfd_link_hash_entry *)); 172 173/* This structure holds all the information needed to communicate 174 between BFD and the linker when doing a link. */ 175 176struct bfd_link_info 177{ 178 /* Function callbacks. */ 179 const struct bfd_link_callbacks *callbacks; 180 /* true if BFD should generate a relocateable object file. */ 181 boolean relocateable; 182 /* true if BFD should generate a shared object. */ 183 boolean shared; 184 /* true if BFD should pre-bind symbols in a shared object. */ 185 boolean symbolic; 186 /* true if shared objects should be linked directly, not shared. */ 187 boolean static_link; 188 /* true if the output file should be in a traditional format. This 189 is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag 190 on the output file, but may be checked when reading the input 191 files. */ 192 boolean traditional_format; 193 /* Which symbols to strip. */ 194 enum bfd_link_strip strip; 195 /* Which local symbols to discard. */ 196 enum bfd_link_discard discard; 197 /* The local symbol prefix to discard if using discard_l. */ 198 unsigned int lprefix_len; 199 const char *lprefix; 200 /* true if symbols should be retained in memory, false if they 201 should be freed and reread. */ 202 boolean keep_memory; 203 /* The list of input BFD's involved in the link. These are chained 204 together via the link_next field. */ 205 bfd *input_bfds; 206 /* If a symbol should be created for each input BFD, this is section 207 where those symbols should be placed. It must be a section in 208 the output BFD. It may be NULL, in which case no such symbols 209 will be created. This is to support CREATE_OBJECT_SYMBOLS in the 210 linker command language. */ 211 asection *create_object_symbols_section; 212 /* Hash table handled by BFD. */ 213 struct bfd_link_hash_table *hash; 214 /* Hash table of symbols to keep. This is NULL unless strip is 215 strip_some. */ 216 struct bfd_hash_table *keep_hash; 217 /* true if every symbol should be reported back via the notice 218 callback. */ 219 boolean notice_all; 220 /* Hash table of symbols to report back via the notice callback. If 221 this is NULL, and notice_all is false, then no symbols are 222 reported back. */ 223 struct bfd_hash_table *notice_hash; 224 /* Hash table of symbols which are being wrapped (the --wrap linker 225 option). If this is NULL, no symbols are being wrapped. */ 226 struct bfd_hash_table *wrap_hash; 227 /* If a base output file is wanted, then this points to it */ 228 PTR base_file; 229}; 230 231/* This structures holds a set of callback functions. These are 232 called by the BFD linker routines. The first argument to each 233 callback function is the bfd_link_info structure being used. Each 234 function returns a boolean value. If the function returns false, 235 then the BFD function which called it will return with a failure 236 indication. */ 237 238struct bfd_link_callbacks 239{ 240 /* A function which is called when an object is added from an 241 archive. ABFD is the archive element being added. NAME is the 242 name of the symbol which caused the archive element to be pulled 243 in. */ 244 boolean (*add_archive_element) PARAMS ((struct bfd_link_info *, 245 bfd *abfd, 246 const char *name)); 247 /* A function which is called when a symbol is found with multiple 248 definitions. NAME is the symbol which is defined multiple times. 249 OBFD is the old BFD, OSEC is the old section, OVAL is the old 250 value, NBFD is the new BFD, NSEC is the new section, and NVAL is 251 the new value. OBFD may be NULL. OSEC and NSEC may be 252 bfd_com_section or bfd_ind_section. */ 253 boolean (*multiple_definition) PARAMS ((struct bfd_link_info *, 254 const char *name, 255 bfd *obfd, 256 asection *osec, 257 bfd_vma oval, 258 bfd *nbfd, 259 asection *nsec, 260 bfd_vma nval)); 261 /* A function which is called when a common symbol is defined 262 multiple times. NAME is the symbol appearing multiple times. 263 OBFD is the BFD of the existing symbol; it may be NULL if this is 264 not known. OTYPE is the type of the existing symbol, which may 265 be bfd_link_hash_defined, bfd_link_hash_defweak, 266 bfd_link_hash_common, or bfd_link_hash_indirect. If OTYPE is 267 bfd_link_hash_common, OSIZE is the size of the existing symbol. 268 NBFD is the BFD of the new symbol. NTYPE is the type of the new 269 symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or 270 bfd_link_hash_indirect. If NTYPE is bfd_link_hash_common, NSIZE 271 is the size of the new symbol. */ 272 boolean (*multiple_common) PARAMS ((struct bfd_link_info *, 273 const char *name, 274 bfd *obfd, 275 enum bfd_link_hash_type otype, 276 bfd_vma osize, 277 bfd *nbfd, 278 enum bfd_link_hash_type ntype, 279 bfd_vma nsize)); 280 /* A function which is called to add a symbol to a set. ENTRY is 281 the link hash table entry for the set itself (e.g., 282 __CTOR_LIST__). RELOC is the relocation to use for an entry in 283 the set when generating a relocateable file, and is also used to 284 get the size of the entry when generating an executable file. 285 ABFD, SEC and VALUE identify the value to add to the set. */ 286 boolean (*add_to_set) PARAMS ((struct bfd_link_info *, 287 struct bfd_link_hash_entry *entry, 288 bfd_reloc_code_real_type reloc, 289 bfd *abfd, asection *sec, bfd_vma value)); 290 /* A function which is called when the name of a g++ constructor or 291 destructor is found. This is only called by some object file 292 formats. CONSTRUCTOR is true for a constructor, false for a 293 destructor. This will use BFD_RELOC_CTOR when generating a 294 relocateable file. NAME is the name of the symbol found. ABFD, 295 SECTION and VALUE are the value of the symbol. */ 296 boolean (*constructor) PARAMS ((struct bfd_link_info *, 297 boolean constructor, 298 const char *name, bfd *abfd, asection *sec, 299 bfd_vma value)); 300 /* A function which is called to issue a linker warning. For 301 example, this is called when there is a reference to a warning 302 symbol. WARNING is the warning to be issued. SYMBOL is the name 303 of the symbol which triggered the warning; it may be NULL if 304 there is none. ABFD, SECTION and ADDRESS identify the location 305 which trigerred the warning; either ABFD or SECTION or both may 306 be NULL if the location is not known. */ 307 boolean (*warning) PARAMS ((struct bfd_link_info *, 308 const char *warning, const char *symbol, 309 bfd *abfd, asection *section, 310 bfd_vma address)); 311 /* A function which is called when a relocation is attempted against 312 an undefined symbol. NAME is the symbol which is undefined. 313 ABFD, SECTION and ADDRESS identify the location from which the 314 reference is made. In some cases SECTION may be NULL. */ 315 boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *, 316 const char *name, bfd *abfd, 317 asection *section, bfd_vma address)); 318 /* A function which is called when a reloc overflow occurs. NAME is 319 the name of the symbol or section the reloc is against, 320 RELOC_NAME is the name of the relocation, and ADDEND is any 321 addend that is used. ABFD, SECTION and ADDRESS identify the 322 location at which the overflow occurs; if this is the result of a 323 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 324 ABFD will be NULL. */ 325 boolean (*reloc_overflow) PARAMS ((struct bfd_link_info *, 326 const char *name, 327 const char *reloc_name, bfd_vma addend, 328 bfd *abfd, asection *section, 329 bfd_vma address)); 330 /* A function which is called when a dangerous reloc is performed. 331 The canonical example is an a29k IHCONST reloc which does not 332 follow an IHIHALF reloc. MESSAGE is an appropriate message. 333 ABFD, SECTION and ADDRESS identify the location at which the 334 problem occurred; if this is the result of a 335 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 336 ABFD will be NULL. */ 337 boolean (*reloc_dangerous) PARAMS ((struct bfd_link_info *, 338 const char *message, 339 bfd *abfd, asection *section, 340 bfd_vma address)); 341 /* A function which is called when a reloc is found to be attached 342 to a symbol which is not being written out. NAME is the name of 343 the symbol. ABFD, SECTION and ADDRESS identify the location of 344 the reloc; if this is the result of a 345 bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then 346 ABFD will be NULL. */ 347 boolean (*unattached_reloc) PARAMS ((struct bfd_link_info *, 348 const char *name, 349 bfd *abfd, asection *section, 350 bfd_vma address)); 351 /* A function which is called when a symbol in notice_hash is 352 defined or referenced. NAME is the symbol. ABFD, SECTION and 353 ADDRESS are the value of the symbol. If SECTION is 354 bfd_und_section, this is a reference. */ 355 boolean (*notice) PARAMS ((struct bfd_link_info *, const char *name, 356 bfd *abfd, asection *section, bfd_vma address)); 357}; 358 359/* The linker builds link_order structures which tell the code how to 360 include input data in the output file. */ 361 362/* These are the types of link_order structures. */ 363 364enum bfd_link_order_type 365{ 366 bfd_undefined_link_order, /* Undefined. */ 367 bfd_indirect_link_order, /* Built from a section. */ 368 bfd_fill_link_order, /* Fill with a 16 bit constant. */ 369 bfd_data_link_order, /* Set to explicit data. */ 370 bfd_section_reloc_link_order, /* Relocate against a section. */ 371 bfd_symbol_reloc_link_order /* Relocate against a symbol. */ 372}; 373 374/* This is the link_order structure itself. These form a chain 375 attached to the section whose contents they are describing. */ 376 377struct bfd_link_order 378{ 379 /* Next link_order in chain. */ 380 struct bfd_link_order *next; 381 /* Type of link_order. */ 382 enum bfd_link_order_type type; 383 /* Offset within output section. */ 384 bfd_vma offset; 385 /* Size within output section. */ 386 bfd_size_type size; 387 /* Type specific information. */ 388 union 389 { 390 struct 391 { 392 /* Section to include. If this is used, then 393 section->output_section must be the section the 394 link_order is attached to, section->output_offset must 395 equal the link_order offset field, and section->_raw_size 396 must equal the link_order size field. Maybe these 397 restrictions should be relaxed someday. */ 398 asection *section; 399 } indirect; 400 struct 401 { 402 /* Value to fill with. */ 403 unsigned int value; 404 } fill; 405 struct 406 { 407 /* Data to put into file. The size field gives the number 408 of bytes which this field points to. */ 409 bfd_byte *contents; 410 } data; 411 struct 412 { 413 /* Description of reloc to generate. Used for 414 bfd_section_reloc_link_order and 415 bfd_symbol_reloc_link_order. */ 416 struct bfd_link_order_reloc *p; 417 } reloc; 418 } u; 419}; 420 421/* A linker order of type bfd_section_reloc_link_order or 422 bfd_symbol_reloc_link_order means to create a reloc against a 423 section or symbol, respectively. This is used to implement -Ur to 424 generate relocs for the constructor tables. The 425 bfd_link_order_reloc structure describes the reloc that BFD should 426 create. It is similar to a arelent, but I didn't use arelent 427 because the linker does not know anything about most symbols, and 428 any asymbol structure it creates will be partially meaningless. 429 This information could logically be in the bfd_link_order struct, 430 but I didn't want to waste the space since these types of relocs 431 are relatively rare. */ 432 433struct bfd_link_order_reloc 434{ 435 /* Reloc type. */ 436 bfd_reloc_code_real_type reloc; 437 438 union 439 { 440 /* For type bfd_section_reloc_link_order, this is the section 441 the reloc should be against. This must be a section in the 442 output BFD, not any of the input BFDs. */ 443 asection *section; 444 /* For type bfd_symbol_reloc_link_order, this is the name of the 445 symbol the reloc should be against. */ 446 const char *name; 447 } u; 448 449 /* Addend to use. The object file should contain zero. The BFD 450 backend is responsible for filling in the contents of the object 451 file correctly. For some object file formats (e.g., COFF) the 452 addend must be stored into in the object file, and for some 453 (e.g., SPARC a.out) it is kept in the reloc. */ 454 bfd_vma addend; 455}; 456 457/* Allocate a new link_order for a section. */ 458extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *)); 459 460#endif 461