Home | History | Annotate | Download | only in src
      1 /* Copyright (C) 2001-2010, 2012 Red Hat, Inc.
      2    This file is part of Red Hat elfutils.
      3    Written by Ulrich Drepper <drepper (at) redhat.com>, 2001.
      4 
      5    Red Hat elfutils is free software; you can redistribute it and/or modify
      6    it under the terms of the GNU General Public License as published by the
      7    Free Software Foundation; version 2 of the License.
      8 
      9    Red Hat elfutils is distributed in the hope that it will be useful, but
     10    WITHOUT ANY WARRANTY; without even the implied warranty of
     11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     12    General Public License for more details.
     13 
     14    You should have received a copy of the GNU General Public License along
     15    with Red Hat elfutils; if not, write to the Free Software Foundation,
     16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
     17 
     18    Red Hat elfutils is an included package of the Open Invention Network.
     19    An included package of the Open Invention Network is a package for which
     20    Open Invention Network licensees cross-license their patents.  No patent
     21    license is granted, either expressly or impliedly, by designation as an
     22    included package.  Should you wish to participate in the Open Invention
     23    Network licensing program, please visit www.openinventionnetwork.com
     24    <http://www.openinventionnetwork.com>.  */
     25 
     26 #ifdef HAVE_CONFIG_H
     27 # include <config.h>
     28 #endif
     29 
     30 #include <argp.h>
     31 #include <assert.h>
     32 #include <error.h>
     33 #include <fcntl.h>
     34 #include <libelf.h>
     35 #include <libintl.h>
     36 #include <locale.h>
     37 #include <mcheck.h>
     38 #include <stdio.h>
     39 #include <stdio_ext.h>
     40 #include <stdlib.h>
     41 #include <string.h>
     42 #include <unistd.h>
     43 
     44 #include <system.h>
     45 #include "ld.h"
     46 #include "list.h"
     47 
     48 
     49 /* Name and version of program.  */
     50 static void print_version (FILE *stream, struct argp_state *state);
     51 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
     52 
     53 /* Bug report address.  */
     54 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
     55 
     56 
     57 /* Values for the various options.  */
     58 enum
     59   {
     60     ARGP_whole_archive = 300,
     61     ARGP_no_whole_archive,
     62     ARGP_static,
     63     ARGP_dynamic,
     64     ARGP_pagesize,
     65     ARGP_rpath_link,
     66     ARGP_runpath,
     67     ARGP_runpath_link,
     68     ARGP_version_script,
     69     ARGP_gc_sections,
     70     ARGP_no_gc_sections,
     71     ARGP_no_undefined,
     72     ARGP_conserve,
     73     ARGP_as_needed,
     74     ARGP_no_as_needed,
     75     ARGP_eh_frame_hdr,
     76     ARGP_hash_style,
     77     ARGP_build_id,
     78 #if YYDEBUG
     79     ARGP_yydebug,
     80 #endif
     81   };
     82 
     83 
     84 /* Definitions of arguments for argp functions.  */
     85 static const struct argp_option options[] =
     86 {
     87   { NULL, 0, NULL, 0, N_("Input File Control:"), 0 },
     88   { "whole-archive", ARGP_whole_archive, NULL, 0,
     89     N_("Include whole archives in the output from now on."), 0 },
     90   { "no-whole-archive", ARGP_no_whole_archive, NULL, 0,
     91     N_("Stop including the whole archives in the output."), 0 },
     92   { NULL, 'l', N_("FILE"), OPTION_HIDDEN, NULL, 0 },
     93   { "start-group", '(', NULL, 0, N_("Start a group."), 0 },
     94   { "end-group", ')', NULL, 0, N_("End a group."), 0 },
     95   { NULL, 'L', N_("PATH"), 0,
     96     N_("Add PATH to list of directories files are searched in."), 0 },
     97   { "as-needed", ARGP_as_needed, NULL, 0,
     98     N_("Only set DT_NEEDED for following dynamic libs if actually used"), 0 },
     99   { "no-as-needed", ARGP_no_as_needed, NULL, 0,
    100     N_("Always set DT_NEEDED for following dynamic libs"), 0 },
    101   { "rpath-link", ARGP_rpath_link, "PATH", OPTION_HIDDEN, NULL, 0 },
    102   { NULL, 'i', NULL, 0, N_("Ignore LD_LIBRARY_PATH environment variable."),
    103     0 },
    104 
    105   { NULL, 0, NULL, 0, N_("Output File Control:"), 0 },
    106   { "output", 'o', N_("FILE"), 0, N_("Place output in FILE."), 0 },
    107   { NULL, 'z', "KEYWORD", OPTION_HIDDEN, NULL, 0 },
    108   { "-z nodefaultlib", '\0', NULL, OPTION_DOC,
    109     N_("Object is marked to not use default search path at runtime."), 0 },
    110   { "-z allextract", '\0', NULL, OPTION_DOC,
    111     N_("Same as --whole-archive."), 0 },
    112   { "-z defaultextract", '\0', NULL, OPTION_DOC, N_("\
    113 Default rules of extracting from archive; weak references are not enough."),
    114     0 },
    115   { "-z weakextract", '\0', NULL, OPTION_DOC,
    116     N_("Weak references cause extraction from archive."), 0 },
    117   { "-z muldefs", '\0', NULL, OPTION_DOC,
    118     N_("Allow multiple definitions; first is used."), 0 },
    119   { "-z defs | nodefs", '\0', NULL, OPTION_DOC,
    120     N_("Disallow/allow undefined symbols in DSOs."), 0 },
    121     { "no-undefined", ARGP_no_undefined, NULL, OPTION_HIDDEN, NULL, 0 },
    122   { "-z origin", '\0', NULL, OPTION_DOC,
    123     N_("Object requires immediate handling of $ORIGIN."), 0 },
    124   { "-z now", '\0', NULL, OPTION_DOC,
    125     N_("Relocation will not be processed lazily."), 0 },
    126   { "-z nodelete", '\0', NULL, OPTION_DOC,
    127     N_("Object cannot be unloaded at runtime."), 0 },
    128   { "-z initfirst", '\0', NULL, OPTION_DOC,
    129     N_("Mark object to be initialized first."), 0 },
    130   { "-z lazyload | nolazyload", '\0', NULL, OPTION_DOC,
    131     N_("Enable/disable lazy-loading flag for following dependencies."), 0 },
    132   { "-z nodlopen", '\0', NULL, OPTION_DOC,
    133     N_("Mark object as not loadable with 'dlopen'."), 0 },
    134   { "-z ignore | record", '\0', NULL, OPTION_DOC,
    135     N_("Ignore/record dependencies on unused DSOs."), 0 },
    136   { "-z systemlibrary", '\0', NULL, OPTION_DOC,
    137     N_("Generated DSO will be a system library."), 0 },
    138   { "entry", 'e', N_("ADDRESS"), 0, N_("Set entry point address."), 0 },
    139   { "static", ARGP_static, NULL, OPTION_HIDDEN, NULL, 0 },
    140   { "-B static", ARGP_static, NULL, OPTION_DOC,
    141     N_("Do not link against shared libraries."), 0 },
    142   { "dynamic", ARGP_dynamic, NULL, OPTION_HIDDEN, NULL, 0 },
    143   { "-B dynamic", ARGP_dynamic, NULL, OPTION_DOC,
    144     N_("Prefer linking against shared libraries."), 0 },
    145   { "export-dynamic", 'E', NULL, 0, N_("Export all dynamic symbols."), 0 },
    146   { "strip-all", 's', NULL, 0, N_("Strip all symbols."), 0 },
    147   { "strip-debug", 'S', NULL, 0, N_("Strip debugging symbols."), 0 },
    148   { "pagesize", ARGP_pagesize, "SIZE", 0,
    149     N_("Assume pagesize for the target system to be SIZE."), 0 },
    150   { "rpath", 'R', "PATH", OPTION_HIDDEN, NULL, 0 },
    151   { "runpath", ARGP_runpath, "PATH", 0, N_("Set runtime DSO search path."),
    152     0 },
    153   { "runpath-link", ARGP_runpath_link, "PATH", 0,
    154     N_("Set link time DSO search path."), 0 },
    155   { "shared", 'G', NULL, 0, N_("Generate dynamic shared object."), 0 },
    156   { NULL, 'r', NULL, 0L, N_("Generate relocatable object."), 0 },
    157   { NULL, 'B', "KEYWORD", OPTION_HIDDEN, "", 0 },
    158   { "-B local", 'B', NULL, OPTION_DOC,
    159     N_("Causes symbol not assigned to a version be reduced to local."), 0 },
    160   { "gc-sections", ARGP_gc_sections, NULL, 0, N_("Remove unused sections."),
    161     0 },
    162   { "no-gc-sections", ARGP_no_gc_sections, NULL, 0,
    163     N_("Don't remove unused sections."), 0 },
    164   { "soname", 'h', "NAME", 0, N_("Set soname of shared object."), 0 },
    165   { "dynamic-linker", 'I', "NAME", 0, N_("Set the dynamic linker name."), 0 },
    166   { NULL, 'Q', "YN", OPTION_HIDDEN, NULL, 0 },
    167   { "-Q y | n", 'Q', NULL, OPTION_DOC,
    168     N_("Add/suppress addition indentifying link-editor to .comment section."),
    169     0 },
    170   { "eh-frame-hdr", ARGP_eh_frame_hdr, NULL, 0,
    171     N_("Create .eh_frame_hdr section"), 0 },
    172   { "hash-style", ARGP_hash_style, "STYLE", 0,
    173     N_("Set hash style to sysv, gnu or both."), 0 },
    174   { "build-id", ARGP_build_id, "STYLE", OPTION_ARG_OPTIONAL,
    175     N_("Generate build ID note (md5, sha1 (default), uuid)."), 0 },
    176 
    177   { NULL, 0, NULL, 0, N_("Linker Operation Control:"), 0 },
    178   { "verbose", 'v', NULL, 0, N_("Verbose messages."), 0 },
    179   { "trace", 't', NULL, 0, N_("Trace file opens."), 0 },
    180   { "conserve-memory", ARGP_conserve, NULL, 0,
    181     N_("Trade speed for less memory usage"), 0 },
    182   { NULL, 'O', N_("LEVEL"), OPTION_ARG_OPTIONAL,
    183     N_("Set optimization level to LEVEL."), 0 },
    184   { NULL, 'c', N_("FILE"), 0, N_("Use linker script in FILE."), 0 },
    185 #if YYDEBUG
    186   { "yydebug", ARGP_yydebug, NULL, 0,
    187     N_("Select to get parser debug information"), 0 },
    188 #endif
    189   { "version-script", ARGP_version_script, "FILE", 0,
    190     N_("Read version information from FILE."), 0 },
    191   { "emulation", 'm', "NAME", 0, N_("Set emulation to NAME."), 0 },
    192 
    193   { NULL, 0, NULL, 0, NULL, 0 }
    194 };
    195 
    196 /* Short description of program.  */
    197 static const char doc[] = N_("Combine object and archive files.");
    198 
    199 /* Strings for arguments in help texts.  */
    200 static const char args_doc[] = N_("[FILE]...");
    201 
    202 /* Prototype for option handler.  */
    203 static void replace_args (int argc, char *argv[]);
    204 static error_t parse_opt_1st (int key, char *arg, struct argp_state *state);
    205 static error_t parse_opt_2nd (int key, char *arg, struct argp_state *state);
    206 
    207 /* Data structure to communicate with argp functions.  */
    208 static struct argp argp_1st =
    209 {
    210   options, parse_opt_1st, args_doc, doc, NULL, NULL, NULL
    211 };
    212 static struct argp argp_2nd =
    213 {
    214   options, parse_opt_2nd, args_doc, doc, NULL, NULL, NULL
    215 };
    216 
    217 
    218 /* Linker state.  This contains all global information.  */
    219 struct ld_state ld_state;
    220 
    221 /* List of the input files.  */
    222 static struct file_list
    223 {
    224   const char *name;
    225   struct file_list *next;
    226 } *input_file_list;
    227 
    228 /* If nonzero be verbose.  */
    229 int verbose;
    230 
    231 /* If nonzero, trade speed for less memory/address space usage.  */
    232 int conserve_memory;
    233 
    234 /* The emulation name to use.  */
    235 static const char *emulation;
    236 
    237 /* Keep track of the nesting level.  Even though we don't handle nested
    238    groups we still keep track to improve the error messages.  */
    239 static int group_level;
    240 
    241 /* The last file we processed.  */
    242 static struct usedfiles *last_file;
    243 
    244 /* The default linker script.  */
    245 /* XXX We'll do this a bit different in the real solution.  */
    246 static const char *linker_script = SRCDIR "/elf32-i386.script";
    247 
    248 /* Nonzero if an error occurred while loading the input files.  */
    249 static int error_loading;
    250 
    251 
    252 /* Intermediate storage for the LD_LIBRARY_PATH information from the
    253    environment.  */
    254 static char *ld_library_path1;
    255 
    256 /* Flag used to communicate with the scanner.  */
    257 int ld_scan_version_script;
    258 
    259 /* Name of the input file.  */
    260 const char *ldin_fname;
    261 
    262 /* Define by parser if required.  */
    263 extern int lddebug;
    264 
    265 
    266 /* Prototypes for local functions.  */
    267 static void parse_z_option (const char *arg);
    268 static void parse_z_option_2 (const char *arg);
    269 static void parse_B_option (const char *arg);
    270 static void parse_B_option_2 (const char *arg);
    271 static void determine_output_format (void);
    272 static void load_needed (void);
    273 static void collect_sections (void);
    274 static void add_rxxpath (struct pathelement **pathp, const char *str);
    275 static void gen_rxxpath_data (void);
    276 static void read_version_script (const char *fname);
    277 static void create_lscript_symbols (void);
    278 static void create_special_section_symbol (struct symbol **symp,
    279 					   const char *name);
    280 
    281 
    282 int
    283 main (int argc, char *argv[])
    284 {
    285   int remaining;
    286   int err;
    287 
    288 #ifndef NDEBUG
    289   /* Enable memory debugging.  */
    290   mtrace ();
    291 #endif
    292 
    293   /* Sanity check.  We always want to use the LFS functionality.  */
    294   if (sizeof (off_t) != sizeof (off64_t))
    295     abort ();
    296 
    297   /* We use no threads here which can interfere with handling a stream.  */
    298   __fsetlocking (stdin, FSETLOCKING_BYCALLER);
    299   __fsetlocking (stdout, FSETLOCKING_BYCALLER);
    300   __fsetlocking (stderr, FSETLOCKING_BYCALLER);
    301 
    302   /* Set locale.  */
    303   setlocale (LC_ALL, "");
    304 
    305   /* Make sure the message catalog can be found.  */
    306   bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
    307 
    308   /* Initialize the message catalog.  */
    309   textdomain (PACKAGE_TARNAME);
    310 
    311   /* Before we start tell the ELF library which version we are using.  */
    312   elf_version (EV_CURRENT);
    313 
    314   /* The user can use the LD_LIBRARY_PATH environment variable to add
    315      additional lookup directories.  */
    316   ld_library_path1 = getenv ("LD_LIBRARY_PATH");
    317 
    318   /* Initialize the memory handling.  */
    319 #define obstack_chunk_alloc xmalloc
    320 #define obstack_chunk_free free
    321   obstack_init (&ld_state.smem);
    322 
    323   /* Recognize old-style parameters for compatibility.  */
    324   replace_args (argc, argv);
    325 
    326   /* One quick pass over the parameters which allows us to scan for options
    327      with global effect which influence the rest of the processing.  */
    328   argp_parse (&argp_1st, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
    329 
    330   /* We need at least one input file.  */
    331   if (input_file_list == NULL)
    332     {
    333       error (0, 0, gettext ("At least one input file needed"));
    334       argp_help (&argp_1st, stderr, ARGP_HELP_SEE, "ld");
    335       exit (EXIT_FAILURE);
    336     }
    337 
    338   /* Determine which ELF backend to use.  */
    339   determine_output_format ();
    340 
    341   /* If no hash style was specific default to the oldand slow SysV
    342      method.  */
    343   if (unlikely (ld_state.hash_style == hash_style_none))
    344     ld_state.hash_style = hash_style_sysv;
    345 
    346   /* Prepare state.  */
    347   err = ld_prepare_state (emulation);
    348   if (err != 0)
    349     error (EXIT_FAILURE, 0, gettext ("error while preparing linking"));
    350 
    351   /* XXX Read the linker script now.  Since we later will have the linker
    352      script built in we don't go into trouble to make sure we handle GROUP
    353      statements in the script.  This simply must not happen.  */
    354   ldin = fopen (linker_script, "r");
    355   if (ldin == NULL)
    356     error (EXIT_FAILURE, errno, gettext ("cannot open linker script '%s'"),
    357 	   linker_script);
    358   /* No need for locking.  */
    359   __fsetlocking (ldin, FSETLOCKING_BYCALLER);
    360 
    361   ld_state.srcfiles = NULL;
    362   ldlineno = 1;
    363   ld_scan_version_script = 0;
    364   ldin_fname = linker_script;
    365   if (ldparse () != 0)
    366     /* Something went wrong during parsing.  */
    367     exit (EXIT_FAILURE);
    368   fclose (ldin);
    369 
    370   /* We now might have a list of directories to look for libraries in
    371      named by the linker script.  Put them in a different list so that
    372      they are searched after all paths given by the user on the
    373      command line.  */
    374   ld_state.default_paths = ld_state.paths;
    375   ld_state.paths = ld_state.tailpaths = NULL;
    376 
    377   /* Get runpath/rpath information in usable form.  */
    378   gen_rxxpath_data ();
    379 
    380   /* Parse and process arguments for real.  */
    381   argp_parse (&argp_2nd, argc, argv, ARGP_IN_ORDER, &remaining, NULL);
    382   /* All options should have been processed by the argp parser.  */
    383   assert (remaining == argc);
    384 
    385   /* Process the last file.  */
    386   while (last_file != NULL)
    387     /* Try to open the file.  */
    388     error_loading |= FILE_PROCESS (-1, last_file, &ld_state, &last_file);
    389 
    390   /* Stop if there has been a problem while reading the input files.  */
    391   if (error_loading)
    392     exit (error_loading);
    393 
    394   /* See whether all opened -( were closed.  */
    395   if (group_level > 0)
    396     {
    397       error (0, 0, gettext ("-( without matching -)"));
    398       argp_help (&argp_1st, stderr, ARGP_HELP_SEE, "ld");
    399       exit (EXIT_FAILURE);
    400     }
    401 
    402   /* When we create a relocatable file we don't have to look for the
    403      DT_NEEDED DSOs and we also don't test for undefined symbols.  */
    404   if (ld_state.file_type != relocatable_file_type)
    405     {
    406       /* At this point we have loaded all the direct dependencies.  What
    407 	 remains to be done is find the indirect dependencies.  These are
    408 	 DSOs which are referenced by the DT_NEEDED entries in the DSOs
    409 	 which are direct dependencies.  We have to transitively find and
    410 	 load all these dependencies.  */
    411       load_needed ();
    412 
    413       /* At this point all object files and DSOs are read.  If there
    414 	 are still undefined symbols left they might have to be
    415 	 synthesized from the linker script.  */
    416       create_lscript_symbols ();
    417 
    418       /* Now that we have loaded all the object files we can determine
    419 	 whether we have any non-weak unresolved references left.  If
    420 	 there are any we stop.  If the user used the '-z nodefs' option
    421 	 and we are creating a DSO don't perform the tests.  */
    422       if (FLAG_UNRESOLVED (&ld_state) != 0)
    423 	exit (1);
    424     }
    425 
    426   /* Collect information about the relocations which will be carried
    427      forward into the output.  We have to do this here and now since
    428      we need to know which sections have to be created.  */
    429   if (ld_state.file_type != relocatable_file_type)
    430     {
    431       void *p ;
    432       struct scnhead *h;
    433 
    434       p = NULL;
    435       while ((h = ld_section_tab_iterate (&ld_state.section_tab, &p)) != NULL)
    436 	if (h->type == SHT_REL || h->type == SHT_RELA)
    437 	  {
    438 	    struct scninfo *runp = h->last;
    439 	    do
    440 	      {
    441 		/* If we are processing the relocations determine how
    442 		   many will be in the output file.  Also determine
    443 		   how many GOT entries are needed.  */
    444 		COUNT_RELOCATIONS (&ld_state, runp);
    445 
    446 		ld_state.relsize_total += runp->relsize;
    447 	      }
    448 	    while ((runp = runp->next) != h->last);
    449 	  }
    450     }
    451 
    452   /* Not part of the gABI, but part of every psABI: the symbols for the
    453      GOT section.  Add the symbol if necessary.  */
    454   if (ld_state.need_got)
    455     create_special_section_symbol (&ld_state.got_symbol,
    456 				   "_GLOBAL_OFFSET_TABLE_");
    457   /* Similarly for the _DYNAMIC symbol which points to the dynamic
    458      section.  */
    459   if (dynamically_linked_p ())
    460     create_special_section_symbol (&ld_state.dyn_symbol, "_DYNAMIC");
    461 
    462   /* We are ready to start working on the output file.  Not all
    463      information has been gather or created yet.  This will be done as
    464      we go.  Open the file now.  */
    465   if (OPEN_OUTFILE (&ld_state, EM_NONE, ELFCLASSNONE, ELFDATANONE) != 0)
    466     exit (1);
    467 
    468   /* Create the sections which are generated by the linker and are not
    469      present in the input file.  The output file must already have
    470      been opened since we need the ELF descriptor to deduce type
    471      sizes.  */
    472   GENERATE_SECTIONS (&ld_state);
    473 
    474   /* At this point we have read all the files and know all the
    475      sections which have to be linked into the application.  We do now
    476      create an array listing all the sections.  We will than pass this
    477      array to a system specific function which can reorder it at will.
    478      The functions can also merge sections if this is what is
    479      wanted.  */
    480   collect_sections ();
    481 
    482   /* Create the output sections now.  This may requires sorting them
    483      first.  */
    484   CREATE_SECTIONS (&ld_state);
    485 
    486   /* Create the output file data.  Appropriate code for the selected
    487      output file type is called.  */
    488   if (CREATE_OUTFILE (&ld_state) != 0)
    489     exit (1);
    490 
    491   /* Finalize the output file, write the data out.  */
    492   err |= FINALIZE (&ld_state);
    493 
    494   /* Return with an non-zero exit status also if any error message has
    495      been printed.  */
    496   return err | (error_message_count != 0);
    497 }
    498 
    499 
    500 static void
    501 replace_args (int argc, char *argv[])
    502 {
    503   static const struct
    504   {
    505     const char *from;
    506     const char *to;
    507   } args[] =
    508       {
    509 	{ "-export-dynamic", "--export-dynamic" },
    510 	{ "-dynamic-linker", "--dynamic-linker" },
    511 	{ "-static", "--static" },
    512       };
    513   const size_t nargs = sizeof (args) / sizeof (args[0]);
    514 
    515   for (int i = 1; i < argc; ++i)
    516     if (argv[i][0] == '-' && islower (argv[i][1]) && argv[i][2] != '\0')
    517       for (size_t j = 0; j < nargs; ++j)
    518 	if (strcmp (argv[i], args[j].from) == 0)
    519 	  {
    520 	    argv[i] = (char *) args[j].to;
    521 	    break;
    522 	  }
    523 }
    524 
    525 
    526 static int
    527 valid_hexarg (const char *arg)
    528 {
    529   if (strncasecmp (arg, "0x", 2) != 0)
    530     return 0;
    531 
    532   arg += 2;
    533   do
    534     {
    535       if (isxdigit (arg[0]) && isxdigit (arg[1]))
    536 	{
    537 	  arg += 2;
    538 	  if (arg[0] == '-' || arg[0] == ':')
    539 	    ++arg;
    540 	}
    541       else
    542 	return 0;
    543     }
    544   while (*arg != '\0');
    545 
    546   return 1;
    547 }
    548 
    549 
    550 /* Quick scan of the parameter list for options with global effect.  */
    551 static error_t
    552 parse_opt_1st (int key, char *arg,
    553 	       struct argp_state *state __attribute__ ((unused)))
    554 {
    555   switch (key)
    556     {
    557     case 'B':
    558       parse_B_option (arg);
    559       break;
    560 
    561     case 'c':
    562       linker_script = arg;
    563       break;
    564 
    565     case 'E':
    566       ld_state.export_all_dynamic = true;
    567       break;
    568 
    569     case 'G':
    570       if (ld_state.file_type != no_file_type)
    571 	error (EXIT_FAILURE, 0,
    572 	       gettext ("only one option of -G and -r is allowed"));
    573       ld_state.file_type = dso_file_type;
    574 
    575       /* If we generate a DSO we have to export all symbols.  */
    576       ld_state.export_all_dynamic = true;
    577       break;
    578 
    579     case 'h':
    580       ld_state.soname = arg;
    581       break;
    582 
    583     case 'i':
    584       /* Discard the LD_LIBRARY_PATH value we found.  */
    585       ld_library_path1 = NULL;
    586       break;
    587 
    588     case 'I':
    589       ld_state.interp = arg;
    590       break;
    591 
    592     case 'm':
    593       if (emulation != NULL)
    594 	error (EXIT_FAILURE, 0, gettext ("more than one '-m' parameter"));
    595       emulation = arg;
    596       break;
    597 
    598     case 'Q':
    599       if (arg[1] == '\0' && (arg[0] == 'y' || arg[0] == 'Y'))
    600 	ld_state.add_ld_comment = true;
    601       else if (arg[1] == '\0' && (arg[0] == 'n' || arg[0] == 'N'))
    602 	ld_state.add_ld_comment = true;
    603       else
    604 	error (EXIT_FAILURE, 0, gettext ("unknown option `-%c %s'"), 'Q', arg);
    605       break;
    606 
    607     case 'r':
    608       if (ld_state.file_type != no_file_type)
    609 	error (EXIT_FAILURE, 0,
    610 	       gettext ("only one option of -G and -r is allowed"));
    611       ld_state.file_type = relocatable_file_type;
    612       break;
    613 
    614     case 'S':
    615       ld_state.strip = strip_debug;
    616       break;
    617 
    618     case 't':
    619       ld_state.trace_files = true;
    620       break;
    621 
    622     case 'v':
    623       verbose = 1;
    624       break;
    625 
    626     case 'z':
    627       /* The SysV linker used 'z' to pass various flags to the linker.
    628 	 We follow this.  See 'parse_z_option' for the options we
    629 	 recognize.  */
    630       parse_z_option (arg);
    631       break;
    632 
    633     case ARGP_pagesize:
    634       {
    635 	char *endp;
    636 	ld_state.pagesize = strtoul (arg, &endp, 0);
    637 	if (*endp != '\0')
    638 	  {
    639 	    if (endp[1] == '\0' && tolower (*endp) == 'k')
    640 	      ld_state.pagesize *= 1024;
    641 	    else if (endp[1] == '\0' && tolower (*endp) == 'm')
    642 	      ld_state.pagesize *= 1024 * 1024;
    643 	    else
    644 	      {
    645 		error (0, 0,
    646 		       gettext ("invalid page size value '%s': ignored"),
    647 		       arg);
    648 		ld_state.pagesize = 0;
    649 	      }
    650 	  }
    651       }
    652       break;
    653 
    654     case 'R':
    655       add_rxxpath (&ld_state.rpath, arg);
    656       break;
    657 
    658     case ARGP_rpath_link:
    659       add_rxxpath (&ld_state.rpath_link, arg);
    660       break;
    661 
    662     case ARGP_runpath:
    663       add_rxxpath (&ld_state.runpath, arg);
    664       break;
    665 
    666     case ARGP_runpath_link:
    667       add_rxxpath (&ld_state.runpath_link, arg);
    668       break;
    669 
    670     case ARGP_gc_sections:
    671     case ARGP_no_gc_sections:
    672       ld_state.gc_sections = key == ARGP_gc_sections;
    673       break;
    674 
    675     case ARGP_eh_frame_hdr:
    676       ld_state.eh_frame_hdr = true;
    677       break;
    678 
    679     case ARGP_hash_style:
    680       if (strcmp (arg, "gnu") == 0)
    681 	ld_state.hash_style = hash_style_gnu;
    682       else if (strcmp (arg, "both") == 0)
    683 	ld_state.hash_style = hash_style_gnu | hash_style_sysv;
    684       else if (strcmp (arg, "sysv") == 0)
    685 	ld_state.hash_style = hash_style_sysv;
    686       else
    687 	error (EXIT_FAILURE, 0, gettext ("invalid hash style '%s'"), arg);
    688       break;
    689 
    690     case ARGP_build_id:
    691       if (arg == NULL)
    692 	ld_state.build_id = "sha1";
    693       else if (strcmp (arg, "uuid") != 0
    694 	       && strcmp (arg, "md5") != 0
    695 	       && strcmp (arg, "sha1") != 0
    696 	       && !valid_hexarg (arg))
    697 	error (EXIT_FAILURE, 0, gettext ("invalid build-ID style '%s'"), arg);
    698       else
    699 	ld_state.build_id = arg;
    700       break;
    701 
    702     case 's':
    703       if (arg == NULL)
    704 	{
    705 	  if (ld_state.strip == strip_all)
    706 	    ld_state.strip = strip_everything;
    707 	  else
    708 	    ld_state.strip = strip_all;
    709 	  break;
    710 	}
    711       /* FALLTHROUGH */
    712 
    713     case 'e':
    714     case 'o':
    715     case 'O':
    716     case ARGP_whole_archive:
    717     case ARGP_no_whole_archive:
    718     case ARGP_as_needed:
    719     case ARGP_no_as_needed:
    720     case 'L':
    721     case '(':
    722     case ')':
    723     case 'l':
    724     case ARGP_static:
    725     case ARGP_dynamic:
    726     case ARGP_version_script:
    727       /* We'll handle these in the second pass.  */
    728       break;
    729 
    730     case ARGP_KEY_ARG:
    731       {
    732 	struct file_list *newp;
    733 
    734 	newp = (struct file_list *) xmalloc (sizeof (struct file_list));
    735 	newp->name = arg;
    736 #ifndef NDEBUG
    737 	newp->next = NULL;
    738 #endif
    739 	CSNGL_LIST_ADD_REAR (input_file_list, newp);
    740       }
    741       break;
    742 
    743 #if YYDEBUG
    744     case ARGP_yydebug:
    745       lddebug = 1;
    746       break;
    747 #endif
    748 
    749     case ARGP_no_undefined:
    750       ld_state.nodefs = false;
    751       break;
    752 
    753     case ARGP_conserve:
    754       conserve_memory = 1;
    755       break;
    756 
    757     default:
    758       return ARGP_ERR_UNKNOWN;
    759     }
    760   return 0;
    761 }
    762 
    763 
    764 /* Handle program arguments for real.  */
    765 static error_t
    766 parse_opt_2nd (int key, char *arg,
    767 	       struct argp_state *state __attribute__ ((unused)))
    768 {
    769   static bool group_start_requested;
    770   static bool group_end_requested;
    771 
    772   switch (key)
    773     {
    774     case 'B':
    775       parse_B_option_2 (arg);
    776       break;
    777 
    778     case 'e':
    779       ld_state.entry = arg;
    780       break;
    781 
    782     case 'o':
    783       if (ld_state.outfname != NULL)
    784 	{
    785 	  error (0, 0, gettext ("More than one output file name given."));
    786 	see_help:
    787 	  argp_help (&argp_2nd, stderr, ARGP_HELP_SEE, "ld");
    788 	  exit (EXIT_FAILURE);
    789 	}
    790       ld_state.outfname = arg;
    791       break;
    792 
    793     case 'O':
    794       if (arg == NULL)
    795 	ld_state.optlevel = 1;
    796       else
    797 	{
    798 	  char *endp;
    799 	  unsigned long int level = strtoul (arg, &endp, 10);
    800 	  if (*endp != '\0')
    801 	    {
    802 	      error (0, 0, gettext ("Invalid optimization level `%s'"), arg);
    803 	      goto see_help;
    804 	    }
    805 	  ld_state.optlevel = level;
    806 	}
    807       break;
    808 
    809     case ARGP_whole_archive:
    810       ld_state.extract_rule = allextract;
    811       break;
    812     case ARGP_no_whole_archive:
    813       ld_state.extract_rule = defaultextract;
    814       break;
    815 
    816     case ARGP_as_needed:
    817       ld_state.as_needed = true;
    818       break;
    819     case ARGP_no_as_needed:
    820       ld_state.as_needed = false;
    821       break;
    822 
    823     case ARGP_static:
    824     case ARGP_dynamic:
    825       /* Enable/disable use for DSOs.  */
    826       ld_state.statically = key == ARGP_static;
    827       break;
    828 
    829     case 'z':
    830       /* The SysV linker used 'z' to pass various flags to the linker.
    831 	 We follow this.  See 'parse_z_option' for the options we
    832 	 recognize.  */
    833       parse_z_option_2 (arg);
    834       break;
    835 
    836     case ARGP_version_script:
    837       read_version_script (arg);
    838       break;
    839 
    840     case 'L':
    841       /* Add a new search directory.  */
    842       ld_new_searchdir (arg);
    843       break;
    844 
    845     case '(':
    846       /* Start a link group.  We have to be able to determine the object
    847 	 file which is named next.  Do this by remembering a pointer to
    848 	 the pointer which will point to the next object.  */
    849       if (verbose && (group_start_requested || !group_end_requested))
    850 	error (0, 0, gettext ("nested -( -) groups are not allowed"));
    851 
    852       /* Increment the nesting level.  */
    853       ++group_level;
    854 
    855       /* Record group start.  */
    856       group_start_requested = true;
    857       group_end_requested = false;
    858       break;
    859 
    860     case ')':
    861       /* End a link group.  If there is no group open this is clearly
    862 	 a bug.  If there is a group open insert a back reference
    863 	 pointer in the record for the last object of the group.  If
    864 	 there is no new object or just one don't do anything.  */
    865       if (!group_end_requested)
    866 	{
    867 	  if (group_level == 0)
    868 	    {
    869 	      error (0, 0, gettext ("-) without matching -("));
    870 	      goto see_help;
    871 	    }
    872 	}
    873       else
    874 	last_file->group_end = true;
    875 
    876       if (group_level > 0)
    877 	--group_level;
    878       break;
    879 
    880     case 'l':
    881     case ARGP_KEY_ARG:
    882       {
    883 	while (last_file != NULL)
    884 	  /* Try to open the file.  */
    885 	  error_loading |= FILE_PROCESS (-1, last_file, &ld_state, &last_file);
    886 
    887 	last_file = ld_new_inputfile (arg,
    888 				      key == 'l'
    889 				      ? archive_file_type
    890 				      : relocatable_file_type);
    891 	if (group_start_requested)
    892 	  {
    893 	    last_file->group_start = true;
    894 
    895 	    group_start_requested = false;
    896 	    group_end_requested = true;
    897 	  }
    898       }
    899       break;
    900 
    901     default:
    902       /* We can catch all other options here.  They either have
    903 	 already been handled or, if the parameter was not correct,
    904 	 the error has been reported.  */
    905       break;
    906     }
    907   return 0;
    908 }
    909 
    910 
    911 /* Load all the DSOs named as dependencies in other DSOs we already
    912    loaded.  */
    913 static void
    914 load_needed (void)
    915 {
    916   struct usedfiles *first;
    917   struct usedfiles *runp;
    918 
    919   /* XXX There is one problem here: do we allow references from
    920      regular object files to be satisfied by these implicit
    921      dependencies?  The old linker allows this and several libraries
    922      depend on this.  Solaris' linker does not allow this; it provides
    923      the user with a comprehensive error message explaining the
    924      situation.
    925 
    926      XXX IMO the old ld behavior is correct since this is also how the
    927      dynamic linker will work.  It will look for unresolved references
    928      in all loaded DSOs.
    929 
    930      XXX Should we add an option to get Solaris compatibility?  */
    931   if (ld_state.needed == NULL)
    932     return;
    933 
    934   runp = first = ld_state.needed->next;
    935   do
    936     {
    937       struct usedfiles *ignore;
    938       struct usedfiles *next = runp->next;
    939       int err;
    940 
    941       err = FILE_PROCESS (-1, runp, &ld_state, &ignore);
    942       if (err != 0)
    943 	/* Something went wrong.  */
    944 	exit (err);
    945 
    946       runp = next;
    947     }
    948   while (runp != first);
    949 }
    950 
    951 
    952 /* Print the version information.  */
    953 static void
    954 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
    955 {
    956   fprintf (stream, "ld (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
    957   fprintf (stream, gettext ("\
    958 Copyright (C) %s Red Hat, Inc.\n\
    959 This is free software; see the source for copying conditions.  There is NO\n\
    960 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
    961 "), "2012");
    962   fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
    963 }
    964 
    965 
    966 /* There are a lot of -z options, parse them here.  Some of them have
    967    to be parsed in the first pass, others must be handled in the
    968    second pass.  */
    969 static void
    970 parse_z_option (const char *arg)
    971 {
    972   if (strcmp (arg, "nodefaultlib") == 0
    973       /* This is only meaningful if we create a DSO.  */
    974       && ld_state.file_type == dso_file_type)
    975     ld_state.dt_flags_1 |= DF_1_NODEFLIB;
    976   else if (strcmp (arg, "muldefs") == 0)
    977     ld_state.muldefs = true;
    978   else if (strcmp (arg, "nodefs") == 0)
    979     ld_state.nodefs = true;
    980   else if (strcmp (arg, "defs") == 0)
    981     ld_state.nodefs = false;
    982   else if (strcmp (arg, "now") == 0)
    983     /* We could also set the DF_1_NOW flag in DT_FLAGS_1 but this isn't
    984        necessary.  */
    985     ld_state.dt_flags |= DF_BIND_NOW;
    986   else if (strcmp (arg, "origin") == 0)
    987     /* We could also set the DF_1_ORIGIN flag in DT_FLAGS_1 but this isn't
    988        necessary.  */
    989     ld_state.dt_flags |= DF_ORIGIN;
    990   else if (strcmp (arg, "nodelete") == 0
    991 	   /* This is only meaningful if we create a DSO.  */
    992 	   && ld_state.file_type == dso_file_type)
    993     ld_state.dt_flags_1 |= DF_1_NODELETE;
    994   else if (strcmp (arg, "initfirst") == 0)
    995     ld_state.dt_flags_1 |= DF_1_INITFIRST;
    996   else if (strcmp (arg, "nodlopen") == 0
    997 	   /* This is only meaningful if we create a DSO.  */
    998 	   && ld_state.file_type == dso_file_type)
    999     ld_state.dt_flags_1 |= DF_1_NOOPEN;
   1000   else if (strcmp (arg, "systemlibrary") == 0)
   1001     ld_state.is_system_library = true;
   1002   else if (strcmp (arg, "execstack") == 0)
   1003     ld_state.execstack = execstack_true;
   1004   else if (strcmp (arg, "noexecstack") == 0)
   1005     ld_state.execstack = execstack_false_force;
   1006   else if (strcmp (arg, "allextract") != 0
   1007 	   && strcmp (arg, "defaultextract") != 0
   1008 	   && strcmp (arg, "weakextract") != 0
   1009 	   && strcmp (arg, "lazyload") != 0
   1010 	   && strcmp (arg, "nolazyload") != 0
   1011 	   && strcmp (arg, "ignore") != 0
   1012 	   && strcmp (arg, "record") != 0)
   1013     error (0, 0, gettext ("unknown option `-%c %s'"), 'z', arg);
   1014 }
   1015 
   1016 
   1017 static void
   1018 parse_z_option_2 (const char *arg)
   1019 {
   1020   if (strcmp (arg, "allextract") == 0)
   1021     ld_state.extract_rule = allextract;
   1022   else if (strcmp (arg, "defaultextract") == 0)
   1023     ld_state.extract_rule = defaultextract;
   1024   else if (strcmp (arg, "weakextract") == 0)
   1025     ld_state.extract_rule = weakextract;
   1026   else if (strcmp (arg, "lazyload") == 0)
   1027     ld_state.lazyload = true;
   1028   else if (strcmp (arg, "nolazyload") == 0)
   1029     ld_state.lazyload = false;
   1030   else if (strcmp (arg, "ignore") == 0)
   1031     ld_state.as_needed = true;
   1032   else if (strcmp (arg, "record") == 0)
   1033     ld_state.as_needed = false;
   1034 }
   1035 
   1036 
   1037 /* There are a lot of -B options, parse them here.  */
   1038 static void
   1039 parse_B_option (const char *arg)
   1040 {
   1041   if (strcmp (arg, "local") == 0)
   1042     ld_state.default_bind_local = true;
   1043   else if (strcmp (arg, "symbolic") != 0
   1044 	   && strcmp (arg, "static") != 0
   1045 	   && strcmp (arg, "dynamic") != 0)
   1046     error (0, 0, gettext ("unknown option '-%c %s'"), 'B', arg);
   1047 }
   1048 
   1049 
   1050 /* The same functionality, but called in the second pass over the
   1051    parameters.  */
   1052 static void
   1053 parse_B_option_2 (const char *arg)
   1054 {
   1055   if (strcmp (arg, "static") == 0)
   1056     ld_state.statically = true;
   1057   else if (strcmp (arg, "dynamic") == 0)
   1058     ld_state.statically = false;
   1059   else if (strcmp (arg, "symbolic") == 0
   1060 	   /* This is only meaningful if we create a DSO.  */
   1061 	   && ld_state.file_type == dso_file_type)
   1062     ld_state.dt_flags |= DF_SYMBOLIC;
   1063 }
   1064 
   1065 
   1066 static void
   1067 determine_output_format (void)
   1068 {
   1069   /* First change the 'input_file_list' variable in a simple
   1070      single-linked list.  */
   1071   struct file_list *last = input_file_list;
   1072   input_file_list = input_file_list->next;
   1073   last->next = NULL;
   1074 
   1075   /* Determine the target configuration which we are supposed to use.
   1076      The user can use the '-m' option to select one.  If this is
   1077      missing we are trying to load one file and determine the
   1078      architecture from that.  */
   1079   if (emulation != NULL)
   1080     {
   1081       ld_state.ebl = ebl_openbackend_emulation (emulation);
   1082 
   1083       assert (ld_state.ebl != NULL);
   1084     }
   1085   else
   1086     {
   1087       /* Find an ELF input file and let it determine the ELf backend.  */
   1088       struct file_list *runp = input_file_list;
   1089 
   1090       while (runp != NULL)
   1091 	{
   1092 	  int fd = open (runp->name, O_RDONLY);
   1093 	  if (fd != -1)
   1094 	    {
   1095 	      int try (Elf *elf)
   1096 		{
   1097 		  int result = 0;
   1098 
   1099 		  if (elf == NULL)
   1100 		    return 0;
   1101 
   1102 		  if (elf_kind (elf) == ELF_K_ELF)
   1103 		    {
   1104 		      /* We have an ELF file.  We now can find out
   1105 			 what the output format should be.  */
   1106 		      XElf_Ehdr_vardef(ehdr);
   1107 
   1108 		      /* Get the ELF header of the object.  */
   1109 		      xelf_getehdr (elf, ehdr);
   1110 		      if (ehdr != NULL)
   1111 			ld_state.ebl =
   1112 			  ebl_openbackend_machine (ehdr->e_machine);
   1113 
   1114 		      result = 1;
   1115 		    }
   1116 		  else if (elf_kind (elf) == ELF_K_AR)
   1117 		    {
   1118 		      /* Try the archive members.  This could
   1119 			 potentially lead to wrong results if the
   1120 			 archive contains files for more than one
   1121 			 architecture.  But this is the user's
   1122 			 problem.  */
   1123 		      Elf *subelf;
   1124 		      Elf_Cmd cmd = ELF_C_READ_MMAP;
   1125 
   1126 		      while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
   1127 			{
   1128 			  cmd = elf_next (subelf);
   1129 
   1130 			  if (try (subelf) != 0)
   1131 			    break;
   1132 			}
   1133 		    }
   1134 
   1135 		  elf_end (elf);
   1136 
   1137 		  return result;
   1138 		}
   1139 
   1140 	      if (try (elf_begin (fd, ELF_C_READ_MMAP, NULL)) != 0)
   1141 		/* Found a file.  */
   1142 		break;
   1143 	    }
   1144 
   1145 	  runp = runp->next;
   1146 	}
   1147 
   1148       if (ld_state.ebl == NULL)
   1149 	{
   1150 	  error (0, 0, gettext ("\
   1151 could not find input file to determine output file format"));
   1152 	  error (EXIT_FAILURE, 0, gettext ("\
   1153 try again with an appropriate '-m' parameter"));
   1154 	}
   1155     }
   1156 
   1157   /* We don't need the list of input files anymore.  The second run over
   1158      the parameters will handle them.  */
   1159   while (input_file_list != NULL)
   1160     {
   1161       struct file_list *oldp = input_file_list;
   1162       input_file_list = input_file_list->next;
   1163       free (oldp);
   1164     }
   1165 
   1166   /* We also know now what kind of file we are supposed to create.  If
   1167      the user hasn't selected anythign we create and executable.  */
   1168   if (ld_state.file_type == no_file_type)
   1169     ld_state.file_type = executable_file_type;
   1170 }
   1171 
   1172 /* Add DIR to the list of directories searched for object files and
   1173    libraries.  */
   1174 void
   1175 ld_new_searchdir (const char *dir)
   1176 {
   1177   struct pathelement *newpath;
   1178 
   1179   newpath = (struct pathelement *)
   1180     obstack_calloc (&ld_state.smem, sizeof (struct pathelement));
   1181 
   1182   newpath->pname = dir;
   1183 
   1184   /* Enqueue the file.  */
   1185   if (ld_state.tailpaths == NULL)
   1186     ld_state.paths = ld_state.tailpaths = newpath->next = newpath;
   1187   else
   1188     {
   1189       ld_state.tailpaths->next = newpath;
   1190       ld_state.tailpaths = newpath;
   1191       newpath->next = ld_state.paths;
   1192     }
   1193 }
   1194 
   1195 
   1196 struct usedfiles *
   1197 ld_new_inputfile (const char *fname, enum file_type type)
   1198 {
   1199   struct usedfiles *newfile = (struct usedfiles *)
   1200     obstack_calloc (&ld_state.smem, sizeof (struct usedfiles));
   1201 
   1202   newfile->soname = newfile->fname = newfile->rfname = fname;
   1203   newfile->file_type = type;
   1204   newfile->extract_rule = ld_state.extract_rule;
   1205   newfile->as_needed = ld_state.as_needed;
   1206   newfile->lazyload = ld_state.lazyload;
   1207   newfile->status = not_opened;
   1208 
   1209   return newfile;
   1210 }
   1211 
   1212 
   1213 /* Create an array listing all the sections.  We will than pass this
   1214    array to a system specific function which can reorder it at will.
   1215    The functions can also merge sections if this is what is
   1216    wanted.  */
   1217 static void
   1218 collect_sections (void)
   1219 {
   1220   void *p ;
   1221   struct scnhead *h;
   1222   size_t cnt;
   1223 
   1224   /* We have that many sections.  At least for now.  */
   1225   ld_state.nallsections = ld_state.section_tab.filled;
   1226 
   1227   /* Allocate the array.  We allocate one more entry than computed so
   1228      far since we might need a new section for the copy relocations.  */
   1229   ld_state.allsections =
   1230     (struct scnhead **) obstack_alloc (&ld_state.smem,
   1231 				       (ld_state.nallsections + 1)
   1232 				       * sizeof (struct scnhead *));
   1233 
   1234   /* Fill the array.  We rely here on the hash table iterator to
   1235      return the entries in the order they were added.  */
   1236   cnt = 0;
   1237   p = NULL;
   1238   while ((h = ld_section_tab_iterate (&ld_state.section_tab, &p)) != NULL)
   1239     {
   1240       struct scninfo *runp;
   1241       bool used = false;
   1242 
   1243       if (h->kind == scn_normal)
   1244 	{
   1245 	  runp = h->last;
   1246 	  do
   1247 	    {
   1248 	      if (h->type == SHT_REL || h->type == SHT_RELA)
   1249 		{
   1250 		  if (runp->used)
   1251 		    /* This is a relocation section.  If the section
   1252 		       it is relocating is used in the result so must
   1253 		       the relocation section.  */
   1254 		    runp->used
   1255 		      = runp->fileinfo->scninfo[SCNINFO_SHDR (runp->shdr).sh_info].used;
   1256 		}
   1257 
   1258 	      /* Accumulate the result.  */
   1259 	      used |= runp->used;
   1260 
   1261 	      /* Next input section.  */
   1262 	      runp = runp->next;
   1263 	    }
   1264 	  while (runp != h->last);
   1265 
   1266 	  h->used = used;
   1267 	}
   1268 
   1269       ld_state.allsections[cnt++] = h;
   1270     }
   1271   ld_state.nusedsections = cnt;
   1272 
   1273   assert (cnt == ld_state.nallsections);
   1274 }
   1275 
   1276 
   1277 /* Add given path to the end of list.  */
   1278 static void
   1279 add_rxxpath (struct pathelement **pathp, const char *str)
   1280 {
   1281   struct pathelement *newp;
   1282 
   1283   /* The path elements can in theory be freed after we read all the
   1284      files.  But the amount of memory we are talking about is small
   1285      and the cost of free() calls is not neglectable.  */
   1286   newp = (struct pathelement *) obstack_alloc (&ld_state.smem, sizeof (*newp));
   1287   newp->pname = str;
   1288   newp->exist = 0;
   1289 #ifndef NDEBUG
   1290   newp->next = NULL;
   1291 #endif
   1292 
   1293   CSNGL_LIST_ADD_REAR (*pathp, newp);
   1294 }
   1295 
   1296 
   1297 /* Convert lists of possibly colon-separated directory lists into lists
   1298    where each entry is for a single directory.  */
   1299 static void
   1300 normalize_dirlist (struct pathelement **pathp)
   1301 {
   1302   struct pathelement *firstp = *pathp;
   1303 
   1304   do
   1305     {
   1306       const char *pname = (*pathp)->pname;
   1307       const char *colonp = strchrnul (pname, ':');
   1308 
   1309       if (colonp != NULL)
   1310 	{
   1311 	  struct pathelement *lastp = *pathp;
   1312 	  struct pathelement *newp;
   1313 
   1314 	  while (1)
   1315 	    {
   1316 	      if (colonp == pname)
   1317 		lastp->pname = ".";
   1318 	      else
   1319 		lastp->pname = obstack_strndup (&ld_state.smem, pname,
   1320 						colonp - pname);
   1321 
   1322 	      if (*colonp == '\0')
   1323 		break;
   1324 	      pname = colonp + 1;
   1325 
   1326 	      newp = (struct pathelement *) obstack_alloc (&ld_state.smem,
   1327 							   sizeof (*newp));
   1328 	      newp->next = lastp->next;
   1329 	      newp->exist = 0;
   1330 	      lastp = lastp->next = newp;
   1331 
   1332 	      colonp = strchrnul (pname, ':');
   1333 	    }
   1334 
   1335 	  pathp = &lastp->next;
   1336 	}
   1337       else
   1338 	pathp = &(*pathp)->next;
   1339     }
   1340   while (*pathp != firstp);
   1341 }
   1342 
   1343 
   1344 /* Called after all parameters are parsed to bring the runpath/rpath
   1345    information into a usable form.  */
   1346 static void
   1347 gen_rxxpath_data (void)
   1348 {
   1349   char *ld_library_path2;
   1350 
   1351   /* Convert the information in true single-linked lists for easy use.
   1352      At this point we also discard the rpath information if runpath
   1353      information is provided.  rpath is deprecated and should not be
   1354      used (or ever be invented for that matter).  */
   1355   if (ld_state.rpath != NULL)
   1356     {
   1357       struct pathelement *endp = ld_state.rpath;
   1358       ld_state.rpath = ld_state.rpath->next;
   1359       endp->next = NULL;
   1360     }
   1361   if (ld_state.rpath_link != NULL)
   1362     {
   1363       struct pathelement *endp = ld_state.rpath_link;
   1364       ld_state.rpath_link = ld_state.rpath_link->next;
   1365       endp->next = NULL;
   1366     }
   1367 
   1368   if (ld_state.runpath != NULL)
   1369     {
   1370       struct pathelement *endp = ld_state.runpath;
   1371       ld_state.runpath = ld_state.runpath->next;
   1372       endp->next = NULL;
   1373 
   1374       /* If rpath information is also available discard it.
   1375 	 XXX Should there be a possibility to avoid this?  */
   1376       while (ld_state.rpath != NULL)
   1377 	{
   1378 	  struct pathelement *old = ld_state.rpath;
   1379 	  ld_state.rpath = ld_state.rpath->next;
   1380 	  free (old);
   1381 	}
   1382     }
   1383   if (ld_state.runpath_link != NULL)
   1384     {
   1385       struct pathelement *endp = ld_state.runpath_link;
   1386       ld_state.runpath_link = ld_state.runpath_link->next;
   1387       endp->next = NULL;
   1388 
   1389       /* If rpath information is also available discard it.
   1390 	 XXX Should there be a possibility to avoid this?  */
   1391       while (ld_state.rpath_link != NULL)
   1392 	{
   1393 	  struct pathelement *old = ld_state.rpath_link;
   1394 	  ld_state.rpath_link = ld_state.rpath_link->next;
   1395 	  free (old);
   1396 	}
   1397 
   1398       /* The information in the strings in the list can actually be
   1399 	 directory lists themselves, with entries separated by colons.
   1400 	 Convert the list now to a list with one list entry for each
   1401 	 directory.  */
   1402       normalize_dirlist (&ld_state.runpath_link);
   1403     }
   1404   else if (ld_state.rpath_link != NULL)
   1405     /* Same as for the runpath_link above.  */
   1406     normalize_dirlist (&ld_state.rpath_link);
   1407 
   1408 
   1409   /* As a related task, handle the LD_LIBRARY_PATH value here.  First
   1410      we have to possibly split the value found (if it contains a
   1411      semicolon).  Then we have to split the value in list of
   1412      directories, i.e., split at the colons.  */
   1413   if (ld_library_path1 != NULL)
   1414     {
   1415       ld_library_path2 = strchr (ld_library_path1, ';');
   1416       if (ld_library_path2 == NULL)
   1417 	{
   1418 	  /* If no semicolon is present the directories are looked at
   1419 	     after the -L parameters (-> ld_library_path2).  */
   1420 	  ld_library_path2 = ld_library_path1;
   1421 	  ld_library_path1 = NULL;
   1422 	}
   1423       else
   1424 	{
   1425 	  /* NUL terminate the first part.  */
   1426 	  *ld_library_path2++ = '\0';
   1427 
   1428 	  /* Convert the string value in a list.  */
   1429 	  add_rxxpath (&ld_state.ld_library_path1, ld_library_path1);
   1430 	  normalize_dirlist (&ld_state.ld_library_path1);
   1431 	}
   1432 
   1433       add_rxxpath (&ld_state.ld_library_path2, ld_library_path2);
   1434       normalize_dirlist (&ld_state.ld_library_path2);
   1435     }
   1436 }
   1437 
   1438 
   1439 static void
   1440 read_version_script (const char *fname)
   1441 {
   1442   /* Open the file.  The name is supposed to be the complete (relative
   1443      or absolute) path.  No search along a path will be performed.  */
   1444   ldin = fopen (fname, "r");
   1445   if (ldin == NULL)
   1446     error (EXIT_FAILURE, errno, gettext ("cannot read version script '%s'"),
   1447 	   fname);
   1448   /* No need for locking.  */
   1449   __fsetlocking (ldin, FSETLOCKING_BYCALLER);
   1450 
   1451   /* Tell the parser that this is a version script.  */
   1452   ld_scan_version_script = 1;
   1453 
   1454   ldlineno = 1;
   1455   ldin_fname = fname;
   1456   if (ldparse () != 0)
   1457     /* Something went wrong during parsing.  */
   1458     exit (EXIT_FAILURE);
   1459 
   1460   fclose (ldin);
   1461 }
   1462 
   1463 
   1464 static void
   1465 create_lscript_symbols (void)
   1466 {
   1467   /* Walk through the data from the linker script and generate all the
   1468      symbols which are required to be present and those marked
   1469      with PROVIDE if there is a undefined reference.  */
   1470   if (ld_state.output_segments == NULL)
   1471     return;
   1472 
   1473   struct output_segment *segment = ld_state.output_segments->next;
   1474   do
   1475     {
   1476       struct output_rule *orule;
   1477 
   1478       for (orule = segment->output_rules; orule != NULL; orule = orule->next)
   1479 	if (orule->tag == output_assignment
   1480 	    /* The assignments to "." (i.e., the PC) have to be
   1481 	       ignored here.  */
   1482 	    && strcmp (orule->val.assignment->variable, ".") != 0)
   1483 	  {
   1484 	    struct symbol *s = ld_state.unresolved;
   1485 
   1486 	    /* Check whether the symbol is needed.  */
   1487 	    if (likely (s != NULL))
   1488 	      {
   1489 		struct symbol *first = s;
   1490 		const char *providename = orule->val.assignment->variable;
   1491 
   1492 		/* Determine whether the provided symbol is still
   1493 		   undefined.  */
   1494 		// XXX TODO Loop inside a loop.  Gag!  Must rewrite.  */
   1495 		do
   1496 		  if (strcmp (s->name, providename) == 0)
   1497 		    {
   1498 		      /* Not defined but referenced.  */
   1499 		      if (unlikely (!s->defined))
   1500 			{
   1501 			  /* Put on the list of symbols.  First remove it from
   1502 			     whatever list it currently is on.  */
   1503 			  CDBL_LIST_DEL (ld_state.unresolved, s);
   1504 			  --ld_state.nunresolved;
   1505 			  goto use_it;
   1506 			}
   1507 
   1508 		      if (unlikely (!orule->val.assignment->provide_flag))
   1509 			{
   1510 			  /* The symbol is already defined and now again
   1511 			     in the linker script.  This is an error.  */
   1512 			  error (0, 0, gettext ("\
   1513 duplicate definition of '%s' in linker script"),
   1514 				 providename);
   1515 			  goto next_rule;
   1516 			}
   1517 		    }
   1518 		while ((s = s->next) != first);
   1519 	      }
   1520 
   1521 	    /* If the symbol only has to be provided if it is needed,
   1522 	       ignore it here since it is not undefined.  */
   1523 	    if (orule->val.assignment->provide_flag)
   1524 	      continue;
   1525 
   1526 	    /* Allocate memory for this new symbol.  */
   1527 	    s = (struct symbol *)
   1528 	      obstack_calloc (&ld_state.smem, sizeof (struct symbol));
   1529 
   1530 	    /* Initialize it.  */
   1531 	    s->name = orule->val.assignment->variable;
   1532 
   1533 	    /* Insert it into the symbol hash table.  */
   1534 	    unsigned long int hval = elf_hash (s->name);
   1535 	    if (unlikely (ld_symbol_tab_insert (&ld_state.symbol_tab,
   1536 						hval, s) != 0))
   1537 	      {
   1538 		/* This means the symbol is defined somewhere else.
   1539 		   Maybe it comes from a DSO or so.  Get the
   1540 		   definition.  */
   1541 		free (s);
   1542 		struct symbol *old = ld_symbol_tab_find (&ld_state.symbol_tab,
   1543 							 hval, s);
   1544 		assert (old != NULL);
   1545 		free (s);
   1546 
   1547 		/* If this is a definition from the application itself
   1548 		   this means a duplicate definition.  */
   1549 		if (! old->in_dso)
   1550 		  {
   1551 		    error (0, 0, gettext ("\
   1552 duplicate definition of '%s' in linker script"),
   1553 			   s->name);
   1554 		    goto next_rule;
   1555 		  }
   1556 
   1557 		/* We use the definition from the linker script.  */
   1558 		s = old;
   1559 	      }
   1560 
   1561 	  use_it:
   1562 	    /* The symbol is (now) defined.  */
   1563 	    s->defined = 1;
   1564 	    s->type = STT_NOTYPE;
   1565 
   1566 	    /* Add a reference to the symbol record.  We will come
   1567 	       across it when creating the output file.  */
   1568 	    orule->val.assignment->sym = s;
   1569 
   1570 	    SNGL_LIST_PUSH (ld_state.lscript_syms, s);
   1571 	    ++ld_state.nlscript_syms;
   1572 
   1573 	  next_rule:
   1574 	    ;
   1575 	  }
   1576 
   1577       segment = segment->next;
   1578     }
   1579   while (segment != ld_state.output_segments->next);
   1580 }
   1581 
   1582 
   1583 /* Create creation of spection section symbols representing sections in the
   1584    output file.  This is done for symbols like _GLOBAL_OFFSET_TABLE_ and
   1585    _DYNAMIC.  */
   1586 static void
   1587 create_special_section_symbol (struct symbol **symp, const char *name)
   1588 {
   1589   if (*symp == NULL)
   1590     {
   1591       /* No symbol defined found yet.  Create one.  */
   1592       struct symbol *newsym = (struct symbol *)
   1593 	obstack_calloc (&ld_state.smem, sizeof (*newsym));
   1594 
   1595       newsym->name = name;
   1596       // XXX Should we mark the symbol hidden?  They are hardly useful
   1597       // used outside the current object.
   1598 
   1599       /* Add to the symbol table.  */
   1600       if (unlikely (ld_symbol_tab_insert (&ld_state.symbol_tab,
   1601 					  elf_hash (name), newsym) != 0))
   1602 	abort ();
   1603 
   1604       *symp = newsym;
   1605     }
   1606   else if ((*symp)->defined)
   1607     /* Cannot happen.  We do use this symbol from any input file.  */
   1608     abort ();
   1609 
   1610   (*symp)->defined = 1;
   1611   (*symp)->local = 1;
   1612   (*symp)->hidden = 1;
   1613   (*symp)->type = STT_OBJECT;
   1614 
   1615   ++ld_state.nsymtab;
   1616 }
   1617 
   1618 
   1619 #include "debugpred.h"
   1620