gold/options.h

   1 // options.h -- handle command line options for gold  -*- C++ -*-
   2
   3 // Copyright 2006, 2007 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 // Command_line
  24 //   Holds everything we get from the command line.
  25 // General_options (from Command_line::options())
  26 //   Options which are not position dependent.
  27 // Input_argument (from Command_line::inputs())
  28 //   The list of input files, including -l options.
  29 // Position_dependent_options (from Input_argument::options())
  30 //   Position dependent options which apply to this argument.
  31
  32 #ifndef GOLD_OPTIONS_H
  33 #define GOLD_OPTIONS_H
  34
  35 #include <cstdlib>
  36 #include <list>
  37 #include <string>
  38 #include <vector>
  39
  40 #include "script.h"
  41
  42 namespace gold
  43 {
  44
  45 class Command_line;
  46 class Input_file_group;
  47 class Position_dependent_options;
  48
  49 namespace options
  50 {
  51
  52 class Command_line_options;
  53 struct One_option;
  54 struct One_z_option;
  55 struct One_debug_option;
  56
  57 } // End namespace gold::options.
  58
  59 // A directory to search.  For each directory we record whether it is
  60 // in the sysroot.  We need to know this so that, if a linker script
  61 // is found within the sysroot, we will apply the sysroot to any files
  62 // named by that script.
  63
  64 class Search_directory
  65 {
  66  public:
  67   // We need a default constructor because we put this in a
  68   // std::vector.
  69   Search_directory()
  70     : name_(NULL), put_in_sysroot_(false), is_in_sysroot_(false)
  71   { }
  72
  73   // This is the usual constructor.
  74   Search_directory(const char* name, bool put_in_sysroot)
  75     : name_(name), put_in_sysroot_(put_in_sysroot), is_in_sysroot_(false)
  76   { gold_assert(!this->name_.empty()); }
  77
  78   // This is called if we have a sysroot.  The sysroot is prefixed to
  79   // any entries for which put_in_sysroot_ is true.  is_in_sysroot_ is
  80   // set to true for any enries which are in the sysroot (this will
  81   // naturally include any entries for which put_in_sysroot_ is true).
  82   // SYSROOT is the sysroot, CANONICAL_SYSROOT is the result of
  83   // passing SYSROOT to lrealpath.
  84   void
  85   add_sysroot(const char* sysroot, const char* canonical_sysroot);
  86
  87   // Get the directory name.
  88   const std::string&
  89   name() const
  90   { return this->name_; }
  91
  92   // Return whether this directory is in the sysroot.
  93   bool
  94   is_in_sysroot() const
  95   { return this->is_in_sysroot_; }
  96
  97  private:
  98   std::string name_;
  99   bool put_in_sysroot_;
 100   bool is_in_sysroot_;
 101 };
 102
 103 // The position independent options which apply to the whole link.
 104 // There are a lot of them.
 105
 106 class General_options
 107 {
 108  public:
 109   General_options();
 110
 111   // -E: export dynamic symbols.
 112   bool
 113   export_dynamic() const
 114   { return this->export_dynamic_; }
 115
 116   // -I: dynamic linker name.
 117   const char*
 118   dynamic_linker() const
 119   { return this->dynamic_linker_; }
 120
 121   // -L: Library search path.
 122   typedef std::vector<Search_directory> Dir_list;
 123
 124   const Dir_list&
 125   search_path() const
 126   { return this->search_path_; }
 127
 128   // -O: optimization level (0: don't try to optimize output size).
 129   int
 130   optimization_level() const
 131   { return this->optimization_level_; }
 132
 133   // -o: Output file name.
 134   const char*
 135   output_file_name() const
 136   { return this->output_file_name_; }
 137
 138   // -r: Whether we are doing a relocatable link.
 139   bool
 140   is_relocatable() const
 141   { return this->is_relocatable_; }
 142
 143   // -s: Strip all symbols.
 144   bool
 145   strip_all() const
 146   { return this->strip_ == STRIP_ALL; }
 147
 148   // -S: Strip debugging information.
 149   bool
 150   strip_debug() const
 151   { return this->strip_ == STRIP_ALL || this->strip_ == STRIP_DEBUG; }
 152
 153   // --strip-debug-gdb: strip only debugging information that's not
 154   // used by gdb (at least, for gdb versions <= 6.7).
 155   bool
 156   strip_debug_gdb() const
 157   { return this->strip_debug() || this->strip_ == STRIP_DEBUG_UNUSED_BY_GDB; }
 158
 159   // --allow-shlib-undefined: do not warn about unresolved symbols in
 160   // --shared libraries.
 161   bool
 162   allow_shlib_undefined() const
 163   { return this->allow_shlib_undefined_; }
 164
 165   // -Bsymbolic: bind defined symbols locally.
 166   bool
 167   symbolic() const
 168   { return this->symbolic_; }
 169
 170   // --compress-debug-sections: compress .debug_* sections in the
 171   // output file using the given compression method.  This is useful
 172   // when the tools (such as gdb) support compressed sections.
 173   bool
 174   compress_debug_sections() const
 175   { return this->compress_debug_sections_ != NO_COMPRESSION; }
 176
 177   bool
 178   zlib_compress_debug_sections() const
 179   { return this->compress_debug_sections_ == ZLIB_COMPRESSION; }
 180
 181   // --demangle: demangle C++ symbols in our log messages.
 182   bool
 183   demangle() const
 184   { return this->demangle_; }
 185
 186   // --detect-odr-violations: Whether to search for One Defn Rule violations.
 187   bool
 188   detect_odr_violations() const
 189   { return this->detect_odr_violations_; }
 190
 191   // --eh-frame-hdr: Whether to generate an exception frame header.
 192   bool
 193   create_eh_frame_hdr() const
 194   { return this->create_eh_frame_hdr_; }
 195
 196   // --rpath: The runtime search path.
 197   const Dir_list&
 198   rpath() const
 199   { return this->rpath_; }
 200
 201   // --rpath-link: The link time search patch for shared libraries.
 202   const Dir_list&
 203   rpath_link() const
 204   { return this->rpath_link_; }
 205
 206   // --shared: Whether generating a shared object.
 207   bool
 208   is_shared() const
 209   { return this->is_shared_; }
 210
 211   // --static: Whether doing a static link.
 212   bool
 213   is_static() const
 214   { return this->is_static_; }
 215
 216   // --stats: Print resource usage statistics.
 217   bool
 218   print_stats() const
 219   { return this->print_stats_; }
 220
 221   // --sysroot: The system root of a cross-linker.
 222   const std::string&
 223   sysroot() const
 224   { return this->sysroot_; }
 225
 226   // -Ttext: The address of the .text section
 227   uint64_t
 228   text_segment_address() const
 229   { return this->text_segment_address_; }
 230
 231   // Whether -Ttext was used.
 232   bool
 233   user_set_text_segment_address() const
 234   { return this->text_segment_address_ != -1U; }
 235
 236   // --threads: Whether to use threads.
 237   bool
 238   threads() const
 239   { return this->threads_; }
 240
 241   // --thread-count-initial: Threads to use in initial pass.
 242   int
 243   thread_count_initial() const
 244   { return this->thread_count_initial_; }
 245
 246   // --thread-count-middle: Threads to use in middle pass.
 247   int
 248   thread_count_middle() const
 249   { return this->thread_count_middle_; }
 250
 251   // --thread-count-final: Threads to use in final pass.
 252   int
 253   thread_count_final() const
 254   { return this->thread_count_final_; }
 255
 256   // -z execstack, -z noexecstack
 257   bool
 258   is_execstack_set() const
 259   { return this->execstack_ != EXECSTACK_FROM_INPUT; }
 260
 261   bool
 262   is_stack_executable() const
 263   { return this->execstack_ == EXECSTACK_YES; }
 264
 265   // --debug
 266   unsigned int
 267   debug() const
 268   { return this->debug_; }
 269
 270  private:
 271   // Don't copy this structure.
 272   General_options(const General_options&);
 273   General_options& operator=(const General_options&);
 274
 275   friend class Command_line;
 276   friend class options::Command_line_options;
 277
 278   // Which symbols to strip.
 279   enum Strip
 280   {
 281     // Don't strip any symbols.
 282     STRIP_NONE,
 283     // Strip all symbols.
 284     STRIP_ALL,
 285     // Strip debugging information.
 286     STRIP_DEBUG,
 287     // Strip debugging information that's not used by gdb (at least <= 6.7)
 288     STRIP_DEBUG_UNUSED_BY_GDB
 289   };
 290
 291   // Whether to mark the stack as executable.
 292   enum Execstack
 293   {
 294     // Not set on command line.
 295     EXECSTACK_FROM_INPUT,
 296     // Mark the stack as executable.
 297     EXECSTACK_YES,
 298     // Mark the stack as not executable.
 299     EXECSTACK_NO
 300   };
 301
 302   // What compression method to use
 303   enum CompressionMethod
 304   {
 305     NO_COMPRESSION,
 306     ZLIB_COMPRESSION,
 307   };
 308
 309   void
 310   set_export_dynamic()
 311   { this->export_dynamic_ = true; }
 312
 313   void
 314   set_dynamic_linker(const char* arg)
 315   { this->dynamic_linker_ = arg; }
 316
 317   void
 318   add_to_search_path(const char* arg)
 319   { this->search_path_.push_back(Search_directory(arg, false)); }
 320
 321   void
 322   add_to_search_path_with_sysroot(const char* arg)
 323   { this->search_path_.push_back(Search_directory(arg, true)); }
 324
 325   void
 326   set_optimization_level(const char* arg)
 327   { this->optimization_level_ = atoi(arg); }
 328
 329   void
 330   set_output_file_name(const char* arg)
 331   { this->output_file_name_ = arg; }
 332
 333   void
 334   set_relocatable()
 335   { this->is_relocatable_ = true; }
 336
 337   void
 338   set_strip_all()
 339   { this->strip_ = STRIP_ALL; }
 340
 341   // Note: normalize_options() depends on the fact that this turns off
 342   // STRIP_ALL if it were already set.
 343   void
 344   set_strip_debug()
 345   { this->strip_ = STRIP_DEBUG; }
 346
 347   void
 348   set_strip_debug_gdb()
 349   { this->strip_ = STRIP_DEBUG_UNUSED_BY_GDB; }
 350
 351   void
 352   set_allow_shlib_undefined()
 353   { this->allow_shlib_undefined_ = true; }
 354
 355   void
 356   set_no_allow_shlib_undefined()
 357   { this->allow_shlib_undefined_ = false; }
 358
 359   void
 360   set_symbolic()
 361   { this->symbolic_ = true; }
 362
 363   void set_compress_debug_symbols(const char* arg)
 364   {
 365     if (strcmp(arg, "none") == 0)
 366       this->compress_debug_sections_ = NO_COMPRESSION;
 367 #ifdef HAVE_ZLIB_H
 368     else if (strcmp(arg, "zlib") == 0)
 369       this->compress_debug_sections_ = ZLIB_COMPRESSION;
 370 #endif
 371     else
 372       gold_fatal(_("Unsupported argument to --compress-debug-symbols: %s"),
 373                  arg);
 374   }
 375
 376   void
 377   set_demangle()
 378   { this->demangle_ = true; }
 379
 380   void
 381   clear_demangle()
 382   { this->demangle_ = false; }
 383
 384   void
 385   set_detect_odr_violations()
 386   { this->detect_odr_violations_ = true; }
 387
 388   void
 389   set_create_eh_frame_hdr()
 390   { this->create_eh_frame_hdr_ = true; }
 391
 392   void
 393   add_to_rpath(const char* arg)
 394   { this->rpath_.push_back(Search_directory(arg, false)); }
 395
 396   void
 397   add_to_rpath_link(const char* arg)
 398   { this->rpath_link_.push_back(Search_directory(arg, false)); }
 399
 400   void
 401   set_shared()
 402   { this->is_shared_ = true; }
 403
 404   void
 405   set_static()
 406   { this->is_static_ = true; }
 407
 408   void
 409   set_stats()
 410   { this->print_stats_ = true; }
 411
 412   void
 413   set_sysroot(const char* arg)
 414   { this->sysroot_ = arg; }
 415
 416   void
 417   set_text_segment_address(const char* arg)
 418   {
 419     char* endptr;
 420     this->text_segment_address_ = strtoull(arg, &endptr, 0);
 421     if (*endptr != '\0'
 422         || this->text_segment_address_ == -1U)
 423       {
 424         fprintf(stderr, _("%s: invalid argument to -Ttext: %s\n"),
 425                 program_name, arg);
 426         ::exit(1);
 427       }
 428   }
 429
 430   int
 431   parse_thread_count(const char* arg)
 432   {
 433     char* endptr;
 434     int count = strtol(arg, &endptr, 0);
 435     if (*endptr != '\0' || count < 0)
 436       {
 437         fprintf(stderr, _("%s: invalid thread count: %s\n"),
 438                 program_name, arg);
 439         ::exit(1);
 440       }
 441     return count;
 442   }
 443
 444   void
 445   set_threads()
 446   { this->threads_ = true; }
 447
 448   void
 449   clear_threads()
 450   { this->threads_ = false; }
 451
 452   void
 453   set_thread_count(const char* arg)
 454   {
 455     int count = this->parse_thread_count(arg);
 456     this->thread_count_initial_ = count;
 457     this->thread_count_middle_ = count;
 458     this->thread_count_final_ = count;
 459   }
 460
 461   void
 462   set_thread_count_initial(const char* arg)
 463   { this->thread_count_initial_ = this->parse_thread_count(arg); }
 464
 465   void
 466   set_thread_count_middle(const char* arg)
 467   { this->thread_count_initial_ = this->parse_thread_count(arg); }
 468
 469   void
 470   set_thread_count_final(const char* arg)
 471   { this->thread_count_initial_ = this->parse_thread_count(arg); }
 472
 473   void
 474   ignore(const char*)
 475   { }
 476
 477   void
 478   set_execstack()
 479   { this->execstack_ = EXECSTACK_YES; }
 480
 481   void
 482   set_noexecstack()
 483   { this->execstack_ = EXECSTACK_NO; }
 484
 485   void
 486   set_debug(unsigned int flags)
 487   { this->debug_ = flags; }
 488
 489   // Handle the -z option.
 490   void
 491   handle_z_option(const char*);
 492
 493   // Handle the --debug option.
 494   void
 495   handle_debug_option(const char*);
 496
 497   // Apply any sysroot to the directory lists.
 498   void
 499   add_sysroot();
 500
 501   bool export_dynamic_;
 502   const char* dynamic_linker_;
 503   Dir_list search_path_;
 504   int optimization_level_;
 505   const char* output_file_name_;
 506   bool is_relocatable_;
 507   Strip strip_;
 508   bool allow_shlib_undefined_;
 509   bool symbolic_;
 510   CompressionMethod compress_debug_sections_;
 511   bool demangle_;
 512   bool detect_odr_violations_;
 513   bool create_eh_frame_hdr_;
 514   Dir_list rpath_;
 515   Dir_list rpath_link_;
 516   bool is_shared_;
 517   bool is_static_;
 518   bool print_stats_;
 519   std::string sysroot_;
 520   uint64_t text_segment_address_;
 521   bool threads_;
 522   int thread_count_initial_;
 523   int thread_count_middle_;
 524   int thread_count_final_;
 525   Execstack execstack_;
 526   unsigned int debug_;
 527 };
 528
 529 // The current state of the position dependent options.
 530
 531 class Position_dependent_options
 532 {
 533  public:
 534   Position_dependent_options();
 535
 536   // -Bdynamic/-Bstatic: Whether we are searching for a static archive
 537   // -rather than a shared object.
 538   bool
 539   do_static_search() const
 540   { return this->do_static_search_; }
 541
 542   // --as-needed: Whether to add a DT_NEEDED argument only if the
 543   // dynamic object is used.
 544   bool
 545   as_needed() const
 546   { return this->as_needed_; }
 547
 548   // --whole-archive: Whether to include the entire contents of an
 549   // --archive.
 550   bool
 551   include_whole_archive() const
 552   { return this->include_whole_archive_; }
 553
 554   void
 555   set_static_search()
 556   { this->do_static_search_ = true; }
 557
 558   void
 559   set_dynamic_search()
 560   { this->do_static_search_ = false; }
 561
 562   void
 563   set_as_needed()
 564   { this->as_needed_ = true; }
 565
 566   void
 567   clear_as_needed()
 568   { this->as_needed_ = false; }
 569
 570   void
 571   set_whole_archive()
 572   { this->include_whole_archive_ = true; }
 573
 574   void
 575   clear_whole_archive()
 576   { this->include_whole_archive_ = false; }
 577
 578  private:
 579   bool do_static_search_;
 580   bool as_needed_;
 581   bool include_whole_archive_;
 582 };
 583
 584 // A single file or library argument from the command line.
 585
 586 class Input_file_argument
 587 {
 588  public:
 589   // name: file name or library name
 590   // is_lib: true if name is a library name: that is, emits the leading
 591   //         "lib" and trailing ".so"/".a" from the name
 592   // extra_search_path: an extra directory to look for the file, prior
 593   //         to checking the normal library search path.  If this is "",
 594   //         then no extra directory is added.
 595   // options: The position dependent options at this point in the
 596   //         command line, such as --whole-archive.
 597   Input_file_argument()
 598     : name_(), is_lib_(false), extra_search_path_(""), options_()
 599   { }
 600
 601   Input_file_argument(const char* name, bool is_lib,
 602                       const char* extra_search_path,
 603                       const Position_dependent_options& options)
 604     : name_(name), is_lib_(is_lib), extra_search_path_(extra_search_path),
 605       options_(options)
 606   { }
 607
 608   const char*
 609   name() const
 610   { return this->name_.c_str(); }
 611
 612   const Position_dependent_options&
 613   options() const
 614   { return this->options_; }
 615
 616   bool
 617   is_lib() const
 618   { return this->is_lib_; }
 619
 620   const char*
 621   extra_search_path() const
 622   {
 623     return (this->extra_search_path_.empty()
 624             ? NULL
 625             : this->extra_search_path_.c_str());
 626   }
 627
 628   // Return whether this file may require a search using the -L
 629   // options.
 630   bool
 631   may_need_search() const
 632   { return this->is_lib_ || !this->extra_search_path_.empty(); }
 633
 634  private:
 635   // We use std::string, not const char*, here for convenience when
 636   // using script files, so that we do not have to preserve the string
 637   // in that case.
 638   std::string name_;
 639   bool is_lib_;
 640   std::string extra_search_path_;
 641   Position_dependent_options options_;
 642 };
 643
 644 // A file or library, or a group, from the command line.
 645
 646 class Input_argument
 647 {
 648  public:
 649   // Create a file or library argument.
 650   explicit Input_argument(Input_file_argument file)
 651     : is_file_(true), file_(file), group_(NULL)
 652   { }
 653
 654   // Create a group argument.
 655   explicit Input_argument(Input_file_group* group)
 656     : is_file_(false), group_(group)
 657   { }
 658
 659   // Return whether this is a file.
 660   bool
 661   is_file() const
 662   { return this->is_file_; }
 663
 664   // Return whether this is a group.
 665   bool
 666   is_group() const
 667   { return !this->is_file_; }
 668
 669   // Return the information about the file.
 670   const Input_file_argument&
 671   file() const
 672   {
 673     gold_assert(this->is_file_);
 674     return this->file_;
 675   }
 676
 677   // Return the information about the group.
 678   const Input_file_group*
 679   group() const
 680   {
 681     gold_assert(!this->is_file_);
 682     return this->group_;
 683   }
 684
 685   Input_file_group*
 686   group()
 687   {
 688     gold_assert(!this->is_file_);
 689     return this->group_;
 690   }
 691
 692  private:
 693   bool is_file_;
 694   Input_file_argument file_;
 695   Input_file_group* group_;
 696 };
 697
 698 // A group from the command line.  This is a set of arguments within
 699 // --start-group ... --end-group.
 700
 701 class Input_file_group
 702 {
 703  public:
 704   typedef std::vector<Input_argument> Files;
 705   typedef Files::const_iterator const_iterator;
 706
 707   Input_file_group()
 708     : files_()
 709   { }
 710
 711   // Add a file to the end of the group.
 712   void
 713   add_file(const Input_file_argument& arg)
 714   { this->files_.push_back(Input_argument(arg)); }
 715
 716   // Iterators to iterate over the group contents.
 717
 718   const_iterator
 719   begin() const
 720   { return this->files_.begin(); }
 721
 722   const_iterator
 723   end() const
 724   { return this->files_.end(); }
 725
 726  private:
 727   Files files_;
 728 };
 729
 730 // A list of files from the command line or a script.
 731
 732 class Input_arguments
 733 {
 734  public:
 735   typedef std::vector<Input_argument> Input_argument_list;
 736   typedef Input_argument_list::const_iterator const_iterator;
 737
 738   Input_arguments()
 739     : input_argument_list_(), in_group_(false)
 740   { }
 741
 742   // Add a file.
 743   void
 744   add_file(const Input_file_argument& arg);
 745
 746   // Start a group (the --start-group option).
 747   void
 748   start_group();
 749
 750   // End a group (the --end-group option).
 751   void
 752   end_group();
 753
 754   // Return whether we are currently in a group.
 755   bool
 756   in_group() const
 757   { return this->in_group_; }
 758
 759   // The number of entries in the list.
 760   int
 761   size() const
 762   { return this->input_argument_list_.size(); }
 763
 764   // Iterators to iterate over the list of input files.
 765
 766   const_iterator
 767   begin() const
 768   { return this->input_argument_list_.begin(); }
 769
 770   const_iterator
 771   end() const
 772   { return this->input_argument_list_.end(); }
 773
 774   // Return whether the list is empty.
 775   bool
 776   empty() const
 777   { return this->input_argument_list_.empty(); }
 778
 779  private:
 780   Input_argument_list input_argument_list_;
 781   bool in_group_;
 782 };
 783
 784 // All the information read from the command line.
 785
 786 class Command_line
 787 {
 788  public:
 789   typedef Input_arguments::const_iterator const_iterator;
 790
 791   Command_line();
 792
 793   // Process the command line options.  This will exit with an
 794   // appropriate error message if an unrecognized option is seen.
 795   void
 796   process(int argc, char** argv);
 797
 798   // Process one command-line option.  This takes the index of argv to
 799   // process, and returns the index for the next option.
 800   int
 801   process_one_option(int argc, char** argv, int i, bool* no_more_options);
 802
 803   // Handle a -l option.
 804   int
 805   process_l_option(int, char**, char*, bool);
 806
 807   // Handle a --start-group option.
 808   void
 809   start_group(const char* arg);
 810
 811   // Handle a --end-group option.
 812   void
 813   end_group(const char* arg);
 814
 815   // Get an option argument--a helper function for special processing.
 816   const char*
 817   get_special_argument(const char* longname, int argc, char** argv,
 818                        const char* arg, bool long_option,
 819                        int *pret);
 820
 821   // Get the general options.
 822   const General_options&
 823   options() const
 824   { return this->options_; }
 825
 826   // Get the position dependent options.
 827   const Position_dependent_options&
 828   position_dependent_options() const
 829   { return this->position_options_; }
 830
 831   // The number of input files.
 832   int
 833   number_of_input_files() const
 834   { return this->inputs_.size(); }
 835
 836   // Iterators to iterate over the list of input files.
 837
 838   const_iterator
 839   begin() const
 840   { return this->inputs_.begin(); }
 841
 842   const_iterator
 843   end() const
 844   { return this->inputs_.end(); }
 845
 846  private:
 847   Command_line(const Command_line&);
 848   Command_line& operator=(const Command_line&);
 849
 850   // Report usage error.
 851   void
 852   usage() ATTRIBUTE_NORETURN;
 853   void
 854   usage(const char* msg, const char* opt) ATTRIBUTE_NORETURN;
 855   void
 856   usage(const char* msg, char opt) ATTRIBUTE_NORETURN;
 857
 858   // Apply a command line option.
 859   void
 860   apply_option(const gold::options::One_option&, const char*);
 861
 862   // Add a file.
 863   void
 864   add_file(const char* name, bool is_lib);
 865
 866   // Examine the result of processing the command-line, and verify
 867   // the flags do not contradict each other or are otherwise illegal.
 868   void
 869   normalize_options();
 870
 871   General_options options_;
 872   Position_dependent_options position_options_;
 873   Input_arguments inputs_;
 874 };
 875
 876 } // End namespace gold.
 877
 878 #endif // !defined(GOLD_OPTIONS_H)