include/bfdlink.h

   1 /* bfdlink.h -- header file for BFD link routines
   2    Copyright (C) 1993-2024 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #ifndef BFDLINK_H
  23 #define BFDLINK_H
  24
  25 /* Which symbols to strip during a link.  */
  26 enum bfd_link_strip
  27 {
  28   strip_none,           /* Don't strip any symbols.  */
  29   strip_debugger,       /* Strip debugging symbols.  */
  30   strip_some,           /* keep_hash is the list of symbols to keep.  */
  31   strip_all             /* Strip all symbols.  */
  32 };
  33
  34 /* Which local symbols to discard during a link.  This is irrelevant
  35    if strip_all is used.  */
  36 enum bfd_link_discard
  37 {
  38   discard_sec_merge,    /* Discard local temporary symbols in SEC_MERGE
  39                            sections.  */
  40   discard_none,         /* Don't discard any locals.  */
  41   discard_l,            /* Discard local temporary symbols.  */
  42   discard_all           /* Discard all locals.  */
  43 };
  44
  45 enum notice_asneeded_action {
  46   notice_as_needed,
  47   notice_not_needed,
  48   notice_needed
  49 };
  50
  51 /* Whether to generate ELF common symbols with the STT_COMMON type
  52    during a relocatable link.  */
  53 enum bfd_link_elf_stt_common
  54 {
  55   unchanged,
  56   elf_stt_common,
  57   no_elf_stt_common
  58 };
  59
  60 /* Describes the type of hash table entry structure being used.
  61    Different hash table structure have different fields and so
  62    support different linking features.  */
  63 enum bfd_link_hash_table_type
  64   {
  65     bfd_link_generic_hash_table,
  66     bfd_link_elf_hash_table
  67   };
  68 \f
  69 /* These are the possible types of an entry in the BFD link hash
  70    table.  */
  71
  72 enum bfd_link_hash_type
  73 {
  74   bfd_link_hash_new,            /* Symbol is new.  */
  75   bfd_link_hash_undefined,      /* Symbol seen before, but undefined.  */
  76   bfd_link_hash_undefweak,      /* Symbol is weak and undefined.  */
  77   bfd_link_hash_defined,        /* Symbol is defined.  */
  78   bfd_link_hash_defweak,        /* Symbol is weak and defined.  */
  79   bfd_link_hash_common,         /* Symbol is common.  */
  80   bfd_link_hash_indirect,       /* Symbol is an indirect link.  */
  81   bfd_link_hash_warning         /* Like indirect, but warn if referenced.  */
  82 };
  83
  84 enum bfd_link_common_skip_ar_symbols
  85 {
  86   bfd_link_common_skip_none,
  87   bfd_link_common_skip_text,
  88   bfd_link_common_skip_data,
  89   bfd_link_common_skip_all
  90 };
  91
  92 struct bfd_link_hash_common_entry
  93   {
  94     unsigned int alignment_power;       /* Alignment.  */
  95     asection *section;          /* Symbol section.  */
  96   };
  97
  98 /* The linking routines use a hash table which uses this structure for
  99    its elements.  */
 100
 101 struct bfd_link_hash_entry
 102 {
 103   /* Base hash table entry structure.  */
 104   struct bfd_hash_entry root;
 105
 106   /* Type of this entry.  */
 107   ENUM_BITFIELD (bfd_link_hash_type) type : 8;
 108
 109   /* Symbol is referenced in a normal regular object file,
 110      as distinct from a LTO IR object file.  */
 111   unsigned int non_ir_ref_regular : 1;
 112
 113   /* Symbol is referenced in a normal dynamic object file,
 114      as distinct from a LTO IR object file.  */
 115   unsigned int non_ir_ref_dynamic : 1;
 116
 117   /* The symbol, SYM, is referenced by __real_SYM in an object file.  */
 118   unsigned int ref_real : 1;
 119
 120   /* The symbol is a wrapper symbol, __wrap_SYM.  */
 121   unsigned int wrapper_symbol : 1;
 122
 123   /* Symbol is a built-in define.  These will be overridden by PROVIDE
 124      in a linker script.  */
 125   unsigned int linker_def : 1;
 126
 127   /* Symbol defined in a linker script.  */
 128   unsigned int ldscript_def : 1;
 129
 130   /* Symbol will be converted from absolute to section-relative.  Set for
 131      symbols defined by a script from "dot" (also SEGMENT_START or ORIGIN)
 132      outside of an output section statement.  */
 133   unsigned int rel_from_abs : 1;
 134
 135   /* A union of information depending upon the type.  */
 136   union
 137     {
 138       /* Nothing is kept for bfd_hash_new.  */
 139       /* bfd_link_hash_undefined, bfd_link_hash_undefweak.  */
 140       struct
 141         {
 142           /* Undefined and common symbols are kept in a linked list through
 143              this field.  This field is present in all of the union element
 144              so that we don't need to remove entries from the list when we
 145              change their type.  Removing entries would either require the
 146              list to be doubly linked, which would waste more memory, or
 147              require a traversal.  When an undefined or common symbol is
 148              created, it should be added to this list, the head of which is in
 149              the link hash table itself.  As symbols are defined, they need
 150              not be removed from the list; anything which reads the list must
 151              doublecheck the symbol type.
 152
 153              Weak symbols are not kept on this list.
 154
 155              Defined and defweak symbols use this field as a reference marker.
 156              If the field is not NULL, or this structure is the tail of the
 157              undefined symbol list, the symbol has been referenced.  If the
 158              symbol is undefined and becomes defined, this field will
 159              automatically be non-NULL since the symbol will have been on the
 160              undefined symbol list.  */
 161           struct bfd_link_hash_entry *next;
 162           /* BFD symbol was found in.  */
 163           bfd *abfd;
 164         } undef;
 165       /* bfd_link_hash_defined, bfd_link_hash_defweak.  */
 166       struct
 167         {
 168           struct bfd_link_hash_entry *next;
 169           /* Symbol section.  */
 170           asection *section;
 171           /* Symbol value.  */
 172           bfd_vma value;
 173         } def;
 174       /* bfd_link_hash_indirect, bfd_link_hash_warning.  */
 175       struct
 176         {
 177           struct bfd_link_hash_entry *next;
 178           /* Real symbol.  */
 179           struct bfd_link_hash_entry *link;
 180           /* Warning message (bfd_link_hash_warning only).  */
 181           const char *warning;
 182         } i;
 183       /* bfd_link_hash_common.  */
 184       struct
 185         {
 186           struct bfd_link_hash_entry *next;
 187           /* The linker needs to know three things about common
 188              symbols: the size, the alignment, and the section in
 189              which the symbol should be placed.  We store the size
 190              here, and we allocate a small structure to hold the
 191              section and the alignment.  The alignment is stored as a
 192              power of two.  We don't store all the information
 193              directly because we don't want to increase the size of
 194              the union; this structure is a major space user in the
 195              linker.  */
 196           struct bfd_link_hash_common_entry *p;
 197           /* Common symbol size.  */
 198           bfd_size_type size;
 199         } c;
 200     } u;
 201 };
 202
 203 /* This is the link hash table.  It is a derived class of
 204    bfd_hash_table.  */
 205
 206 struct bfd_link_hash_table
 207 {
 208   /* The hash table itself.  */
 209   struct bfd_hash_table table;
 210   /* A linked list of undefined and common symbols, linked through the
 211      next field in the bfd_link_hash_entry structure.  */
 212   struct bfd_link_hash_entry *undefs;
 213   /* Entries are added to the tail of the undefs list.  */
 214   struct bfd_link_hash_entry *undefs_tail;
 215   /* Function to free the hash table on closing BFD.  */
 216   void (*hash_table_free) (bfd *);
 217   /* The type of the link hash table.  */
 218   enum bfd_link_hash_table_type type;
 219 };
 220
 221 /* Look up an entry in a link hash table.  If FOLLOW is TRUE, this
 222    follows bfd_link_hash_indirect and bfd_link_hash_warning links to
 223    the real symbol.  */
 224 extern struct bfd_link_hash_entry *bfd_link_hash_lookup
 225   (struct bfd_link_hash_table *, const char *, bool create,
 226    bool copy, bool follow);
 227
 228 /* Look up an entry in the main linker hash table if the symbol might
 229    be wrapped.  This should only be used for references to an
 230    undefined symbol, not for definitions of a symbol.  */
 231
 232 extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup
 233   (bfd *, struct bfd_link_info *, const char *, bool, bool, bool);
 234
 235 /* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_"
 236    and the remainder is found in wrap_hash, return the real symbol.  */
 237
 238 extern struct bfd_link_hash_entry *unwrap_hash_lookup
 239   (struct bfd_link_info *, bfd *, struct bfd_link_hash_entry *);
 240
 241 /* Traverse a link hash table.  */
 242 extern void bfd_link_hash_traverse
 243   (struct bfd_link_hash_table *,
 244     bool (*) (struct bfd_link_hash_entry *, void *),
 245     void *);
 246
 247 /* Add an entry to the undefs list.  */
 248 extern void bfd_link_add_undef
 249   (struct bfd_link_hash_table *, struct bfd_link_hash_entry *);
 250
 251 /* Remove symbols from the undefs list that don't belong there.  */
 252 extern void bfd_link_repair_undef_list
 253   (struct bfd_link_hash_table *table);
 254
 255 /* Read symbols and cache symbol pointer array in outsymbols.  */
 256 extern bool bfd_generic_link_read_symbols (bfd *);
 257
 258 /* Check the relocs in the BFD.  Called after all the input
 259    files have been loaded, and garbage collection has tagged
 260    any unneeded sections.  */
 261 extern bool bfd_link_check_relocs (bfd *,struct bfd_link_info *);
 262
 263 struct bfd_sym_chain
 264 {
 265   struct bfd_sym_chain *next;
 266   const char *name;
 267 };
 268 \f
 269 /* How to handle unresolved symbols.
 270    There are four possibilities which are enumerated below:  */
 271 enum report_method
 272 {
 273   /* This is the initial value when then link_info structure is created.
 274      It allows the various stages of the linker to determine whether they
 275      allowed to set the value.  */
 276   RM_NOT_YET_SET = 0,
 277   RM_IGNORE,
 278   RM_DIAGNOSE,
 279 };
 280
 281 /* How to handle DT_TEXTREL.  */
 282
 283 enum textrel_check_method
 284 {
 285   textrel_check_none,
 286   textrel_check_warning,
 287   textrel_check_error
 288 };
 289
 290 #define bfd_link_textrel_check(info) \
 291   (info->textrel_check != textrel_check_none)
 292
 293 typedef enum {with_flags, without_flags} flag_type;
 294
 295 /* A section flag list.  */
 296 struct flag_info_list
 297 {
 298   flag_type with;
 299   const char *name;
 300   bool valid;
 301   struct flag_info_list *next;
 302 };
 303
 304 /* Section flag info.  */
 305 struct flag_info
 306 {
 307   flagword only_with_flags;
 308   flagword not_with_flags;
 309   struct flag_info_list *flag_list;
 310   bool flags_initialized;
 311 };
 312
 313 struct bfd_elf_dynamic_list;
 314 struct bfd_elf_version_tree;
 315
 316 /* Types of output.  */
 317
 318 enum output_type
 319 {
 320   type_pde,
 321   type_pie,
 322   type_relocatable,
 323   type_dll,
 324 };
 325
 326 #define bfd_link_pde(info)         ((info)->type == type_pde)
 327 #define bfd_link_dll(info)         ((info)->type == type_dll)
 328 #define bfd_link_relocatable(info) ((info)->type == type_relocatable)
 329 #define bfd_link_pie(info)         ((info)->type == type_pie)
 330 #define bfd_link_executable(info)  (bfd_link_pde (info) || bfd_link_pie (info))
 331 #define bfd_link_pic(info)         (bfd_link_dll (info) || bfd_link_pie (info))
 332
 333 /* This structure holds all the information needed to communicate
 334    between BFD and the linker when doing a link.  */
 335
 336 struct bfd_link_info
 337 {
 338   /* Output type.  */
 339   ENUM_BITFIELD (output_type) type : 2;
 340
 341   /* TRUE if BFD should pre-bind symbols in a shared object.  */
 342   unsigned int symbolic: 1;
 343
 344   /* TRUE if BFD should export all symbols in the dynamic symbol table
 345      of an executable, rather than only those used.  */
 346   unsigned int export_dynamic: 1;
 347
 348   /* TRUE if a default symbol version should be created and used for
 349      exported symbols.  */
 350   unsigned int create_default_symver: 1;
 351
 352   /* TRUE if unreferenced sections should be removed.  */
 353   unsigned int gc_sections: 1;
 354
 355   /* TRUE if exported symbols should be kept during section gc.  */
 356   unsigned int gc_keep_exported: 1;
 357
 358   /* TRUE if every symbol should be reported back via the notice
 359      callback.  */
 360   unsigned int notice_all: 1;
 361
 362   /* TRUE if the LTO plugin is active.  */
 363   unsigned int lto_plugin_active: 1;
 364
 365   /* TRUE if all LTO IR symbols have been read.  */
 366   unsigned int lto_all_symbols_read : 1;
 367
 368   /* TRUE if global symbols in discarded sections should be stripped.  */
 369   unsigned int strip_discarded: 1;
 370
 371   /* TRUE if all data symbols should be dynamic.  */
 372   unsigned int dynamic_data: 1;
 373
 374   /* TRUE if section groups should be resolved.  */
 375   unsigned int resolve_section_groups: 1;
 376
 377   /* Set if output file is big-endian, or if that is unknown, from
 378      the command line or first input file endianness.  */
 379   unsigned int big_endian : 1;
 380
 381   /* Which symbols to strip.  */
 382   ENUM_BITFIELD (bfd_link_strip) strip : 2;
 383
 384   /* Which local symbols to discard.  */
 385   ENUM_BITFIELD (bfd_link_discard) discard : 2;
 386
 387   /* Whether to generate ELF common symbols with the STT_COMMON type.  */
 388   ENUM_BITFIELD (bfd_link_elf_stt_common) elf_stt_common : 2;
 389
 390   /* Criteria for skipping symbols when determining
 391      whether to include an object from an archive.  */
 392   ENUM_BITFIELD (bfd_link_common_skip_ar_symbols) common_skip_ar_symbols : 2;
 393
 394   /* What to do with unresolved symbols in an object file.
 395      When producing executables the default is GENERATE_ERROR.
 396      When producing shared libraries the default is IGNORE.  The
 397      assumption with shared libraries is that the reference will be
 398      resolved at load/execution time.  */
 399   ENUM_BITFIELD (report_method) unresolved_syms_in_objects : 2;
 400
 401   /* What to do with unresolved symbols in a shared library.
 402      The same defaults apply.  */
 403   ENUM_BITFIELD (report_method) unresolved_syms_in_shared_libs : 2;
 404
 405   /* TRUE if unresolved symbols are to be warned, rather than errored.  */
 406   unsigned int warn_unresolved_syms: 1;
 407
 408   /* TRUE if shared objects should be linked directly, not shared.  */
 409   unsigned int static_link: 1;
 410
 411   /* TRUE if symbols should be retained in memory, FALSE if they
 412      should be freed and reread.  */
 413   unsigned int keep_memory: 1;
 414
 415   /* TRUE if BFD should generate relocation information in the final
 416      executable.  */
 417   unsigned int emitrelocations: 1;
 418
 419   /* TRUE if PT_GNU_RELRO segment should be created.  */
 420   unsigned int relro: 1;
 421
 422   /* TRUE if DT_RELR should be enabled for compact relative
 423      relocations.  */
 424   unsigned int enable_dt_relr: 1;
 425
 426   /* TRUE if separate code segment should be created.  */
 427   unsigned int separate_code: 1;
 428
 429   /* TRUE if only one read-only, non-code segment should be created.  */
 430   unsigned int one_rosegment: 1;
 431
 432   /* Nonzero if .eh_frame_hdr section and PT_GNU_EH_FRAME ELF segment
 433      should be created.  1 for DWARF2 tables, 2 for compact tables.  */
 434   unsigned int eh_frame_hdr_type: 2;
 435
 436   /* What to do with DT_TEXTREL in output.  */
 437   ENUM_BITFIELD (textrel_check_method) textrel_check: 2;
 438
 439   /* TRUE if .hash section should be created.  */
 440   unsigned int emit_hash: 1;
 441
 442   /* TRUE if .gnu.hash section should be created.  */
 443   unsigned int emit_gnu_hash: 1;
 444
 445   /* If TRUE reduce memory overheads, at the expense of speed. This will
 446      cause map file generation to use an O(N^2) algorithm and disable
 447      caching ELF symbol buffer.  */
 448   unsigned int reduce_memory_overheads: 1;
 449
 450   /* TRUE if the output file should be in a traditional format.  This
 451      is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag
 452      on the output file, but may be checked when reading the input
 453      files.  */
 454   unsigned int traditional_format: 1;
 455
 456   /* TRUE if non-PLT relocs should be merged into one reloc section
 457      and sorted so that relocs against the same symbol come together.  */
 458   unsigned int combreloc: 1;
 459
 460   /* TRUE if a default symbol version should be created and used for
 461      imported symbols.  */
 462   unsigned int default_imported_symver: 1;
 463
 464   /* TRUE if the new ELF dynamic tags are enabled. */
 465   unsigned int new_dtags: 1;
 466
 467   /* FALSE if .eh_frame unwind info should be generated for PLT and other
 468      linker created sections, TRUE if it should be omitted.  */
 469   unsigned int no_ld_generated_unwind_info: 1;
 470
 471   /* TRUE if BFD should generate a "task linked" object file,
 472      similar to relocatable but also with globals converted to
 473      statics.  */
 474   unsigned int task_link: 1;
 475
 476   /* TRUE if ok to have multiple definitions, without warning.  */
 477   unsigned int allow_multiple_definition: 1;
 478
 479   /* TRUE if multiple definition of absolute symbols (eg. from -R) should
 480      be reported.  */
 481   unsigned int prohibit_multiple_definition_absolute: 1;
 482
 483   /* TRUE if multiple definitions should only warn.  */
 484   unsigned int warn_multiple_definition: 1;
 485
 486   /* TRUE if ok to have version with no definition.  */
 487   unsigned int allow_undefined_version: 1;
 488
 489   /* TRUE if some symbols have to be dynamic, controlled by
 490      --dynamic-list command line options.  */
 491   unsigned int dynamic: 1;
 492
 493   /* Set if the "-z execstack" option has been used to request that a
 494      PT_GNU_STACK segment should be created with PF_R, PF_W and PF_X
 495      flags set.
 496
 497      Note - if performing a relocatable link then a .note.GNU-stack
 498      section will be created instead, if one does not exist already.
 499      The section will have the SHF_EXECINSTR flag bit set.  */
 500   unsigned int execstack: 1;
 501
 502   /* Set if the "-z noexecstack" option has been used to request that a
 503      PT_GNU_STACK segment should be created with PF_R and PF_W flags.  Or
 504      a non-executable .note.GNU-stack section for relocateable links.
 505
 506      Note - this flag is not quite orthogonal to execstack, since both
 507      of these flags can be 0.  In this case a stack segment can still
 508      be created, but it will only have the PF_X flag bit set if one or
 509      more of the input files contains a .note.GNU-stack section with the
 510      SHF_EXECINSTR flag bit set, or if the default behaviour for the
 511      architecture is to create executable stacks.
 512
 513      The execstack and noexecstack flags should never both be 1.  */
 514   unsigned int noexecstack: 1;
 515
 516   /* Tri-state variable:
 517      0 => do not warn when creating an executable stack.
 518      1 => always warn when creating an executable stack (for any reason).
 519      2 => only warn when an executable stack has been requested an object
 520           file and execstack is 0 or noexecstack is 1.
 521      3 => not used.  */
 522   unsigned int warn_execstack: 2;
 523   /* TRUE if a warning generated because of warn_execstack should be instead
 524      be treated as an error.  */
 525   unsigned int error_execstack: 1;
 526
 527   /* TRUE if warnings should NOT be generated for TLS segments with eXecute
 528      permission or LOAD segments with RWX permissions.  */
 529   unsigned int no_warn_rwx_segments: 1;
 530   /* TRUE if the user gave either --warn-rwx-segments or
 531      --no-warn-rwx-segments on the linker command line.  */
 532   unsigned int user_warn_rwx_segments: 1;
 533   /* TRUE if warnings generated when no_warn_rwx_segements is 0 should
 534      instead be treated as errors.  */
 535   unsigned int warn_is_error_for_rwx_segments: 1;
 536
 537   /* TRUE if the stack can be made executable because of the absence of a
 538      .note.GNU-stack section in an input file.  Note - even if this field
 539      is set, some targets may choose to ignore the setting and not create
 540      an executable stack.  */
 541   unsigned int default_execstack : 1;
 542
 543   /* TRUE if we want to produced optimized output files.  This might
 544      need much more time and therefore must be explicitly selected.  */
 545   unsigned int optimize: 1;
 546
 547   /* TRUE if user should be informed of removed unreferenced sections.  */
 548   unsigned int print_gc_sections: 1;
 549
 550   /* TRUE if we should warn alternate ELF machine code.  */
 551   unsigned int warn_alternate_em: 1;
 552
 553   /* TRUE if the linker script contained an explicit PHDRS command.  */
 554   unsigned int user_phdrs: 1;
 555
 556   /* TRUE if program headers ought to be loaded.  */
 557   unsigned int load_phdrs: 1;
 558
 559   /* TRUE if we should check relocations after all input files have
 560      been opened.  */
 561   unsigned int check_relocs_after_open_input: 1;
 562
 563   /* TRUE if generation of .interp/PT_INTERP should be suppressed.  */
 564   unsigned int nointerp: 1;
 565
 566   /* TRUE if common symbols should be treated as undefined.  */
 567   unsigned int inhibit_common_definition : 1;
 568
 569   /* TRUE if "-Map map" is passed to linker.  */
 570   unsigned int has_map_file : 1;
 571
 572   /* TRUE if "--enable-non-contiguous-regions" is passed to the
 573      linker.  */
 574   unsigned int non_contiguous_regions : 1;
 575
 576   /* TRUE if "--enable-non-contiguous-regions-warnings" is passed to
 577      the linker.  */
 578   unsigned int non_contiguous_regions_warnings : 1;
 579
 580   /* TRUE if all symbol names should be unique.  */
 581   unsigned int unique_symbol : 1;
 582
 583   /* TRUE if maxpagesize is set on command-line.  */
 584   unsigned int maxpagesize_is_set : 1;
 585
 586   /* TRUE if commonpagesize is set on command-line.  */
 587   unsigned int commonpagesize_is_set : 1;
 588
 589   /* Char that may appear as the first char of a symbol, but should be
 590      skipped (like symbol_leading_char) when looking up symbols in
 591      wrap_hash.  Used by PowerPC Linux for 'dot' symbols.  */
 592   char wrap_char;
 593
 594   /* Separator between archive and filename in linker script filespecs.  */
 595   char path_separator;
 596
 597   /* Default stack size.  Zero means default (often zero itself), -1
 598      means explicitly zero-sized.  */
 599   bfd_signed_vma stacksize;
 600
 601   /* Enable or disable target specific optimizations.
 602
 603      Not all targets have optimizations to enable.
 604
 605      Normally these optimizations are disabled by default but some targets
 606      prefer to enable them by default.  So this field is a tri-state variable.
 607      The values are:
 608
 609      zero: Enable the optimizations (either from --relax being specified on
 610        the command line or the backend's before_allocation emulation function.
 611
 612      positive: The user has requested that these optimizations be disabled.
 613        (Via the --no-relax command line option).
 614
 615      negative: The optimizations are disabled.  (Set when initializing the
 616        args_type structure in ldmain.c:main.  */
 617   signed int disable_target_specific_optimizations;
 618
 619   /* Function callbacks.  */
 620   const struct bfd_link_callbacks *callbacks;
 621
 622   /* Hash table handled by BFD.  */
 623   struct bfd_link_hash_table *hash;
 624
 625   /* Hash table of symbols to keep.  This is NULL unless strip is
 626      strip_some.  */
 627   struct bfd_hash_table *keep_hash;
 628
 629   /* Hash table of symbols to report back via the notice callback.  If
 630      this is NULL, and notice_all is FALSE, then no symbols are
 631      reported back.  */
 632   struct bfd_hash_table *notice_hash;
 633
 634   /* Hash table of symbols which are being wrapped (the --wrap linker
 635      option).  If this is NULL, no symbols are being wrapped.  */
 636   struct bfd_hash_table *wrap_hash;
 637
 638   /* Hash table of symbols which may be left unresolved during
 639      a link.  If this is NULL, no symbols can be left unresolved.  */
 640   struct bfd_hash_table *ignore_hash;
 641
 642   /* The output BFD.  */
 643   bfd *output_bfd;
 644
 645   /* The import library generated.  */
 646   bfd *out_implib_bfd;
 647
 648   /* The list of input BFD's involved in the link.  These are chained
 649      together via the link.next field.  */
 650   bfd *input_bfds;
 651   bfd **input_bfds_tail;
 652
 653   /* If a symbol should be created for each input BFD, this is section
 654      where those symbols should be placed.  It must be a section in
 655      the output BFD.  It may be NULL, in which case no such symbols
 656      will be created.  This is to support CREATE_OBJECT_SYMBOLS in the
 657      linker command language.  */
 658   asection *create_object_symbols_section;
 659
 660   /* List of global symbol names that are starting points for marking
 661      sections against garbage collection.  */
 662   struct bfd_sym_chain *gc_sym_list;
 663
 664   /* If a base output file is wanted, then this points to it */
 665   void *base_file;
 666
 667   /* The function to call when the executable or shared object is
 668      loaded.  */
 669   const char *init_function;
 670
 671   /* The function to call when the executable or shared object is
 672      unloaded.  */
 673   const char *fini_function;
 674
 675   /* Number of relaxation passes.  Usually only one relaxation pass
 676      is needed.  But a backend can have as many relaxation passes as
 677      necessary.  During bfd_relax_section call, it is set to the
 678      current pass, starting from 0.  */
 679   int relax_pass;
 680
 681   /* Number of relaxation trips.  This number is incremented every
 682      time the relaxation pass is restarted due to a previous
 683      relaxation returning true in *AGAIN.  */
 684   int relax_trip;
 685
 686   /* > 0 to treat protected data defined in the shared library as
 687      reference external.  0 to treat it as internal.  -1 to let
 688      backend to decide.  */
 689   int extern_protected_data;
 690
 691   /* 1 to make undefined weak symbols dynamic when building a dynamic
 692      object.  0 to resolve undefined weak symbols to zero.  -1 to let
 693      the backend decide.  */
 694   int dynamic_undefined_weak;
 695
 696   /* Non-zero if auto-import thunks for DATA items in pei386 DLLs
 697      should be generated/linked against.  Set to 1 if this feature
 698      is explicitly requested by the user, -1 if enabled by default.  */
 699   int pei386_auto_import;
 700
 701   /* Non-zero if runtime relocs for DATA items with non-zero addends
 702      in pei386 DLLs should be generated.  Set to 1 if this feature
 703      is explicitly requested by the user, -1 if enabled by default.  */
 704   int pei386_runtime_pseudo_reloc;
 705
 706   /* How many spare .dynamic DT_NULL entries should be added?  */
 707   unsigned int spare_dynamic_tags;
 708
 709   /* GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS control:
 710        > 1: Turn on by -z indirect-extern-access or by backend.
 711       == 1: Turn on by an input.
 712          0: Turn off.
 713        < 0: Turn on if it is set on any inputs or let backend to
 714             decide.  */
 715   int indirect_extern_access;
 716
 717   /* Non-zero if executable should not contain copy relocs.
 718        > 1: Implied by indirect_extern_access.
 719       == 1: Turn on by -z nocopyreloc.
 720          0: Turn off.
 721     Setting this to non-zero may result in a non-sharable text
 722     segment.  */
 723   int nocopyreloc;
 724
 725   /* Pointer to the GNU_PROPERTY_1_NEEDED property in memory.  */
 726   bfd_byte *needed_1_p;
 727
 728   /* May be used to set DT_FLAGS for ELF. */
 729   bfd_vma flags;
 730
 731   /* May be used to set DT_FLAGS_1 for ELF. */
 732   bfd_vma flags_1;
 733
 734   /* May be used to set DT_GNU_FLAGS_1 for ELF. */
 735   bfd_vma gnu_flags_1;
 736
 737   /* TRUE if references to __start_/__stop_ synthesized symbols do not
 738      specially retain C identifier named sections.  */
 739   int start_stop_gc;
 740
 741   /* May be used to set ELF visibility for __start_* / __stop_.  */
 742   unsigned int start_stop_visibility;
 743
 744   /* The maximum page size for ELF.  */
 745   bfd_vma maxpagesize;
 746
 747   /* The common page size for ELF.  */
 748   bfd_vma commonpagesize;
 749
 750   /* Start and end of RELRO region.  */
 751   bfd_vma relro_start, relro_end;
 752
 753   /* List of symbols should be dynamic.  */
 754   struct bfd_elf_dynamic_list *dynamic_list;
 755
 756   /* The version information.  */
 757   struct bfd_elf_version_tree *version_info;
 758
 759   /* Size of cache.  Backend can use it to keep strace cache size.   */
 760   bfd_size_type cache_size;
 761
 762   /* The maximum cache size.  Backend can use cache_size and and
 763      max_cache_size to decide if keep_memory should be honored.  */
 764   bfd_size_type max_cache_size;
 765 };
 766
 767 /* Some forward-definitions used by some callbacks.  */
 768
 769 struct elf_strtab_hash;
 770 struct elf_internal_sym;
 771
 772 /* This structures holds a set of callback functions.  These are called
 773    by the BFD linker routines.  */
 774
 775 struct bfd_link_callbacks
 776 {
 777   /* A function which is called when an object is added from an
 778      archive.  ABFD is the archive element being added.  NAME is the
 779      name of the symbol which caused the archive element to be pulled
 780      in.  This function may set *SUBSBFD to point to an alternative
 781      BFD from which symbols should in fact be added in place of the
 782      original BFD's symbols.  Returns TRUE if the object should be
 783      added, FALSE if it should be skipped.  */
 784   bool (*add_archive_element)
 785     (struct bfd_link_info *, bfd *abfd, const char *name, bfd **subsbfd);
 786   /* A function which is called when a symbol is found with multiple
 787      definitions.  H is the symbol which is defined multiple times.
 788      NBFD is the new BFD, NSEC is the new section, and NVAL is the new
 789      value.  NSEC may be bfd_com_section or bfd_ind_section.  */
 790   void (*multiple_definition)
 791     (struct bfd_link_info *, struct bfd_link_hash_entry *h,
 792      bfd *nbfd, asection *nsec, bfd_vma nval);
 793   /* A function which is called when a common symbol is defined
 794      multiple times.  H is the symbol appearing multiple times.
 795      NBFD is the BFD of the new symbol.  NTYPE is the type of the new
 796      symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or
 797      bfd_link_hash_indirect.  If NTYPE is bfd_link_hash_common, NSIZE
 798      is the size of the new symbol.  */
 799   void (*multiple_common)
 800     (struct bfd_link_info *, struct bfd_link_hash_entry *h,
 801      bfd *nbfd, enum bfd_link_hash_type ntype, bfd_vma nsize);
 802   /* A function which is called to add a symbol to a set.  ENTRY is
 803      the link hash table entry for the set itself (e.g.,
 804      __CTOR_LIST__).  RELOC is the relocation to use for an entry in
 805      the set when generating a relocatable file, and is also used to
 806      get the size of the entry when generating an executable file.
 807      ABFD, SEC and VALUE identify the value to add to the set.  */
 808   void (*add_to_set)
 809     (struct bfd_link_info *, struct bfd_link_hash_entry *entry,
 810      bfd_reloc_code_real_type reloc, bfd *abfd, asection *sec, bfd_vma value);
 811   /* A function which is called when the name of a g++ constructor or
 812      destructor is found.  This is only called by some object file
 813      formats.  CONSTRUCTOR is TRUE for a constructor, FALSE for a
 814      destructor.  This will use BFD_RELOC_CTOR when generating a
 815      relocatable file.  NAME is the name of the symbol found.  ABFD,
 816      SECTION and VALUE are the value of the symbol.  */
 817   void (*constructor)
 818     (struct bfd_link_info *, bool constructor, const char *name,
 819      bfd *abfd, asection *sec, bfd_vma value);
 820   /* A function which is called to issue a linker warning.  For
 821      example, this is called when there is a reference to a warning
 822      symbol.  WARNING is the warning to be issued.  SYMBOL is the name
 823      of the symbol which triggered the warning; it may be NULL if
 824      there is none.  ABFD, SECTION and ADDRESS identify the location
 825      which trigerred the warning; either ABFD or SECTION or both may
 826      be NULL if the location is not known.  */
 827   void (*warning)
 828     (struct bfd_link_info *, const char *warning, const char *symbol,
 829      bfd *abfd, asection *section, bfd_vma address);
 830   /* A function which is called when a relocation is attempted against
 831      an undefined symbol.  NAME is the symbol which is undefined.
 832      ABFD, SECTION and ADDRESS identify the location from which the
 833      reference is made. IS_FATAL indicates whether an undefined symbol is
 834      a fatal error or not. In some cases SECTION may be NULL.  */
 835   void (*undefined_symbol)
 836     (struct bfd_link_info *, const char *name, bfd *abfd,
 837      asection *section, bfd_vma address, bool is_fatal);
 838   /* A function which is called when a reloc overflow occurs. ENTRY is
 839      the link hash table entry for the symbol the reloc is against.
 840      NAME is the name of the local symbol or section the reloc is
 841      against, RELOC_NAME is the name of the relocation, and ADDEND is
 842      any addend that is used.  ABFD, SECTION and ADDRESS identify the
 843      location at which the overflow occurs; if this is the result of a
 844      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
 845      ABFD will be NULL.  */
 846   void (*reloc_overflow)
 847     (struct bfd_link_info *, struct bfd_link_hash_entry *entry,
 848      const char *name, const char *reloc_name, bfd_vma addend,
 849      bfd *abfd, asection *section, bfd_vma address);
 850   /* A function which is called when a dangerous reloc is performed.
 851      MESSAGE is an appropriate message.
 852      ABFD, SECTION and ADDRESS identify the location at which the
 853      problem occurred; if this is the result of a
 854      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
 855      ABFD will be NULL.  */
 856   void (*reloc_dangerous)
 857     (struct bfd_link_info *, const char *message,
 858      bfd *abfd, asection *section, bfd_vma address);
 859   /* A function which is called when a reloc is found to be attached
 860      to a symbol which is not being written out.  NAME is the name of
 861      the symbol.  ABFD, SECTION and ADDRESS identify the location of
 862      the reloc; if this is the result of a
 863      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
 864      ABFD will be NULL.  */
 865   void (*unattached_reloc)
 866     (struct bfd_link_info *, const char *name,
 867      bfd *abfd, asection *section, bfd_vma address);
 868   /* A function which is called when a symbol in notice_hash is
 869      defined or referenced.  H is the symbol, INH the indirect symbol
 870      if applicable.  ABFD, SECTION and ADDRESS are the (new) value of
 871      the symbol.  If SECTION is bfd_und_section, this is a reference.
 872      FLAGS are the symbol BSF_* flags.  */
 873   bool (*notice)
 874     (struct bfd_link_info *, struct bfd_link_hash_entry *h,
 875      struct bfd_link_hash_entry *inh,
 876      bfd *abfd, asection *section, bfd_vma address, flagword flags);
 877   /* Error or warning link info message.  */
 878   void (*einfo)
 879     (const char *fmt, ...);
 880   /* General link info message.  */
 881   void (*info)
 882     (const char *fmt, ...);
 883   /* Message to be printed in linker map file.  */
 884   void (*minfo)
 885     (const char *fmt, ...);
 886   /* This callback provides a chance for users of the BFD library to
 887      override its decision about whether to place two adjacent sections
 888      into the same segment.  */
 889   bool (*override_segment_assignment)
 890     (struct bfd_link_info *, bfd * abfd,
 891      asection * current_section, asection * previous_section,
 892      bool new_segment);
 893   /* This callback provides a chance for callers of the BFD to examine the
 894      ELF (dynamic) string table once it is complete.  */
 895   void (*examine_strtab)
 896     (struct elf_strtab_hash *symstrtab);
 897   /* This callback is called just before a symbol is swapped out, so that the
 898      CTF machinery can look up symbols during construction.  The name is
 899      already an external strtab offset at this point.  */
 900   void (*ctf_new_symbol)
 901     (int symidx, struct elf_internal_sym *sym);
 902   /* Likewise, for dynamic symbols.  */
 903   void (*ctf_new_dynsym)
 904     (int symidx, struct elf_internal_sym *sym);
 905   /* This callback should emit the CTF section into a non-loadable section in
 906      the output BFD named .ctf or a name beginning with ".ctf.".  */
 907   void (*emit_ctf)
 908     (void);
 909 };
 910 \f
 911 /* The linker builds link_order structures which tell the code how to
 912    include input data in the output file.  */
 913
 914 /* These are the types of link_order structures.  */
 915
 916 enum bfd_link_order_type
 917 {
 918   bfd_undefined_link_order,     /* Undefined.  */
 919   bfd_indirect_link_order,      /* Built from a section.  */
 920   bfd_data_link_order,          /* Set to explicit data.  */
 921   bfd_section_reloc_link_order, /* Relocate against a section.  */
 922   bfd_symbol_reloc_link_order   /* Relocate against a symbol.  */
 923 };
 924
 925 /* This is the link_order structure itself.  These form a chain
 926    attached to the output section whose contents they are describing.  */
 927
 928 struct bfd_link_order
 929 {
 930   /* Next link_order in chain.  */
 931   struct bfd_link_order *next;
 932   /* Type of link_order.  */
 933   enum bfd_link_order_type type;
 934   /* Offset within output section in bytes.  */
 935   bfd_vma offset;
 936   /* Size within output section in octets.  */
 937   bfd_size_type size;
 938   /* Type specific information.  */
 939   union
 940     {
 941       struct
 942         {
 943           /* Section to include.  If this is used, then
 944              section->output_section must be the section the
 945              link_order is attached to, section->output_offset must
 946              equal the link_order offset field, and section->size
 947              must equal the link_order size field.  Maybe these
 948              restrictions should be relaxed someday.  */
 949           asection *section;
 950         } indirect;
 951       struct
 952         {
 953           /* Size of contents, or zero when contents should be filled by
 954              the architecture-dependent fill function.
 955              A non-zero value allows filling of the output section
 956              with an arbitrary repeated pattern.  */
 957           unsigned int size;
 958           /* Data to put into file.  */
 959           bfd_byte *contents;
 960         } data;
 961       struct
 962         {
 963           /* Description of reloc to generate.  Used for
 964              bfd_section_reloc_link_order and
 965              bfd_symbol_reloc_link_order.  */
 966           struct bfd_link_order_reloc *p;
 967         } reloc;
 968     } u;
 969 };
 970
 971 /* A linker order of type bfd_section_reloc_link_order or
 972    bfd_symbol_reloc_link_order means to create a reloc against a
 973    section or symbol, respectively.  This is used to implement -Ur to
 974    generate relocs for the constructor tables.  The
 975    bfd_link_order_reloc structure describes the reloc that BFD should
 976    create.  It is similar to a arelent, but I didn't use arelent
 977    because the linker does not know anything about most symbols, and
 978    any asymbol structure it creates will be partially meaningless.
 979    This information could logically be in the bfd_link_order struct,
 980    but I didn't want to waste the space since these types of relocs
 981    are relatively rare.  */
 982
 983 struct bfd_link_order_reloc
 984 {
 985   /* Reloc type.  */
 986   bfd_reloc_code_real_type reloc;
 987
 988   union
 989     {
 990       /* For type bfd_section_reloc_link_order, this is the section
 991          the reloc should be against.  This must be a section in the
 992          output BFD, not any of the input BFDs.  */
 993       asection *section;
 994       /* For type bfd_symbol_reloc_link_order, this is the name of the
 995          symbol the reloc should be against.  */
 996       const char *name;
 997     } u;
 998
 999   /* Addend to use.  The object file should contain zero.  The BFD
1000      backend is responsible for filling in the contents of the object
1001      file correctly.  For some object file formats (e.g., COFF) the
1002      addend must be stored into in the object file, and for some
1003      (e.g., SPARC a.out) it is kept in the reloc.  */
1004   bfd_vma addend;
1005 };
1006
1007 /* Allocate a new link_order for a section.  */
1008 extern struct bfd_link_order *bfd_new_link_order (bfd *, asection *);
1009
1010 struct bfd_section_already_linked;
1011
1012 extern bool bfd_section_already_linked_table_init (void);
1013 extern void bfd_section_already_linked_table_free (void);
1014 extern bool _bfd_handle_already_linked
1015   (struct bfd_section *, struct bfd_section_already_linked *,
1016    struct bfd_link_info *);
1017
1018 extern struct bfd_section *_bfd_nearby_section
1019   (bfd *, struct bfd_section *, bfd_vma);
1020
1021 extern void _bfd_fix_excluded_sec_syms
1022   (bfd *, struct bfd_link_info *);
1023
1024 /* These structures are used to describe version information for the
1025    ELF linker.  These structures could be manipulated entirely inside
1026    BFD, but it would be a pain.  Instead, the regular linker sets up
1027    these structures, and then passes them into BFD.  */
1028
1029 /* Glob pattern for a version.  */
1030
1031 struct bfd_elf_version_expr
1032 {
1033   /* Next glob pattern for this version.  */
1034   struct bfd_elf_version_expr *next;
1035   /* Glob pattern.  */
1036   const char *pattern;
1037   /* Set if pattern is not a glob.  */
1038   unsigned int literal : 1;
1039   /* Defined by ".symver".  */
1040   unsigned int symver : 1;
1041   /* Defined by version script.  */
1042   unsigned int script : 1;
1043   /* Pattern type.  */
1044 #define BFD_ELF_VERSION_C_TYPE          1
1045 #define BFD_ELF_VERSION_CXX_TYPE        2
1046 #define BFD_ELF_VERSION_JAVA_TYPE       4
1047   unsigned int mask : 3;
1048 };
1049
1050 struct bfd_elf_version_expr_head
1051 {
1052   /* List of all patterns, both wildcards and non-wildcards.  */
1053   struct bfd_elf_version_expr *list;
1054   /* Hash table for non-wildcards.  */
1055   void *htab;
1056   /* Remaining patterns.  */
1057   struct bfd_elf_version_expr *remaining;
1058   /* What kind of pattern types are present in list (bitmask).  */
1059   unsigned int mask;
1060 };
1061
1062 /* Version dependencies.  */
1063
1064 struct bfd_elf_version_deps
1065 {
1066   /* Next dependency for this version.  */
1067   struct bfd_elf_version_deps *next;
1068   /* The version which this version depends upon.  */
1069   struct bfd_elf_version_tree *version_needed;
1070 };
1071
1072 /* A node in the version tree.  */
1073
1074 struct bfd_elf_version_tree
1075 {
1076   /* Next version.  */
1077   struct bfd_elf_version_tree *next;
1078   /* Name of this version.  */
1079   const char *name;
1080   /* Version number.  */
1081   unsigned int vernum;
1082   /* Regular expressions for global symbols in this version.  */
1083   struct bfd_elf_version_expr_head globals;
1084   /* Regular expressions for local symbols in this version.  */
1085   struct bfd_elf_version_expr_head locals;
1086   /* List of versions which this version depends upon.  */
1087   struct bfd_elf_version_deps *deps;
1088   /* Index of the version name.  This is used within BFD.  */
1089   unsigned int name_indx;
1090   /* Whether this version tree was used.  This is used within BFD.  */
1091   int used;
1092   /* Matching hook.  */
1093   struct bfd_elf_version_expr *(*match)
1094     (struct bfd_elf_version_expr_head *head,
1095      struct bfd_elf_version_expr *prev, const char *sym);
1096 };
1097
1098 struct bfd_elf_dynamic_list
1099 {
1100   struct bfd_elf_version_expr_head head;
1101   struct bfd_elf_version_expr *(*match)
1102     (struct bfd_elf_version_expr_head *head,
1103      struct bfd_elf_version_expr *prev, const char *sym);
1104 };
1105
1106 #endif