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