src/ld.c

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