gold/options.cc

   1 // options.c -- handle command line options for gold
   2
   3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #include "gold.h"
  24
  25 #include <cerrno>
  26 #include <cstdlib>
  27 #include <cstring>
  28 #include <fstream>
  29 #include <vector>
  30 #include <iostream>
  31 #include <sys/stat.h>
  32 #include "filenames.h"
  33 #include "libiberty.h"
  34 #include "demangle.h"
  35 #include "../bfd/bfdver.h"
  36
  37 #include "debug.h"
  38 #include "script.h"
  39 #include "target-select.h"
  40 #include "options.h"
  41 #include "plugin.h"
  42
  43 namespace gold
  44 {
  45
  46 General_options
  47 Position_dependent_options::default_options_;
  48
  49 namespace options
  50 {
  51
  52 // This flag is TRUE if we should register the command-line options as they
  53 // are constructed.  It is set after construction of the options within
  54 // class Position_dependent_options.
  55 static bool ready_to_register = false;
  56
  57 // This global variable is set up as General_options is constructed.
  58 static std::vector<const One_option*> registered_options;
  59
  60 // These are set up at the same time -- the variables that accept one
  61 // dash, two, or require -z.  A single variable may be in more than
  62 // one of these data structures.
  63 typedef Unordered_map<std::string, One_option*> Option_map;
  64 static Option_map* long_options = NULL;
  65 static One_option* short_options[128];
  66
  67 void
  68 One_option::register_option()
  69 {
  70   if (!ready_to_register)
  71     return;
  72
  73   registered_options.push_back(this);
  74
  75   // We can't make long_options a static Option_map because we can't
  76   // guarantee that will be initialized before register_option() is
  77   // first called.
  78   if (long_options == NULL)
  79     long_options = new Option_map;
  80
  81   // TWO_DASHES means that two dashes are preferred, but one is ok too.
  82   if (!this->longname.empty())
  83     (*long_options)[this->longname] = this;
  84
  85   const int shortname_as_int = static_cast<int>(this->shortname);
  86   gold_assert(shortname_as_int >= 0 && shortname_as_int < 128);
  87   if (this->shortname != '\0')
  88     {
  89       gold_assert(short_options[shortname_as_int] == NULL);
  90       short_options[shortname_as_int] = this;
  91     }
  92 }
  93
  94 void
  95 One_option::print() const
  96 {
  97   bool comma = false;
  98   printf("  ");
  99   int len = 2;
 100   if (this->shortname != '\0')
 101     {
 102       len += printf("-%c", this->shortname);
 103       if (this->helparg)
 104         {
 105           // -z takes long-names only.
 106           gold_assert(this->dashes != DASH_Z);
 107           len += printf(" %s", gettext(this->helparg));
 108         }
 109       comma = true;
 110     }
 111   if (!this->longname.empty()
 112       && !(this->longname[0] == this->shortname
 113            && this->longname[1] == '\0'))
 114     {
 115       if (comma)
 116         len += printf(", ");
 117       switch (this->dashes)
 118         {
 119         case options::ONE_DASH: case options::EXACTLY_ONE_DASH:
 120           len += printf("-");
 121           break;
 122         case options::TWO_DASHES: case options::EXACTLY_TWO_DASHES:
 123           len += printf("--");
 124           break;
 125         case options::DASH_Z:
 126           len += printf("-z ");
 127           break;
 128         default:
 129           gold_unreachable();
 130         }
 131       len += printf("%s", this->longname.c_str());
 132       if (this->helparg)
 133         {
 134           // For most options, we print "--frob FOO".  But for -z
 135           // we print "-z frob=FOO".
 136           len += printf("%c%s", this->dashes == options::DASH_Z ? '=' : ' ',
 137                         gettext(this->helparg));
 138         }
 139     }
 140
 141   if (len >= 30)
 142     {
 143       printf("\n");
 144       len = 0;
 145     }
 146   for (; len < 30; ++len)
 147     std::putchar(' ');
 148
 149   // TODO: if we're boolean, add " (default)" when appropriate.
 150   printf("%s\n", gettext(this->helpstring));
 151 }
 152
 153 void
 154 help()
 155 {
 156   printf(_("Usage: %s [options] file...\nOptions:\n"), gold::program_name);
 157
 158   std::vector<const One_option*>::const_iterator it;
 159   for (it = registered_options.begin(); it != registered_options.end(); ++it)
 160     (*it)->print();
 161
 162   // config.guess and libtool.m4 look in ld --help output for the
 163   // string "supported targets".
 164   printf(_("%s: supported targets:"), gold::program_name);
 165   std::vector<const char*> supported_names;
 166   gold::supported_target_names(&supported_names);
 167   for (std::vector<const char*>::const_iterator p = supported_names.begin();
 168        p != supported_names.end();
 169        ++p)
 170     printf(" %s", *p);
 171   printf("\n");
 172
 173   printf(_("%s: supported emulations:"), gold::program_name);
 174   supported_names.clear();
 175   gold::supported_emulation_names(&supported_names);
 176   for (std::vector<const char*>::const_iterator p = supported_names.begin();
 177        p != supported_names.end();
 178        ++p)
 179     printf(" %s", *p);
 180   printf("\n");
 181
 182   // REPORT_BUGS_TO is defined in bfd/bfdver.h.
 183   const char* report = REPORT_BUGS_TO;
 184   if (*report != '\0')
 185     printf(_("Report bugs to %s\n"), report);
 186 }
 187
 188 // For bool, arg will be NULL (boolean options take no argument);
 189 // we always just set to true.
 190 void
 191 parse_bool(const char*, const char*, bool* retval)
 192 {
 193   *retval = true;
 194 }
 195
 196 void
 197 parse_uint(const char* option_name, const char* arg, int* retval)
 198 {
 199   char* endptr;
 200   *retval = strtol(arg, &endptr, 0);
 201   if (*endptr != '\0' || retval < 0)
 202     gold_fatal(_("%s: invalid option value (expected an integer): %s"),
 203                option_name, arg);
 204 }
 205
 206 void
 207 parse_int(const char* option_name, const char* arg, int* retval)
 208 {
 209   char* endptr;
 210   *retval = strtol(arg, &endptr, 0);
 211   if (*endptr != '\0')
 212     gold_fatal(_("%s: invalid option value (expected an integer): %s"),
 213                option_name, arg);
 214 }
 215
 216 void
 217 parse_uint64(const char* option_name, const char* arg, uint64_t* retval)
 218 {
 219   char* endptr;
 220   *retval = strtoull(arg, &endptr, 0);
 221   if (*endptr != '\0')
 222     gold_fatal(_("%s: invalid option value (expected an integer): %s"),
 223                option_name, arg);
 224 }
 225
 226 void
 227 parse_double(const char* option_name, const char* arg, double* retval)
 228 {
 229   char* endptr;
 230   *retval = strtod(arg, &endptr);
 231   if (*endptr != '\0')
 232     gold_fatal(_("%s: invalid option value "
 233                  "(expected a floating point number): %s"),
 234                option_name, arg);
 235 }
 236
 237 void
 238 parse_string(const char* option_name, const char* arg, const char** retval)
 239 {
 240   if (*arg == '\0')
 241     gold_fatal(_("%s: must take a non-empty argument"), option_name);
 242   *retval = arg;
 243 }
 244
 245 void
 246 parse_optional_string(const char*, const char* arg, const char** retval)
 247 {
 248   *retval = arg;
 249 }
 250
 251 void
 252 parse_dirlist(const char*, const char* arg, Dir_list* retval)
 253 {
 254   retval->push_back(Search_directory(arg, false));
 255 }
 256
 257 void
 258 parse_set(const char*, const char* arg, String_set* retval)
 259 {
 260   retval->insert(std::string(arg));
 261 }
 262
 263 void
 264 parse_choices(const char* option_name, const char* arg, const char** retval,
 265               const char* choices[], int num_choices)
 266 {
 267   for (int i = 0; i < num_choices; i++)
 268     if (strcmp(choices[i], arg) == 0)
 269       {
 270         *retval = arg;
 271         return;
 272       }
 273
 274   // If we get here, the user did not enter a valid choice, so we die.
 275   std::string choices_list;
 276   for (int i = 0; i < num_choices; i++)
 277     {
 278       choices_list += choices[i];
 279       if (i != num_choices - 1)
 280         choices_list += ", ";
 281     }
 282   gold_fatal(_("%s: must take one of the following arguments: %s"),
 283              option_name, choices_list.c_str());
 284 }
 285
 286 } // End namespace options.
 287
 288 // Define the handler for "special" options (set via DEFINE_special).
 289
 290 void
 291 General_options::parse_help(const char*, const char*, Command_line*)
 292 {
 293   options::help();
 294   ::exit(EXIT_SUCCESS);
 295 }
 296
 297 void
 298 General_options::parse_version(const char* opt, const char*, Command_line*)
 299 {
 300   bool print_short = (opt[0] == '-' && opt[1] == 'v');
 301   gold::print_version(print_short);
 302   this->printed_version_ = true;
 303   if (!print_short)
 304     ::exit(EXIT_SUCCESS);
 305 }
 306
 307 void
 308 General_options::parse_V(const char*, const char*, Command_line*)
 309 {
 310   gold::print_version(true);
 311   this->printed_version_ = true;
 312
 313   printf(_("  Supported targets:\n"));
 314   std::vector<const char*> supported_names;
 315   gold::supported_target_names(&supported_names);
 316   for (std::vector<const char*>::const_iterator p = supported_names.begin();
 317        p != supported_names.end();
 318        ++p)
 319     printf("   %s\n", *p);
 320
 321   printf(_("  Supported emulations:\n"));
 322   supported_names.clear();
 323   gold::supported_emulation_names(&supported_names);
 324   for (std::vector<const char*>::const_iterator p = supported_names.begin();
 325        p != supported_names.end();
 326        ++p)
 327     printf("   %s\n", *p);
 328 }
 329
 330 void
 331 General_options::parse_defsym(const char*, const char* arg,
 332                               Command_line* cmdline)
 333 {
 334   cmdline->script_options().define_symbol(arg);
 335 }
 336
 337 void
 338 General_options::parse_incremental(const char*, const char*,
 339                                    Command_line*)
 340 {
 341   this->incremental_mode_ = INCREMENTAL_AUTO;
 342 }
 343
 344 void
 345 General_options::parse_no_incremental(const char*, const char*,
 346                                       Command_line*)
 347 {
 348   this->incremental_mode_ = INCREMENTAL_OFF;
 349 }
 350
 351 void
 352 General_options::parse_incremental_full(const char*, const char*,
 353                                         Command_line*)
 354 {
 355   this->incremental_mode_ = INCREMENTAL_FULL;
 356 }
 357
 358 void
 359 General_options::parse_incremental_update(const char*, const char*,
 360                                           Command_line*)
 361 {
 362   this->incremental_mode_ = INCREMENTAL_UPDATE;
 363 }
 364
 365 void
 366 General_options::parse_incremental_changed(const char*, const char*,
 367                                            Command_line*)
 368 {
 369   this->implicit_incremental_ = true;
 370   this->incremental_disposition_ = INCREMENTAL_CHANGED;
 371 }
 372
 373 void
 374 General_options::parse_incremental_unchanged(const char*, const char*,
 375                                              Command_line*)
 376 {
 377   this->implicit_incremental_ = true;
 378   this->incremental_disposition_ = INCREMENTAL_UNCHANGED;
 379 }
 380
 381 void
 382 General_options::parse_incremental_unknown(const char*, const char*,
 383                                            Command_line*)
 384 {
 385   this->implicit_incremental_ = true;
 386   this->incremental_disposition_ = INCREMENTAL_CHECK;
 387 }
 388
 389 void
 390 General_options::parse_library(const char*, const char* arg,
 391                                Command_line* cmdline)
 392 {
 393   Input_file_argument::Input_file_type type;
 394   const char* name;
 395   if (arg[0] == ':')
 396     {
 397       type = Input_file_argument::INPUT_FILE_TYPE_SEARCHED_FILE;
 398       name = arg + 1;
 399     }
 400   else
 401     {
 402       type = Input_file_argument::INPUT_FILE_TYPE_LIBRARY;
 403       name = arg;
 404     }
 405   Input_file_argument file(name, type, "", false, *this);
 406   cmdline->inputs().add_file(file);
 407 }
 408
 409 #ifdef ENABLE_PLUGINS
 410 void
 411 General_options::parse_plugin(const char*, const char* arg,
 412                               Command_line*)
 413 {
 414   this->add_plugin(arg);
 415 }
 416
 417 // Parse --plugin-opt.
 418
 419 void
 420 General_options::parse_plugin_opt(const char*, const char* arg,
 421                                   Command_line*)
 422 {
 423   this->add_plugin_option(arg);
 424 }
 425 #endif // ENABLE_PLUGINS
 426
 427 void
 428 General_options::parse_R(const char* option, const char* arg,
 429                          Command_line* cmdline)
 430 {
 431   struct stat s;
 432   if (::stat(arg, &s) != 0 || S_ISDIR(s.st_mode))
 433     this->add_to_rpath(arg);
 434   else
 435     this->parse_just_symbols(option, arg, cmdline);
 436 }
 437
 438 void
 439 General_options::parse_just_symbols(const char*, const char* arg,
 440                                     Command_line* cmdline)
 441 {
 442   Input_file_argument file(arg, Input_file_argument::INPUT_FILE_TYPE_FILE,
 443                            "", true, *this);
 444   cmdline->inputs().add_file(file);
 445 }
 446
 447 // Handle --section-start.
 448
 449 void
 450 General_options::parse_section_start(const char*, const char* arg,
 451                                      Command_line*)
 452 {
 453   const char* eq = strchr(arg, '=');
 454   if (eq == NULL)
 455     {
 456       gold_error(_("invalid argument to --section-start; "
 457                    "must be SECTION=ADDRESS"));
 458       return;
 459     }
 460
 461   std::string section_name(arg, eq - arg);
 462
 463   ++eq;
 464   const char* val_start = eq;
 465   if (eq[0] == '0' && (eq[1] == 'x' || eq[1] == 'X'))
 466     eq += 2;
 467   if (*eq == '\0')
 468     {
 469       gold_error(_("--section-start address missing"));
 470       return;
 471     }
 472   uint64_t addr = 0;
 473   hex_init();
 474   for (; *eq != '\0'; ++eq)
 475     {
 476       if (!hex_p(*eq))
 477         {
 478           gold_error(_("--section-start argument %s is not a valid hex number"),
 479                      val_start);
 480           return;
 481         }
 482       addr <<= 4;
 483       addr += hex_value(*eq);
 484     }
 485
 486   this->section_starts_[section_name] = addr;
 487 }
 488
 489 // Look up a --section-start value.
 490
 491 bool
 492 General_options::section_start(const char* secname, uint64_t* paddr) const
 493 {
 494   if (this->section_starts_.empty())
 495     return false;
 496   std::map<std::string, uint64_t>::const_iterator p =
 497     this->section_starts_.find(secname);
 498   if (p == this->section_starts_.end())
 499     return false;
 500   *paddr = p->second;
 501   return true;
 502 }
 503
 504 void
 505 General_options::parse_static(const char*, const char*, Command_line*)
 506 {
 507   this->set_static(true);
 508 }
 509
 510 void
 511 General_options::parse_script(const char*, const char* arg,
 512                               Command_line* cmdline)
 513 {
 514   if (!read_commandline_script(arg, cmdline))
 515     gold::gold_fatal(_("unable to parse script file %s"), arg);
 516 }
 517
 518 void
 519 General_options::parse_version_script(const char*, const char* arg,
 520                                       Command_line* cmdline)
 521 {
 522   if (!read_version_script(arg, cmdline))
 523     gold::gold_fatal(_("unable to parse version script file %s"), arg);
 524 }
 525
 526 void
 527 General_options::parse_dynamic_list(const char*, const char* arg,
 528                                     Command_line* cmdline)
 529 {
 530   if (!read_dynamic_list(arg, cmdline, &this->dynamic_list_))
 531     gold::gold_fatal(_("unable to parse dynamic-list script file %s"), arg);
 532 }
 533
 534 void
 535 General_options::parse_start_group(const char*, const char*,
 536                                    Command_line* cmdline)
 537 {
 538   cmdline->inputs().start_group();
 539 }
 540
 541 void
 542 General_options::parse_end_group(const char*, const char*,
 543                                  Command_line* cmdline)
 544 {
 545   cmdline->inputs().end_group();
 546 }
 547
 548 void
 549 General_options::parse_start_lib(const char*, const char*,
 550                                  Command_line* cmdline)
 551 {
 552   cmdline->inputs().start_lib(cmdline->position_dependent_options());
 553 }
 554
 555 void
 556 General_options::parse_end_lib(const char*, const char*,
 557                                Command_line* cmdline)
 558 {
 559   cmdline->inputs().end_lib();
 560 }
 561
 562 // The function add_excluded_libs() in ld/ldlang.c of GNU ld breaks up a list
 563 // of names separated by commas or colons and puts them in a linked list.
 564 // We implement the same parsing of names here but store names in an unordered
 565 // map to speed up searching of names.
 566
 567 void
 568 General_options::parse_exclude_libs(const char*, const char* arg,
 569                                     Command_line*)
 570 {
 571   const char* p = arg;
 572
 573   while (*p != '\0')
 574     {
 575       size_t length = strcspn(p, ",:");
 576       this->excluded_libs_.insert(std::string(p, length));
 577       p += (p[length] ? length + 1 : length);
 578     }
 579 }
 580
 581 // The checking logic is based on the function check_excluded_libs() in
 582 // ld/ldlang.c of GNU ld but our implementation is different because we use
 583 // an unordered map instead of a linked list, which is what GNU ld uses.  GNU
 584 // ld searches sequentially in the excluded libs list.  For a given archive,
 585 // a match is found if the archive's name matches exactly one of the list
 586 // entry or if the archive's name is of the form FOO.a and FOO matches exactly
 587 // one of the list entry.  An entry "ALL" in the list is considered as a
 588 // wild-card and matches any given name.
 589
 590 bool
 591 General_options::check_excluded_libs(const std::string &name) const
 592 {
 593   Unordered_set<std::string>::const_iterator p;
 594
 595   // Exit early for the most common case.
 596   if (excluded_libs_.empty())
 597     return false;
 598
 599   // If we see "ALL", all archives are excluded from automatic export.
 600   p = excluded_libs_.find(std::string("ALL"));
 601   if (p != excluded_libs_.end())
 602     return true;
 603
 604   // First strip off any directories in name.
 605   const char* basename = lbasename(name.c_str());
 606
 607   // Try finding an exact match.
 608   p = excluded_libs_.find(std::string(basename));
 609   if (p != excluded_libs_.end())
 610     return true;
 611
 612   // Try matching NAME without ".a" at the end.
 613   size_t length = strlen(basename);
 614   if ((length >= 2)
 615       && (basename[length - 2] == '.')
 616       && (basename[length - 1] == 'a'))
 617     {
 618       p = excluded_libs_.find(std::string(basename, length - 2));
 619       if (p != excluded_libs_.end())
 620         return true;
 621     }
 622
 623   return false;
 624 }
 625
 626 // Recognize input and output target names.  The GNU linker accepts
 627 // these with --format and --oformat.  This code is intended to be
 628 // minimally compatible.  In practice for an ELF target this would be
 629 // the same target as the input files; that name always start with
 630 // "elf".  Non-ELF targets would be "srec", "symbolsrec", "tekhex",
 631 // "binary", "ihex".
 632
 633 General_options::Object_format
 634 General_options::string_to_object_format(const char* arg)
 635 {
 636   if (strncmp(arg, "elf", 3) == 0)
 637     return gold::General_options::OBJECT_FORMAT_ELF;
 638   else if (strcmp(arg, "binary") == 0)
 639     return gold::General_options::OBJECT_FORMAT_BINARY;
 640   else
 641     {
 642       gold::gold_error(_("format '%s' not supported; treating as elf "
 643                          "(supported formats: elf, binary)"),
 644                        arg);
 645       return gold::General_options::OBJECT_FORMAT_ELF;
 646     }
 647 }
 648
 649 void
 650 General_options::parse_fix_v4bx(const char*, const char*,
 651                                 Command_line*)
 652 {
 653   this->fix_v4bx_ = FIX_V4BX_REPLACE;
 654 }
 655
 656 void
 657 General_options::parse_fix_v4bx_interworking(const char*, const char*,
 658                                              Command_line*)
 659 {
 660   this->fix_v4bx_ = FIX_V4BX_INTERWORKING;
 661 }
 662
 663 void
 664 General_options::parse_EB(const char*, const char*, Command_line*)
 665 {
 666   this->endianness_ = ENDIANNESS_BIG;
 667 }
 668
 669 void
 670 General_options::parse_EL(const char*, const char*, Command_line*)
 671 {
 672   this->endianness_ = ENDIANNESS_LITTLE;
 673 }
 674
 675 } // End namespace gold.
 676
 677 namespace
 678 {
 679
 680 void
 681 usage()
 682 {
 683   fprintf(stderr,
 684           _("%s: use the --help option for usage information\n"),
 685           gold::program_name);
 686   ::exit(EXIT_FAILURE);
 687 }
 688
 689 void
 690 usage(const char* msg, const char* opt)
 691 {
 692   fprintf(stderr,
 693           _("%s: %s: %s\n"),
 694           gold::program_name, opt, msg);
 695   usage();
 696 }
 697
 698 // If the default sysroot is relocatable, try relocating it based on
 699 // the prefix FROM.
 700
 701 static char*
 702 get_relative_sysroot(const char* from)
 703 {
 704   char* path = make_relative_prefix(gold::program_name, from,
 705                                     TARGET_SYSTEM_ROOT);
 706   if (path != NULL)
 707     {
 708       struct stat s;
 709       if (::stat(path, &s) == 0 && S_ISDIR(s.st_mode))
 710         return path;
 711       free(path);
 712     }
 713
 714   return NULL;
 715 }
 716
 717 // Return the default sysroot.  This is set by the --with-sysroot
 718 // option to configure.  Note we do not free the return value of
 719 // get_relative_sysroot, which is a small memory leak, but is
 720 // necessary since we store this pointer directly in General_options.
 721
 722 static const char*
 723 get_default_sysroot()
 724 {
 725   const char* sysroot = TARGET_SYSTEM_ROOT;
 726   if (*sysroot == '\0')
 727     return NULL;
 728
 729   if (TARGET_SYSTEM_ROOT_RELOCATABLE)
 730     {
 731       char* path = get_relative_sysroot(BINDIR);
 732       if (path == NULL)
 733         path = get_relative_sysroot(TOOLBINDIR);
 734       if (path != NULL)
 735         return path;
 736     }
 737
 738   return sysroot;
 739 }
 740
 741 // Parse a long option.  Such options have the form
 742 // <-|--><option>[=arg].  If "=arg" is not present but the option
 743 // takes an argument, the next word is taken to the be the argument.
 744 // If equals_only is set, then only the <option>=<arg> form is
 745 // accepted, not the <option><space><arg> form.  Returns a One_option
 746 // struct or NULL if argv[i] cannot be parsed as a long option.  In
 747 // the not-NULL case, *arg is set to the option's argument (NULL if
 748 // the option takes no argument), and *i is advanced past this option.
 749 // NOTE: it is safe for argv and arg to point to the same place.
 750 gold::options::One_option*
 751 parse_long_option(int argc, const char** argv, bool equals_only,
 752                   const char** arg, int* i)
 753 {
 754   const char* const this_argv = argv[*i];
 755
 756   const char* equals = strchr(this_argv, '=');
 757   const char* option_start = this_argv + strspn(this_argv, "-");
 758   std::string option(option_start,
 759                      equals ? equals - option_start : strlen(option_start));
 760
 761   gold::options::Option_map::iterator it
 762       = gold::options::long_options->find(option);
 763   if (it == gold::options::long_options->end())
 764     return NULL;
 765
 766   gold::options::One_option* retval = it->second;
 767
 768   // If the dash-count doesn't match, we fail.
 769   if (this_argv[0] != '-')  // no dashes at all: had better be "-z <longopt>"
 770     {
 771       if (retval->dashes != gold::options::DASH_Z)
 772         return NULL;
 773     }
 774   else if (this_argv[1] != '-')   // one dash
 775     {
 776       if (retval->dashes != gold::options::ONE_DASH
 777           && retval->dashes != gold::options::EXACTLY_ONE_DASH
 778           && retval->dashes != gold::options::TWO_DASHES)
 779         return NULL;
 780     }
 781   else                            // two dashes (or more!)
 782     {
 783       if (retval->dashes != gold::options::TWO_DASHES
 784           && retval->dashes != gold::options::EXACTLY_TWO_DASHES
 785           && retval->dashes != gold::options::ONE_DASH)
 786         return NULL;
 787     }
 788
 789   // Now that we know the option is good (or else bad in a way that
 790   // will cause us to die), increment i to point past this argv.
 791   ++(*i);
 792
 793   // Figure out the option's argument, if any.
 794   if (!retval->takes_argument())
 795     {
 796       if (equals)
 797         usage(_("unexpected argument"), this_argv);
 798       else
 799         *arg = NULL;
 800     }
 801   else
 802     {
 803       if (equals)
 804         *arg = equals + 1;
 805       else if (retval->takes_optional_argument())
 806         *arg = retval->default_value;
 807       else if (*i < argc && !equals_only)
 808         *arg = argv[(*i)++];
 809       else
 810         usage(_("missing argument"), this_argv);
 811     }
 812
 813   return retval;
 814 }
 815
 816 // Parse a short option.  Such options have the form -<option>[arg].
 817 // If "arg" is not present but the option takes an argument, the next
 818 // word is taken to the be the argument.  If the option does not take
 819 // an argument, it may be followed by another short option.  Returns a
 820 // One_option struct or NULL if argv[i] cannot be parsed as a short
 821 // option.  In the not-NULL case, *arg is set to the option's argument
 822 // (NULL if the option takes no argument), and *i is advanced past
 823 // this option.  This function keeps *i the same if we parsed a short
 824 // option that does not take an argument, that looks to be followed by
 825 // another short option in the same word.
 826 gold::options::One_option*
 827 parse_short_option(int argc, const char** argv, int pos_in_argv_i,
 828                    const char** arg, int* i)
 829 {
 830   const char* const this_argv = argv[*i];
 831
 832   if (this_argv[0] != '-')
 833     return NULL;
 834
 835   // We handle -z as a special case.
 836   static gold::options::One_option dash_z("", gold::options::DASH_Z,
 837                                           'z', "", NULL, "Z-OPTION", false,
 838                                           NULL);
 839   gold::options::One_option* retval = NULL;
 840   if (this_argv[pos_in_argv_i] == 'z')
 841     retval = &dash_z;
 842   else
 843     {
 844       const int char_as_int = static_cast<int>(this_argv[pos_in_argv_i]);
 845       if (char_as_int > 0 && char_as_int < 128)
 846         retval = gold::options::short_options[char_as_int];
 847     }
 848
 849   if (retval == NULL)
 850     return NULL;
 851
 852   // Figure out the option's argument, if any.
 853   if (!retval->takes_argument())
 854     {
 855       *arg = NULL;
 856       // We only advance past this argument if it's the only one in argv.
 857       if (this_argv[pos_in_argv_i + 1] == '\0')
 858         ++(*i);
 859     }
 860   else
 861     {
 862       // If we take an argument, we'll eat up this entire argv entry.
 863       ++(*i);
 864       if (this_argv[pos_in_argv_i + 1] != '\0')
 865         *arg = this_argv + pos_in_argv_i + 1;
 866       else if (retval->takes_optional_argument())
 867         *arg = retval->default_value;
 868       else if (*i < argc)
 869         *arg = argv[(*i)++];
 870       else
 871         usage(_("missing argument"), this_argv);
 872     }
 873
 874   // If we're a -z option, we need to parse our argument as a
 875   // long-option, e.g. "-z stacksize=8192".
 876   if (retval == &dash_z)
 877     {
 878       int dummy_i = 0;
 879       const char* dash_z_arg = *arg;
 880       retval = parse_long_option(1, arg, true, arg, &dummy_i);
 881       if (retval == NULL)
 882         usage(_("unknown -z option"), dash_z_arg);
 883     }
 884
 885   return retval;
 886 }
 887
 888 } // End anonymous namespace.
 889
 890 namespace gold
 891 {
 892
 893 General_options::General_options()
 894   : printed_version_(false),
 895     execstack_status_(EXECSTACK_FROM_INPUT),
 896     icf_status_(ICF_NONE),
 897     static_(false),
 898     do_demangle_(false),
 899     plugins_(NULL),
 900     dynamic_list_(),
 901     incremental_mode_(INCREMENTAL_OFF),
 902     incremental_disposition_(INCREMENTAL_CHECK),
 903     implicit_incremental_(false),
 904     excluded_libs_(),
 905     symbols_to_retain_(),
 906     section_starts_(),
 907     fix_v4bx_(FIX_V4BX_NONE),
 908     endianness_(ENDIANNESS_NOT_SET)
 909 {
 910   // Turn off option registration once construction is complete.
 911   gold::options::ready_to_register = false;
 912 }
 913
 914 General_options::Object_format
 915 General_options::format_enum() const
 916 {
 917   return General_options::string_to_object_format(this->format());
 918 }
 919
 920 General_options::Object_format
 921 General_options::oformat_enum() const
 922 {
 923   return General_options::string_to_object_format(this->oformat());
 924 }
 925
 926 // Add the sysroot, if any, to the search paths.
 927
 928 void
 929 General_options::add_sysroot()
 930 {
 931   if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
 932     {
 933       this->set_sysroot(get_default_sysroot());
 934       if (this->sysroot() == NULL || this->sysroot()[0] == '\0')
 935         return;
 936     }
 937
 938   char* canonical_sysroot = lrealpath(this->sysroot());
 939
 940   for (Dir_list::iterator p = this->library_path_.value.begin();
 941        p != this->library_path_.value.end();
 942        ++p)
 943     p->add_sysroot(this->sysroot(), canonical_sysroot);
 944
 945   free(canonical_sysroot);
 946 }
 947
 948 // Return whether FILENAME is in a system directory.
 949
 950 bool
 951 General_options::is_in_system_directory(const std::string& filename) const
 952 {
 953   for (Dir_list::const_iterator p = this->library_path_.value.begin();
 954        p != this->library_path_.value.end();
 955        ++p)
 956     {
 957       // We use a straight string comparison rather than calling
 958       // FILENAME_CMP because we are only interested in the cases
 959       // where we found the file in a system directory, which means
 960       // that we used the directory name as a prefix for a -L search.
 961       if (p->is_system_directory()
 962           && filename.compare(0, p->name().size(), p->name()) == 0)
 963         return true;
 964     }
 965   return false;
 966 }
 967
 968 // Add a plugin to the list of plugins.
 969
 970 void
 971 General_options::add_plugin(const char* filename)
 972 {
 973   if (this->plugins_ == NULL)
 974     this->plugins_ = new Plugin_manager(*this);
 975   this->plugins_->add_plugin(filename);
 976 }
 977
 978 // Add a plugin option to a plugin.
 979
 980 void
 981 General_options::add_plugin_option(const char* arg)
 982 {
 983   if (this->plugins_ == NULL)
 984     gold_fatal("--plugin-opt requires --plugin.");
 985   this->plugins_->add_plugin_option(arg);
 986 }
 987
 988 // Set up variables and other state that isn't set up automatically by
 989 // the parse routine, and ensure options don't contradict each other
 990 // and are otherwise kosher.
 991
 992 void
 993 General_options::finalize()
 994 {
 995   // Normalize the strip modifiers.  They have a total order:
 996   // strip_all > strip_debug > strip_non_line > strip_debug_gdb.
 997   // If one is true, set all beneath it to true as well.
 998   if (this->strip_all())
 999     this->set_strip_debug(true);
1000   if (this->strip_debug())
1001     this->set_strip_debug_non_line(true);
1002   if (this->strip_debug_non_line())
1003     this->set_strip_debug_gdb(true);
1004
1005   if (this->Bshareable())
1006     this->set_shared(true);
1007
1008   // If the user specifies both -s and -r, convert the -s to -S.
1009   // -r requires us to keep externally visible symbols!
1010   if (this->strip_all() && this->relocatable())
1011     {
1012       this->set_strip_all(false);
1013       gold_assert(this->strip_debug());
1014     }
1015
1016   // For us, -dc and -dp are synonyms for --define-common.
1017   if (this->dc())
1018     this->set_define_common(true);
1019   if (this->dp())
1020     this->set_define_common(true);
1021
1022   // We also set --define-common if we're not relocatable, as long as
1023   // the user didn't explicitly ask for something different.
1024   if (!this->user_set_define_common())
1025     this->set_define_common(!this->relocatable());
1026
1027   // execstack_status_ is a three-state variable; update it based on
1028   // -z [no]execstack.
1029   if (this->execstack())
1030     this->set_execstack_status(EXECSTACK_YES);
1031   else if (this->noexecstack())
1032     this->set_execstack_status(EXECSTACK_NO);
1033
1034   // icf_status_ is a three-state variable; update it based on the
1035   // value of this->icf().
1036   if (strcmp(this->icf(), "none") == 0)
1037     this->set_icf_status(ICF_NONE);
1038   else if (strcmp(this->icf(), "safe") == 0)
1039     this->set_icf_status(ICF_SAFE);
1040   else
1041     this->set_icf_status(ICF_ALL);
1042
1043   // Handle the optional argument for --demangle.
1044   if (this->user_set_demangle())
1045     {
1046       this->set_do_demangle(true);
1047       const char* style = this->demangle();
1048       if (*style != '\0')
1049         {
1050           enum demangling_styles style_code;
1051
1052           style_code = cplus_demangle_name_to_style(style);
1053           if (style_code == unknown_demangling)
1054             gold_fatal("unknown demangling style '%s'", style);
1055           cplus_demangle_set_style(style_code);
1056         }
1057     }
1058   else if (this->user_set_no_demangle())
1059     this->set_do_demangle(false);
1060   else
1061     {
1062       // Testing COLLECT_NO_DEMANGLE makes our default demangling
1063       // behaviour identical to that of gcc's linker wrapper.
1064       this->set_do_demangle(getenv("COLLECT_NO_DEMANGLE") == NULL);
1065     }
1066
1067   // -M is equivalent to "-Map -".
1068   if (this->print_map() && !this->user_set_Map())
1069     {
1070       this->set_Map("-");
1071       this->set_user_set_Map();
1072     }
1073
1074   // Using -n or -N implies -static.
1075   if (this->nmagic() || this->omagic())
1076     this->set_static(true);
1077
1078   // If --thread_count is specified, it applies to
1079   // --thread-count-{initial,middle,final}, though it doesn't override
1080   // them.
1081   if (this->thread_count() > 0 && this->thread_count_initial() == 0)
1082     this->set_thread_count_initial(this->thread_count());
1083   if (this->thread_count() > 0 && this->thread_count_middle() == 0)
1084     this->set_thread_count_middle(this->thread_count());
1085   if (this->thread_count() > 0 && this->thread_count_final() == 0)
1086     this->set_thread_count_final(this->thread_count());
1087
1088   // Let's warn if you set the thread-count but we're going to ignore it.
1089 #ifndef ENABLE_THREADS
1090   if (this->threads())
1091     {
1092       gold_warning(_("ignoring --threads: "
1093                      "%s was compiled without thread support"),
1094                    program_name);
1095       this->set_threads(false);
1096     }
1097   if (this->thread_count() > 0 || this->thread_count_initial() > 0
1098       || this->thread_count_middle() > 0 || this->thread_count_final() > 0)
1099     gold_warning(_("ignoring --thread-count: "
1100                    "%s was compiled without thread support"),
1101                  program_name);
1102 #endif
1103
1104   if (this->user_set_Y())
1105     {
1106       std::string s = this->Y();
1107       if (s.compare(0, 2, "P,") == 0)
1108         s.erase(0, 2);
1109
1110       size_t pos = 0;
1111       size_t next_pos;
1112       do
1113         {
1114           next_pos = s.find(':', pos);
1115           size_t len = (next_pos == std::string::npos
1116                         ? next_pos
1117                         : next_pos - pos);
1118           if (len != 0)
1119             this->add_to_library_path_with_sysroot(s.substr(pos, len).c_str());
1120           pos = next_pos + 1;
1121         }
1122       while (next_pos != std::string::npos);
1123     }
1124   else if (!this->nostdlib())
1125     {
1126       // Even if they don't specify it, we add -L /lib and -L /usr/lib.
1127       // FIXME: We should only do this when configured in native mode.
1128       this->add_to_library_path_with_sysroot("/lib");
1129       this->add_to_library_path_with_sysroot("/usr/lib");
1130     }
1131
1132   // Parse the contents of -retain-symbols-file into a set.
1133   if (this->retain_symbols_file())
1134     {
1135       std::ifstream in;
1136       in.open(this->retain_symbols_file());
1137       if (!in)
1138         gold_fatal(_("unable to open -retain-symbols-file file %s: %s"),
1139                    this->retain_symbols_file(), strerror(errno));
1140       std::string line;
1141       std::getline(in, line);   // this chops off the trailing \n, if any
1142       while (in)
1143         {
1144           if (!line.empty() && line[line.length() - 1] == '\r')   // Windows
1145             line.resize(line.length() - 1);
1146           this->symbols_to_retain_.insert(line);
1147           std::getline(in, line);
1148         }
1149     }
1150
1151   if (this->shared() && !this->user_set_allow_shlib_undefined())
1152     this->set_allow_shlib_undefined(true);
1153
1154   // Normalize library_path() by adding the sysroot to all directories
1155   // in the path, as appropriate.
1156   this->add_sysroot();
1157
1158   // Now that we've normalized the options, check for contradictory ones.
1159   if (this->shared() && this->is_static())
1160     gold_fatal(_("-shared and -static are incompatible"));
1161   if (this->shared() && this->pie())
1162     gold_fatal(_("-shared and -pie are incompatible"));
1163
1164   if (this->shared() && this->relocatable())
1165     gold_fatal(_("-shared and -r are incompatible"));
1166   if (this->pie() && this->relocatable())
1167     gold_fatal(_("-pie and -r are incompatible"));
1168
1169   // TODO: implement support for -retain-symbols-file with -r, if needed.
1170   if (this->relocatable() && this->retain_symbols_file())
1171     gold_fatal(_("-retain-symbols-file does not yet work with -r"));
1172
1173   if (this->oformat_enum() != General_options::OBJECT_FORMAT_ELF
1174       && (this->shared()
1175           || this->pie()
1176           || this->relocatable()))
1177     gold_fatal(_("binary output format not compatible "
1178                  "with -shared or -pie or -r"));
1179
1180   if (this->user_set_hash_bucket_empty_fraction()
1181       && (this->hash_bucket_empty_fraction() < 0.0
1182           || this->hash_bucket_empty_fraction() >= 1.0))
1183     gold_fatal(_("--hash-bucket-empty-fraction value %g out of range "
1184                  "[0.0, 1.0)"),
1185                this->hash_bucket_empty_fraction());
1186
1187   if (this->implicit_incremental_ && this->incremental_mode_ == INCREMENTAL_OFF)
1188     gold_fatal(_("Options --incremental-changed, --incremental-unchanged, "
1189                  "--incremental-unknown require the use of --incremental"));
1190
1191   // FIXME: we can/should be doing a lot more sanity checking here.
1192 }
1193
1194 // Search_directory methods.
1195
1196 // This is called if we have a sysroot.  Apply the sysroot if
1197 // appropriate.  Record whether the directory is in the sysroot.
1198
1199 void
1200 Search_directory::add_sysroot(const char* sysroot,
1201                               const char* canonical_sysroot)
1202 {
1203   gold_assert(*sysroot != '\0');
1204   if (this->put_in_sysroot_)
1205     {
1206       if (!IS_DIR_SEPARATOR(this->name_[0])
1207           && !IS_DIR_SEPARATOR(sysroot[strlen(sysroot) - 1]))
1208         this->name_ = '/' + this->name_;
1209       this->name_ = sysroot + this->name_;
1210       this->is_in_sysroot_ = true;
1211     }
1212   else
1213     {
1214       // Check whether this entry is in the sysroot.  To do this
1215       // correctly, we need to use canonical names.  Otherwise we will
1216       // get confused by the ../../.. paths that gcc tends to use.
1217       char* canonical_name = lrealpath(this->name_.c_str());
1218       int canonical_name_len = strlen(canonical_name);
1219       int canonical_sysroot_len = strlen(canonical_sysroot);
1220       if (canonical_name_len > canonical_sysroot_len
1221           && IS_DIR_SEPARATOR(canonical_name[canonical_sysroot_len]))
1222         {
1223           canonical_name[canonical_sysroot_len] = '\0';
1224           if (FILENAME_CMP(canonical_name, canonical_sysroot) == 0)
1225             this->is_in_sysroot_ = true;
1226         }
1227       free(canonical_name);
1228     }
1229 }
1230
1231 // Input_arguments methods.
1232
1233 // Add a file to the list.
1234
1235 Input_argument&
1236 Input_arguments::add_file(Input_file_argument& file)
1237 {
1238   file.set_arg_serial(++this->file_count_);
1239   if (this->in_group_)
1240     {
1241       gold_assert(!this->input_argument_list_.empty());
1242       gold_assert(this->input_argument_list_.back().is_group());
1243       return this->input_argument_list_.back().group()->add_file(file);
1244     }
1245   if (this->in_lib_)
1246     {
1247       gold_assert(!this->input_argument_list_.empty());
1248       gold_assert(this->input_argument_list_.back().is_lib());
1249       return this->input_argument_list_.back().lib()->add_file(file);
1250     }
1251   this->input_argument_list_.push_back(Input_argument(file));
1252   return this->input_argument_list_.back();
1253 }
1254
1255 // Start a group.
1256
1257 void
1258 Input_arguments::start_group()
1259 {
1260   if (this->in_group_)
1261     gold_fatal(_("May not nest groups"));
1262   if (this->in_lib_)
1263     gold_fatal(_("may not nest groups in libraries"));
1264   Input_file_group* group = new Input_file_group();
1265   this->input_argument_list_.push_back(Input_argument(group));
1266   this->in_group_ = true;
1267 }
1268
1269 // End a group.
1270
1271 void
1272 Input_arguments::end_group()
1273 {
1274   if (!this->in_group_)
1275     gold_fatal(_("Group end without group start"));
1276   this->in_group_ = false;
1277 }
1278
1279 // Start a lib.
1280
1281 void
1282 Input_arguments::start_lib(const Position_dependent_options& options)
1283 {
1284   if (this->in_lib_)
1285     gold_fatal(_("may not nest libraries"));
1286   if (this->in_group_)
1287     gold_fatal(_("may not nest libraries in groups"));
1288   Input_file_lib* lib = new Input_file_lib(options);
1289   this->input_argument_list_.push_back(Input_argument(lib));
1290   this->in_lib_ = true;
1291 }
1292
1293 // End a lib.
1294
1295 void
1296 Input_arguments::end_lib()
1297 {
1298   if (!this->in_lib_)
1299     gold_fatal(_("lib end without lib start"));
1300   this->in_lib_ = false;
1301 }
1302
1303 // Command_line options.
1304
1305 Command_line::Command_line()
1306 {
1307 }
1308
1309 // Pre_options is the hook that sets the ready_to_register flag.
1310
1311 Command_line::Pre_options::Pre_options()
1312 {
1313   gold::options::ready_to_register = true;
1314 }
1315
1316 // Process the command line options.  For process_one_option, i is the
1317 // index of argv to process next, and must be an option (that is,
1318 // start with a dash).  The return value is the index of the next
1319 // option to process (i+1 or i+2, or argc to indicate processing is
1320 // done).  no_more_options is set to true if (and when) "--" is seen
1321 // as an option.
1322
1323 int
1324 Command_line::process_one_option(int argc, const char** argv, int i,
1325                                  bool* no_more_options)
1326 {
1327   gold_assert(argv[i][0] == '-' && !(*no_more_options));
1328
1329   // If we are reading "--", then just set no_more_options and return.
1330   if (argv[i][1] == '-' && argv[i][2] == '\0')
1331     {
1332       *no_more_options = true;
1333       return i + 1;
1334     }
1335
1336   int new_i = i;
1337   options::One_option* option = NULL;
1338   const char* arg = NULL;
1339
1340   // First, try to process argv as a long option.
1341   option = parse_long_option(argc, argv, false, &arg, &new_i);
1342   if (option)
1343     {
1344       option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1345       return new_i;
1346     }
1347
1348   // Now, try to process argv as a short option.  Since several short
1349   // options can be combined in one argv, we may have to parse a lot
1350   // until we're done reading this argv.
1351   int pos_in_argv_i = 1;
1352   while (new_i == i)
1353     {
1354       option = parse_short_option(argc, argv, pos_in_argv_i, &arg, &new_i);
1355       if (!option)
1356         break;
1357       option->reader->parse_to_value(argv[i], arg, this, &this->options_);
1358       ++pos_in_argv_i;
1359     }
1360   if (option)
1361     return new_i;
1362
1363   // I guess it's neither a long option nor a short option.
1364   usage(_("unknown option"), argv[i]);
1365   return argc;
1366 }
1367
1368
1369 void
1370 Command_line::process(int argc, const char** argv)
1371 {
1372   bool no_more_options = false;
1373   int i = 0;
1374   while (i < argc)
1375     {
1376       this->position_options_.copy_from_options(this->options());
1377       if (no_more_options || argv[i][0] != '-')
1378         {
1379           Input_file_argument file(argv[i],
1380                                    Input_file_argument::INPUT_FILE_TYPE_FILE,
1381                                    "", false, this->position_options_);
1382           this->inputs_.add_file(file);
1383           ++i;
1384         }
1385       else
1386         i = process_one_option(argc, argv, i, &no_more_options);
1387     }
1388
1389   if (this->inputs_.in_group())
1390     {
1391       fprintf(stderr, _("%s: missing group end\n"), program_name);
1392       usage();
1393     }
1394
1395   // Normalize the options and ensure they don't contradict each other.
1396   this->options_.finalize();
1397 }
1398
1399 // Finalize the version script options and return them.
1400
1401 const Version_script_info&
1402 Command_line::version_script()
1403 {
1404   this->options_.finalize_dynamic_list();
1405   Version_script_info* vsi = this->script_options_.version_script_info();
1406   vsi->finalize();
1407   return *vsi;
1408 }
1409
1410 } // End namespace gold.