src/ld.c

   1 /* Copyright (C) 2001-2010, 2012 Red Hat, Inc.
   2    This file is part of Red Hat elfutils.
   3    Written by Ulrich Drepper <drepper@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"