src/ld.h

   1 /* Copyright (C) 2001, 2002, 2003, 2005, 2006, 2008, 2009 Red Hat, Inc.
   2    This file is part of elfutils.
   3    Written by Ulrich Drepper <drepper@redhat.com>, 2001.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    elfutils is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #ifndef LD_H
  19 #define LD_H    1
  20
  21 #include <dlfcn.h>
  22 #include <obstack.h>
  23 #include <stdbool.h>
  24 #include <stdio.h>
  25 #include "xelf.h"
  26
  27
  28 /* Recommended size of the buffer passed to ld_strerror.  */
  29 #define ERRBUFSIZE      (512)
  30
  31 /* Character used to introduce version name after symbol.  */
  32 #define VER_CHR '@'
  33
  34
  35 /* Methods for handling archives.  */
  36 enum extract_rule
  37   {
  38     defaultextract,     /* Weak references don't cause archive member to
  39                            be used.  */
  40     weakextract,        /* Weak references cause archive member to be
  41                            extracted.  */
  42     allextract          /* Extract all archive members regardless of
  43                            references (aka whole-archive).  */
  44   };
  45
  46
  47 /* Type of output file.  */
  48 enum file_type
  49   {
  50     no_file_type = 0,           /* None selected so far.  */
  51     executable_file_type,       /* Executable.  */
  52     dso_file_type,              /* DSO.  */
  53     dso_needed_file_type,       /* DSO introduced by DT_NEEDED.  */
  54     relocatable_file_type,      /* Relocatable object file.  */
  55     archive_file_type           /* Archive (input only).  */
  56   };
  57
  58
  59 struct usedfiles
  60 {
  61   /* The next file given at the command line.  */
  62   struct usedfiles *next;
  63   /* Nonzero if this file is the beginning of a group.  */
  64   bool group_start;
  65   /* Nonzero if this file is the end of a group.  */
  66   bool group_end;
  67   /* Pointer to the beginning of the group.  It is necessary to
  68      explain why we cannot simply use the 'next' pointer and have a
  69      circular single-linked list like in many cases.  The problem is
  70      that the last archive of the group, if it is the last file of the
  71      group, contains the only existing pointer to the next file we
  72      have to look at.  All files are initially connected via the
  73      'next' pointer in a single-linked list.  Therefore we cannot
  74      overwrite this value.  It instead will be used once the group is
  75      handled and we go on processing the rest of the files.  */
  76   struct usedfiles *group_backref;
  77
  78   /* Name/path of the file.  */
  79   const char *fname;
  80   /* Resolved file name.  */
  81   const char *rfname;
  82   /* Name used as reference in DT_NEEDED entries.  This is normally
  83      the SONAME.  If it is missing it's normally the fname above.  */
  84   const char *soname;
  85   /* Handle for the SONAME in the string table.  */
  86   struct Ebl_Strent *sonameent;
  87
  88   /* Help to identify duplicates.  */
  89   dev_t dev;
  90   ino_t ino;
  91
  92   enum
  93     {
  94       not_opened,
  95       opened,
  96       in_archive,
  97       closed
  98     } status;
  99
 100   /* How to extract elements from archives.  */
 101   enum extract_rule extract_rule;
 102
 103   /* Lazy-loading rule.  */
 104   bool lazyload;
 105
 106   /* If this is a DSO the flag indicates whether the file is directly
 107      used in a reference.  */
 108   bool used;
 109
 110   /* True when file should be added to DT_NEEDED list only when
 111      directly referenced.  */
 112   bool as_needed;
 113
 114   /* If nonzero this is the archive sequence number which can be used to
 115      determine whether back refernces from -( -) or GROUP statements
 116      have to be followed.  */
 117   int archive_seq;
 118
 119   /* Pointer to the record for the archive containing this file.  */
 120   struct usedfiles *archive_file;
 121
 122   /* Type of file.  We have to distinguish these types since they
 123      are searched for differently.  */
 124   enum file_type file_type;
 125   /* This is the ELF library handle for this file.  */
 126   Elf *elf;
 127
 128   /* The ELF header.  */
 129 #if NATIVE_ELF != 0
 130   XElf_Ehdr *ehdr;
 131 # define FILEINFO_EHDR(fi) (*(fi))
 132 #else
 133   XElf_Ehdr ehdr;
 134 # define FILEINFO_EHDR(fi) (fi)
 135 #endif
 136
 137   /* Index of the section header string table section.  We use a
 138      separate field and not the e_shstrndx field in the ELF header
 139      since in case of a file with more than 64000 sections the index
 140      might be stored in the section header of section zero.  The
 141      elf_getshdrstrndx() function can find the value but it is too
 142      costly to repeat this call over and over.  */
 143   size_t shstrndx;
 144
 145   /* Info about the sections of the file.  */
 146   struct scninfo
 147   {
 148     /* Handle for the section.  Note that we can store a section
 149        handle here because the file is not changing.  This together
 150        with the knowledge about the libelf library is enough for us to
 151        assume the section reference remains valid at all times.  */
 152     Elf_Scn *scn;
 153     /* Section header.  */
 154 #if NATIVE_ELF != 0
 155     XElf_Shdr *shdr;
 156 # define SCNINFO_SHDR(si) (*(si))
 157 #else
 158     XElf_Shdr shdr;
 159 # define SCNINFO_SHDR(si) (si)
 160 #endif
 161     /* Offset of this files section in the combined section.  */
 162     XElf_Off offset;
 163     /* Index of the section in the output file.  */
 164     Elf32_Word outscnndx;
 165     /* Index of the output section in the 'allsection' array.  */
 166     Elf32_Word allsectionsidx;
 167     /* True if the section is used.  */
 168     bool used;
 169     /* True if section is an unused COMDAT section.  */
 170     bool unused_comdat;
 171     /* True if this is a COMDAT group section.  */
 172     bool comdat_group;
 173     /* Section group number.  This is the index of the SHT_GROUP section.  */
 174     Elf32_Word grpid;
 175     /* Pointer back to the containing file information structure.  */
 176     struct usedfiles *fileinfo;
 177     /* List of symbols in this section (set only for merge-able sections
 178        and group sections).  */
 179     struct symbol *symbols;
 180     /* Size of relocations in this section.  Only used for relocation
 181        sections.  */
 182     size_t relsize;
 183     /* Pointer to next section which is put in the given output
 184        section.  */
 185     struct scninfo *next;
 186   } *scninfo;
 187
 188   /* List of section group sections.  */
 189   struct scninfo *groups;
 190
 191   /* The symbol table section.
 192
 193      XXX Maybe support for more than one symbol table is needed.  */
 194   Elf_Data *symtabdata;
 195   /* Extra section index table section.  */
 196   Elf_Data *xndxdata;
 197   /* Dynamic symbol table section.  */
 198   Elf_Data *dynsymtabdata;
 199   /* The version number section.  */
 200   Elf_Data *versymdata;
 201   /* The defined versions.  */
 202   Elf_Data *verdefdata;
 203   /* Number of versions defined.  */
 204   size_t nverdef;
 205   /* True if the version with the given index number is used in the
 206      output.  */
 207   XElf_Versym *verdefused;
 208   /* How many versions are used.  */
 209   size_t nverdefused;
 210   /* Handle for name of the version.  */
 211   struct Ebl_Strent **verdefent;
 212   /* The needed versions.  */
 213   Elf_Data *verneeddata;
 214   /* String table section associated with the symbol table.  */
 215   Elf32_Word symstridx;
 216   /* String table section associated with the dynamic symbol table.  */
 217   Elf32_Word dynsymstridx;
 218   /* Number of entries in the symbol table.  */
 219   size_t nsymtab;
 220   size_t nlocalsymbols;
 221   size_t ndynsymtab;
 222   /* Dynamic section.  */
 223   Elf_Scn *dynscn;
 224
 225   /* Indirection table for the symbols defined here.  */
 226   Elf32_Word *symindirect;
 227   Elf32_Word *dynsymindirect;
 228   /* For undefined or common symbols we need a reference to the symbol
 229      record.  */
 230   struct symbol **symref;
 231   struct symbol **dynsymref;
 232
 233   /* This is the file descriptor.  The value is -1 if the descriptor
 234      was already closed.  This can happen if we needed file descriptors
 235      to open new files.  */
 236   int fd;
 237   /* This flag is true if the descriptor was passed to the generic
 238      functions from somewhere else.  This is an implementation detail;
 239      no machine-specific code must use this flag.  */
 240   bool fd_passed;
 241
 242   /* True if any of the sections is merge-able.  */
 243   bool has_merge_sections;
 244 };
 245
 246
 247 /* Functions to test for the various types of files we handle.  */
 248 static inline int
 249 ld_file_rel_p (struct usedfiles *file)
 250 {
 251   return (elf_kind (file->elf) == ELF_K_ELF
 252           && FILEINFO_EHDR (file->ehdr).e_type == ET_REL);
 253 }
 254
 255 static inline int
 256 ld_file_dso_p (struct usedfiles *file)
 257 {
 258   return (elf_kind (file->elf) == ELF_K_ELF
 259           && FILEINFO_EHDR (file->ehdr).e_type == ET_DYN);
 260 }
 261
 262 static inline int
 263 ld_file_ar_p (struct usedfiles *file)
 264 {
 265   return elf_kind (file->elf) == ELF_K_AR;
 266 }
 267
 268
 269 struct pathelement
 270 {
 271   /* The next path to search.  */
 272   struct pathelement *next;
 273   /* The path name.  */
 274   const char *pname;
 275   /* Larger than zero if the directory exists, smaller than zero if not,
 276      zero if it is not yet known.  */
 277   int exist;
 278 };
 279
 280
 281 /* Forward declaration.  */
 282 struct ld_state;
 283
 284
 285 /* Callback functions.  */
 286 struct callbacks
 287 {
 288   /* Library names passed to the linker as -lXXX represent files named
 289      libXXX.YY.  The YY part can have different forms, depending on the
 290      architecture.  The generic set is .so and .a (in this order).  */
 291   const char **(*lib_extensions) (struct ld_state *)
 292        __attribute__ ((__const__));
 293 #define LIB_EXTENSION(state) \
 294   DL_CALL_FCT ((state)->callbacks.lib_extensions, (state))
 295
 296   /* Process the given file.  If the file is not yet open, open it.
 297      The first parameter is a file descriptor for the file which can
 298      be -1 to indicate the file has not yet been found.  The second
 299      parameter describes the file to be opened, the last one is the
 300      state of the linker which among other information contain the
 301      paths we look at.*/
 302   int (*file_process) (int fd, struct usedfiles *, struct ld_state *,
 303                        struct usedfiles **);
 304 #define FILE_PROCESS(fd, file, state, nextp) \
 305   DL_CALL_FCT ((state)->callbacks.file_process, (fd, file, state, nextp))
 306
 307   /* Close the given file.  */
 308   int (*file_close) (struct usedfiles *, struct ld_state *);
 309 #define FILE_CLOSE(file, state) \
 310   DL_CALL_FCT ((state)->callbacks.file_close, (file, state))
 311
 312   /* Create the output sections now.  This requires knowledge about
 313      all the sections we will need.  It may be necessary to sort the
 314      sections in the order they are supposed to appear in the
 315      executable.  The sorting use many different kinds of information
 316      to optimize the resulting binary.  Important is to respect
 317      segment boundaries and the needed alignment.  The mode of the
 318      segments will be determined afterwards automatically by the
 319      output routines.  */
 320   void (*create_sections) (struct ld_state *);
 321 #define CREATE_SECTIONS(state) \
 322   DL_CALL_FCT ((state)->callbacks.create_sections, (state))
 323
 324   /* Determine whether we have any non-weak unresolved references left.  */
 325   int (*flag_unresolved) (struct ld_state *);
 326 #define FLAG_UNRESOLVED(state) \
 327   DL_CALL_FCT ((state)->callbacks.flag_unresolved, (state))
 328
 329   /* Create the sections which are generated by the linker and are not
 330      present in the input file.  */
 331   void (*generate_sections) (struct ld_state *);
 332 #define GENERATE_SECTIONS(state) \
 333   DL_CALL_FCT ((state)->callbacks.generate_sections, (state))
 334
 335   /* Open the output file.  The file name is given or "a.out".  We
 336      create as much of the ELF structure as possible.  */
 337   int (*open_outfile) (struct ld_state *, int, int, int);
 338 #define OPEN_OUTFILE(state, machine, class, data) \
 339   DL_CALL_FCT ((state)->callbacks.open_outfile, (state, machine, class, data))
 340
 341   /* Create the data for the output file.  */
 342   int (*create_outfile) (struct ld_state *);
 343 #define CREATE_OUTFILE(state) \
 344   DL_CALL_FCT ((state)->callbacks.create_outfile, (state))
 345
 346   /* Process a relocation section.  */
 347   void (*relocate_section) (struct ld_state *, Elf_Scn *, struct scninfo *,
 348                             const Elf32_Word *);
 349 #define RELOCATE_SECTION(state, outscn, first, dblindirect) \
 350   DL_CALL_FCT ((state)->callbacks.relocate_section, (state, outscn, first,    \
 351                                                      dblindirect))
 352
 353   /* Allocate a data buffer for the relocations of the given output
 354      section.  */
 355   void (*count_relocations) (struct ld_state *, struct scninfo *);
 356 #define COUNT_RELOCATIONS(state, scninfo) \
 357   DL_CALL_FCT ((state)->callbacks.count_relocations, (state, scninfo))
 358
 359   /* Create relocations for executable or DSO.  */
 360   void (*create_relocations) (struct ld_state *, const Elf32_Word *);
 361 #define CREATE_RELOCATIONS(state, dlbindirect) \
 362   DL_CALL_FCT ((state)->callbacks.create_relocations, (state, dblindirect))
 363
 364   /* Finalize the output file.  */
 365   int (*finalize) (struct ld_state *);
 366 #define FINALIZE(state) \
 367   DL_CALL_FCT ((state)->callbacks.finalize, (state))
 368
 369   /* Check whether special section number is known.  */
 370   bool (*special_section_number_p) (struct ld_state *, size_t);
 371 #define SPECIAL_SECTION_NUMBER_P(state, number) \
 372   DL_CALL_FCT ((state)->callbacks.special_section_number_p, (state, number))
 373
 374   /* Check whether section type is known.  */
 375   bool (*section_type_p) (struct ld_state *, XElf_Word);
 376 #define SECTION_TYPE_P(state, type) \
 377   DL_CALL_FCT ((state)->callbacks.section_type_p, (state, type))
 378
 379   /* Return section flags for .dynamic section.  */
 380   XElf_Xword (*dynamic_section_flags) (struct ld_state *);
 381 #define DYNAMIC_SECTION_FLAGS(state) \
 382   DL_CALL_FCT ((state)->callbacks.dynamic_section_flags, (state))
 383
 384   /* Create the data structures for the .plt section and initialize it.  */
 385   void (*initialize_plt) (struct ld_state *, Elf_Scn *scn);
 386 #define INITIALIZE_PLT(state, scn) \
 387   DL_CALL_FCT ((state)->callbacks.initialize_plt, (state, scn))
 388
 389   /* Create the data structures for the .rel.plt section and initialize it.  */
 390   void (*initialize_pltrel) (struct ld_state *, Elf_Scn *scn);
 391 #define INITIALIZE_PLTREL(state, scn) \
 392   DL_CALL_FCT ((state)->callbacks.initialize_pltrel, (state, scn))
 393
 394   /* Finalize the .plt section the what belongs to them.  */
 395   void (*finalize_plt) (struct ld_state *, size_t, size_t, struct symbol **);
 396 #define FINALIZE_PLT(state, nsym, nsym_dyn, ndxtosym) \
 397   DL_CALL_FCT ((state)->callbacks.finalize_plt, (state, nsym, nsym_dyn, \
 398                                                  ndxtosym))
 399
 400   /* Create the data structures for the .got section and initialize it.  */
 401   void (*initialize_got) (struct ld_state *, Elf_Scn *scn);
 402 #define INITIALIZE_GOT(state, scn) \
 403   DL_CALL_FCT ((state)->callbacks.initialize_got, (state, scn))
 404
 405   /* Create the data structures for the .got.plt section and initialize it.  */
 406   void (*initialize_gotplt) (struct ld_state *, Elf_Scn *scn);
 407 #define INITIALIZE_GOTPLT(state, scn) \
 408   DL_CALL_FCT ((state)->callbacks.initialize_gotplt, (state, scn))
 409
 410   /* Return the tag corresponding to the native relocation type for
 411      the platform.  */
 412   int (*rel_type) (struct ld_state *);
 413 #define REL_TYPE(state) \
 414   DL_CALL_FCT ((state)->callbacks.rel_type, (state))
 415 };
 416
 417
 418 /* Structure for symbol representation.  This data structure is used a
 419    lot, so size is important.  */
 420 struct symbol
 421 {
 422   /* Symbol name.  */
 423   const char *name;
 424   /* Size of the object.  */
 425   XElf_Xword size;
 426   /* Index of the symbol in the symbol table of the object.  */
 427   size_t symidx;
 428   /* Index of the symbol in the symbol table of the output file.  */
 429   size_t outsymidx;
 430
 431   /* Description where the symbol is found/needed.  */
 432   size_t scndx;
 433   struct usedfiles *file;
 434   /* Index of the symbol table.  */
 435   Elf32_Word symscndx;
 436
 437   /* Index of the symbol in the dynamic symbol table of the output
 438      file.  Note that the value only needs to be 16 bit wide since
 439      there cannot be more sections in an executable or DSO.  */
 440   unsigned int outdynsymidx:16;
 441
 442   /* Type of the symbol.  */
 443   unsigned int type:4;
 444   /* Various flags.  */
 445   unsigned int defined:1;
 446   unsigned int common:1;
 447   unsigned int weak:1;
 448   unsigned int added:1;
 449   unsigned int merged:1;
 450   unsigned int local:1;
 451   unsigned int hidden:1;
 452   /* Nonzero if the symbol is on the from_dso list.  */
 453   unsigned int on_dsolist:1;
 454   /* Nonzero if symbol needs copy relocation, reset when the
 455      relocation has been created.  */
 456   unsigned int need_copy:1;
 457   unsigned int in_dso:1;
 458
 459   union
 460   {
 461     /* Pointer to the handle created by the functions which create
 462        merged section contents.  We use 'void *' because there are
 463        different implementations used.  */
 464     void *handle;
 465     XElf_Addr value;
 466   } merge;
 467
 468   /* Pointer to next/previous symbol on whatever list the symbol is.  */
 469   struct symbol *next;
 470   struct symbol *previous;
 471   /* Pointer to next symbol of the same section (only set for merge-able
 472      sections).  */
 473   struct symbol *next_in_scn;
 474 };
 475
 476
 477 /* Get the definition for the symbol table.  */
 478 #include <symbolhash.h>
 479
 480 /* Simple single linked list of file names.  */
 481 struct filename_list
 482 {
 483   const char *name;
 484   struct usedfiles *real;
 485   struct filename_list *next;
 486   bool group_start;
 487   bool group_end;
 488   bool as_needed;
 489 };
 490
 491
 492 /* Data structure to describe expression in linker script.  */
 493 struct expression
 494 {
 495   enum expression_tag
 496     {
 497       exp_num,
 498       exp_sizeof_headers,
 499       exp_pagesize,
 500       exp_id,
 501       exp_mult,
 502       exp_div,
 503       exp_mod,
 504       exp_plus,
 505       exp_minus,
 506       exp_and,
 507       exp_or,
 508       exp_align
 509     } tag;
 510
 511   union
 512   {
 513     uintmax_t num;
 514     struct expression *child;
 515     struct
 516     {
 517       struct expression *left;
 518       struct expression *right;
 519     } binary;
 520     const char *str;
 521   } val;
 522 };
 523
 524
 525 /* Data structure for section name with flags.  */
 526 struct input_section_name
 527 {
 528   const char *name;
 529   bool sort_flag;
 530 };
 531
 532 /* File name mask with section name.  */
 533 struct filemask_section_name
 534 {
 535   const char *filemask;
 536   const char *excludemask;
 537   struct input_section_name *section_name;
 538   bool keep_flag;
 539 };
 540
 541 /* Data structure for assignments.  */
 542 struct assignment
 543 {
 544   const char *variable;
 545   struct expression *expression;
 546   struct symbol *sym;
 547   bool provide_flag;
 548 };
 549
 550
 551 /* Data structure describing input for an output section.  */
 552 struct input_rule
 553 {
 554   enum
 555     {
 556       input_section,
 557       input_assignment
 558     } tag;
 559
 560   union
 561   {
 562     struct assignment *assignment;
 563     struct filemask_section_name *section;
 564   } val;
 565
 566   struct input_rule *next;
 567 };
 568
 569
 570 /* Data structure to describe output section.  */
 571 struct output_section
 572 {
 573   const char *name;
 574   struct input_rule *input;
 575   XElf_Addr max_alignment;
 576   bool ignored;
 577 };
 578
 579
 580 /* Data structure to describe output file format.  */
 581 struct output_rule
 582 {
 583   enum
 584     {
 585       output_section,
 586       output_assignment
 587     } tag;
 588
 589   union
 590   {
 591     struct assignment *assignment;
 592     struct output_section section;
 593   } val;
 594
 595   struct output_rule *next;
 596 };
 597
 598
 599 /* List of all the segments the linker script describes.  */
 600 struct output_segment
 601 {
 602   int mode;
 603   struct output_rule *output_rules;
 604   struct output_segment *next;
 605
 606   XElf_Off offset;
 607   XElf_Addr addr;
 608   XElf_Xword align;
 609 };
 610
 611
 612 /* List of identifiers.  */
 613 struct id_list
 614 {
 615   union
 616   {
 617     enum id_type
 618       {
 619         id_str,         /* Normal string.  */
 620         id_all,         /* "*", matches all.  */
 621         id_wild         /* Globbing wildcard string.  */
 622       } id_type;
 623     struct
 624     {
 625       bool local;
 626       const char *versionname;
 627     } s;
 628   } u;
 629   const char *id;
 630   struct id_list *next;
 631 };
 632
 633
 634 /* Version information.  */
 635 struct version
 636 {
 637   struct version *next;
 638   struct id_list *local_names;
 639   struct id_list *global_names;
 640   const char *versionname;
 641   const char *parentname;
 642 };
 643
 644
 645 /* Head for list of sections.  */
 646 struct scnhead
 647 {
 648   /* Name of the sections.  */
 649   const char *name;
 650
 651   /* Accumulated flags for the sections.  */
 652   XElf_Xword flags;
 653
 654   /* Type of the sections.  */
 655   XElf_Word type;
 656
 657   /* Entry size.  If there are differencs between the sections with
 658      the same name this field contains 1.  */
 659   XElf_Word entsize;
 660
 661   /* If non-NULL pointer to group signature.  */
 662   const char *grp_signature;
 663
 664   /* Maximum alignment for all sections.  */
 665   XElf_Word align;
 666
 667   /* Distinguish between normal sections coming from the input file
 668      and sections generated by the linker.  */
 669   enum scn_kind
 670     {
 671       scn_normal,               /* Section from the input file(s).  */
 672       scn_dot_interp,           /* Generated .interp section.  */
 673       scn_dot_got,              /* Generated .got section.  */
 674       scn_dot_gotplt,           /* Generated .got.plt section.  */
 675       scn_dot_dynrel,           /* Generated .rel.dyn section.  */
 676       scn_dot_dynamic,          /* Generated .dynamic section.  */
 677       scn_dot_dynsym,           /* Generated .dynsym section.  */
 678       scn_dot_dynstr,           /* Generated .dynstr section.  */
 679       scn_dot_hash,             /* Generated .hash section.  */
 680       scn_dot_gnu_hash,         /* Generated .gnu.hash section.  */
 681       scn_dot_plt,              /* Generated .plt section.  */
 682       scn_dot_pltrel,           /* Generated .rel.plt section.  */
 683       scn_dot_version,          /* Generated .gnu.version section.  */
 684       scn_dot_version_r,        /* Generated .gnu.version_r section.  */
 685       scn_dot_note_gnu_build_id /* Generated .note.gnu.build-id section.  */
 686     } kind;
 687
 688   /* True is the section is used in the output.  */
 689   bool used;
 690
 691   /* Total size (only determined this way for relocation sections).  */
 692   size_t relsize;
 693
 694   /* Filled in by the section sorting to indicate which segment the
 695      section goes in.  */
 696   int segment_nr;
 697
 698   /* Index of the output section.  We cannot store the section handle
 699      directly here since the handle is a pointer in a dynamically
 700      allocated table which might move if it becomes too small for all
 701      the sections.  Using the index the correct value can be found at
 702      all times.  */
 703   XElf_Word scnidx;
 704
 705   /* Index of the STT_SECTION entry for this section in the symbol
 706      table.  */
 707   XElf_Word scnsymidx;
 708
 709   /* Address of the section in the output file.  */
 710   XElf_Addr addr;
 711
 712   /* Handle for the section name in the output file's section header
 713      string table.  */
 714   struct Ebl_Strent *nameent;
 715
 716   /* Tail of list of symbols for this section.  Only set if the
 717      section is merge-able.  */
 718   struct symbol *symbols;
 719
 720   /* Pointer to last section.  */
 721   struct scninfo *last;
 722 };
 723
 724
 725 /* Define hash table for sections.  */
 726 #include <sectionhash.h>
 727
 728 /* Define hash table for version symbols.  */
 729 #include <versionhash.h>
 730
 731
 732 /* State of the linker.  */
 733 struct ld_state
 734 {
 735   /* ELF backend library handle.  */
 736   Ebl *ebl;
 737
 738   /* List of all archives participating, in this order.  */
 739   struct usedfiles *archives;
 740   /* End of the list.  */
 741   struct usedfiles *tailarchives;
 742   /* If nonzero we are looking for the beginning of a group.  */
 743   bool group_start_requested;
 744   /* Pointer to the archive starting the group.  */
 745   struct usedfiles *group_start_archive;
 746
 747   /* List of the DSOs we found.  */
 748   struct usedfiles *dsofiles;
 749   /* Number of DSO files.  */
 750   size_t ndsofiles;
 751   /* Ultimate list of object files which are linked in.  */
 752   struct usedfiles *relfiles;
 753
 754   /* List the DT_NEEDED DSOs.  */
 755   struct usedfiles *needed;
 756
 757   /* Temporary storage for the parser.  */
 758   struct filename_list *srcfiles;
 759
 760   /* List of all the paths to look at.  */
 761   struct pathelement *paths;
 762   /* Tail of the list.  */
 763   struct pathelement *tailpaths;
 764
 765   /* User provided paths for lookup of DSOs.  */
 766   struct pathelement *rpath;
 767   struct pathelement *rpath_link;
 768   struct pathelement *runpath;
 769   struct pathelement *runpath_link;
 770   struct Ebl_Strent *rxxpath_strent;
 771   int rxxpath_tag;
 772
 773   /* From the environment variable LD_LIBRARY_PATH.  */
 774   struct pathelement *ld_library_path1;
 775   struct pathelement *ld_library_path2;
 776
 777   /* Name of the output file.  */
 778   const char *outfname;
 779   /* Name of the temporary file we initially create.  */
 780   const char *tempfname;
 781   /* File descriptor opened for the output file.  */
 782   int outfd;
 783   /* The ELF descriptor for the output file.  */
 784   Elf *outelf;
 785
 786   /* Type of output file.  */
 787   enum file_type file_type;
 788
 789   /* Is this a system library or not.  */
 790   bool is_system_library;
 791
 792   /* Page size to be assumed for the binary.  */
 793   size_t pagesize;
 794
 795   /* Name of the interpreter for dynamically linked objects.  */
 796   const char *interp;
 797   /* Index of the .interp section.  */
 798   Elf32_Word interpscnidx;
 799
 800   /* Optimization level.  */
 801   unsigned long int optlevel;
 802
 803   /* If true static linking is requested.  */
 804   bool statically;
 805
 806   /* If true, add DT_NEEDED entries for following files if they are
 807      needed.  */
 808   bool as_needed;
 809
 810   /* How to extract elements from archives.  */
 811   enum extract_rule extract_rule;
 812
 813   /* Sequence number of the last archive we used.  */
 814   int last_archive_used;
 815
 816   /* If true print to stdout information about the files we are
 817      trying to open.  */
 818   bool trace_files;
 819
 820   /* If true multiple definitions are not considered an error; the
 821      first is used.  */
 822   bool muldefs;
 823
 824   /* If true undefined symbols when building DSOs are not fatal.  */
 825   bool nodefs;
 826
 827   /* If true add line indentifying link-editor to .comment section.  */
 828   bool add_ld_comment;
 829
 830   /* Stripping while linking.  */
 831   enum
 832     {
 833       strip_none,
 834       strip_debug,
 835       strip_all,
 836       strip_everything
 837     } strip;
 838
 839   /* The callback function vector.  */
 840   struct callbacks callbacks;
 841
 842   /* Name of the entry symbol.  Can also be a numeric value.  */
 843   const char *entry;
 844
 845   /* The description of the segments in the output file.  */
 846   struct output_segment *output_segments;
 847
 848   /* List of the symbols we created from linker script definitions.  */
 849   struct symbol *lscript_syms;
 850   size_t nlscript_syms;
 851
 852   /* Table with known symbols.  */
 853   ld_symbol_tab symbol_tab;
 854
 855   /* Table with used sections.  */
 856   ld_section_tab section_tab;
 857
 858   /* The list of sections once we collected them.   */
 859   struct scnhead **allsections;
 860   size_t nallsections;
 861   size_t nusedsections;
 862   size_t nnotesections;
 863
 864   /* Beginning of the list of symbols which are still unresolved.  */
 865   struct symbol *unresolved;
 866   /* Number of truely unresolved entries in the list.  */
 867   size_t nunresolved;
 868   /* Number of truely unresolved, non-weak entries in the list.  */
 869   size_t nunresolved_nonweak;
 870
 871   /* List of common symbols.  */
 872   struct symbol *common_syms;
 873   /* Section for the common symbols.  */
 874   struct scninfo *common_section;
 875
 876   /* List of symbols defined in DSOs and used in a relocatable file.
 877      DSO symbols not referenced in the relocatable files are not on
 878      the list.  If a symbol is on the list the on_dsolist field in the
 879      'struct symbol' is nonzero.  */
 880   struct symbol *from_dso;
 881   /* Number of entries in from_dso.  */
 882   size_t nfrom_dso;
 883   /* Number of entries in the dynamic symbol table.  */
 884   size_t ndynsym;
 885   /* Number of PLT entries from DSO references.  */
 886   size_t nplt;
 887   /* Number of PLT entries from DSO references.  */
 888   size_t ngot;
 889   /* Number of copy relocations.  */
 890   size_t ncopy;
 891   /* Section for copy relocations.  */
 892   struct scninfo *copy_section;
 893
 894   /* Keeping track of the number of symbols in the output file.  */
 895   size_t nsymtab;
 896   size_t nlocalsymbols;
 897
 898   /* Special symbols.  */
 899   struct symbol *init_symbol;
 900   struct symbol *fini_symbol;
 901
 902   /* The description of the segments in the output file as described
 903      in the default linker script.  This information will be used in
 904      addition to the user-provided information.  */
 905   struct output_segment *default_output_segments;
 906   /* Search paths added by the default linker script.  */
 907   struct pathelement *default_paths;
 908
 909 #ifndef BASE_ELF_NAME
 910   /* The handle of the ld backend library.  */
 911   void *ldlib;
 912 #endif
 913
 914   /* String table for the section headers.  */
 915   struct Ebl_Strtab *shstrtab;
 916
 917   /* True if output file should contain symbol table.  */
 918   bool need_symtab;
 919   /* Symbol table section.  */
 920   Elf32_Word symscnidx;
 921   /* Extended section table section.  */
 922   Elf32_Word xndxscnidx;
 923   /* Symbol string table section.  */
 924   Elf32_Word strscnidx;
 925
 926   /* True if output file should contain dynamic symbol table.  */
 927   bool need_dynsym;
 928   /* Dynamic symbol table section.  */
 929   Elf32_Word dynsymscnidx;
 930   /* Dynamic symbol string table section.  */
 931   Elf32_Word dynstrscnidx;
 932   /* Dynamic symbol hash tables.  */
 933   size_t hashscnidx;
 934   size_t gnuhashscnidx;
 935
 936   /* Procedure linkage table section.  */
 937   Elf32_Word pltscnidx;
 938   /* Number of entries already in the PLT section.  */
 939   size_t nplt_used;
 940   /* Relocation for procedure linkage table section.  */
 941   Elf32_Word pltrelscnidx;
 942
 943   /* Global offset table section.  */
 944   Elf32_Word gotscnidx;
 945   /* And the part of the PLT.  */
 946   Elf32_Word gotpltscnidx;
 947
 948   /* This section will hole all non-PLT relocations.  */
 949   Elf32_Word reldynscnidx;
 950
 951   /* Index of the sections to handle versioning.  */
 952   Elf32_Word versymscnidx;
 953   Elf32_Word verneedscnidx;
 954   /* XXX Should the following names be verneed...?  */
 955   /* Number of version definitions in input DSOs used.  */
 956   int nverdefused;
 957   /* Number of input DSOs using versioning.  */
 958   int nverdeffile;
 959   /* Index of next version.  */
 960   int nextveridx;
 961
 962   /* TLS segment.  */
 963   bool need_tls;
 964   XElf_Addr tls_start;
 965   XElf_Addr tls_tcb;
 966
 967   /* Hash table for version symbol strings.  Only strings without
 968      special characters are hashed here.  */
 969   ld_version_str_tab version_str_tab;
 970   /* At most one of the following two variables is set to true if either
 971      global or local symbol binding is selected as the default.  */
 972   bool default_bind_local;
 973   bool default_bind_global;
 974
 975   /* Execuatable stack selection.  */
 976   enum execstack
 977     {
 978       execstack_false = 0,
 979       execstack_true,
 980       execstack_false_force
 981     } execstack;
 982
 983   /* True if only used sections are used.  */
 984   bool gc_sections;
 985
 986   /* Array to determine final index of symbol.  */
 987   Elf32_Word *dblindirect;
 988
 989   /* Section group handling.  */
 990   struct scngroup
 991   {
 992     Elf32_Word outscnidx;
 993     int nscns;
 994     struct member
 995     {
 996       struct scnhead *scn;
 997       struct member *next;
 998     } *member;
 999     struct Ebl_Strent *nameent;
1000     struct symbol *symbol;
1001     struct scngroup *next;
1002   } *groups;
1003
1004   /* True if the output file needs a .got section.  */
1005   bool need_got;
1006   /* Number of relocations for GOT section caused.  */
1007   size_t nrel_got;
1008
1009   /* Number of entries needed in the .dynamic section.  */
1010   int ndynamic;
1011   /* To keep track of added entries.  */
1012   int ndynamic_filled;
1013   /* Index for the dynamic section.  */
1014   Elf32_Word dynamicscnidx;
1015
1016   /* Flags set in the DT_FLAGS word.  */
1017   Elf32_Word dt_flags;
1018   /* Flags set in the DT_FLAGS_1 word.  */
1019   Elf32_Word dt_flags_1;
1020   /* Flags set in the DT_FEATURE_1 word.  */
1021   Elf32_Word dt_feature_1;
1022
1023   /* Lazy-loading state for dependencies.  */
1024   bool lazyload;
1025
1026   /* True if an .eh_frame_hdr section should be generated.  */
1027   bool eh_frame_hdr;
1028
1029   /* What hash style to generate.  */
1030   enum
1031     {
1032       hash_style_none = 0,
1033       hash_style_sysv = 1,
1034 #define GENERATE_SYSV_HASH ((ld_state.hash_style & hash_style_sysv) != 0)
1035       hash_style_gnu = 2
1036 #define GENERATE_GNU_HASH ((ld_state.hash_style & hash_style_gnu) != 0)
1037     }
1038   hash_style;
1039
1040
1041   /* True if in executables all global symbols should be exported in
1042      the dynamic symbol table.  */
1043   bool export_all_dynamic;
1044
1045   /* Build-ID style.  NULL is none.  */
1046   const char *build_id;
1047   Elf32_Word buildidscnidx;
1048
1049   /* If DSO is generated, this is the SONAME.  */
1050   const char *soname;
1051
1052   /* List of all relocation sections.  */
1053   struct scninfo *rellist;
1054   /* Total size of non-PLT relocations.  */
1055   size_t relsize_total;
1056
1057   /* Record for the GOT symbol, if known.  */
1058   struct symbol *got_symbol;
1059   /* Record for the dynamic section symbol, if known.  */
1060   struct symbol *dyn_symbol;
1061
1062   /* Obstack used for small objects which will not be deleted.  */
1063   struct obstack smem;
1064 };
1065
1066
1067 /* The interface to the scanner.  */
1068
1069 /* Parser entry point.  */
1070 extern int ldparse (void);
1071
1072 /* The input file.  */
1073 extern FILE *ldin;
1074
1075 /* Name of the input file.  */
1076 extern const char *ldin_fname;
1077
1078 /* Current line number.  Must be reset for a new file.  */
1079 extern int ldlineno;
1080
1081 /* If nonzero we are currently parsing a version script.  */
1082 extern int ld_scan_version_script;
1083
1084 /* Flags defined in ld.c.  */
1085 extern int verbose;
1086 extern int conserve_memory;
1087
1088
1089 /* Linker state.  This contains all global information.  */
1090 extern struct ld_state ld_state;
1091
1092
1093 /* Generic ld helper functions.  */
1094
1095 /* Append a new directory to search libraries in.  */
1096 extern void ld_new_searchdir (const char *dir);
1097
1098 /* Append a new file to the list of input files.  */
1099 extern struct usedfiles *ld_new_inputfile (const char *fname,
1100                                            enum file_type type);
1101
1102
1103 /* These are the generic implementations for the callbacks used by ld.  */
1104
1105 /* Initialize state object.  This callback function is called after the
1106    parameters are parsed but before any file is searched for.  */
1107 extern int ld_prepare_state (const char *emulation);
1108
1109
1110 /* Function to determine whether an object will be dynamically linked.  */
1111 extern bool dynamically_linked_p (void);
1112
1113 /* Helper functions for the architecture specific code.  */
1114
1115 /* Checked whether the symbol is undefined and referenced from a DSO.  */
1116 extern bool linked_from_dso_p (struct scninfo *scninfo, size_t symidx);
1117 #ifdef __GNUC_STDC_INLINE__
1118 __attribute__ ((__gnu_inline__))
1119 #endif
1120 extern inline bool
1121 linked_from_dso_p (struct scninfo *scninfo, size_t symidx)
1122 {
1123   struct usedfiles *file = scninfo->fileinfo;
1124
1125   /* If this symbol is not undefined in this file it cannot come from
1126      a DSO.  */
1127   if (symidx < file->nlocalsymbols)
1128     return false;
1129
1130   struct symbol *sym = file->symref[symidx];
1131
1132   return sym->defined && sym->in_dso;
1133 }
1134
1135 #endif  /* ld.h */