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 namespace gold
  41 {
  42
  43 class Command_line;
  44 class Input_file_group;
  45
  46 namespace options {
  47
  48 class Command_line_options;
  49 struct One_option;
  50
  51 } // End namespace gold::options.
  52
  53 // The position independent options which apply to the whole link.
  54 // There are a lot of them.
  55
  56 class General_options
  57 {
  58  public:
  59   General_options();
  60
  61   // -E: export dynamic symbols.
  62   bool
  63   export_dynamic() const
  64   { return this->export_dynamic_; }
  65
  66   // -I: dynamic linker name.
  67   const char*
  68   dynamic_linker() const
  69   { return this->dynamic_linker_; }
  70
  71   // -L: Library search path.
  72   typedef std::vector<const char*> Dir_list;
  73
  74   const Dir_list&
  75   search_path() const
  76   { return this->search_path_; }
  77
  78   // -O: optimization level (0: don't try to optimize output size).
  79   int
  80   optimization_level() const
  81   { return this->optimization_level_; }
  82
  83   // -o: Output file name.
  84   const char*
  85   output_file_name() const
  86   { return this->output_file_name_; }
  87
  88   // -r: Whether we are doing a relocatable link.
  89   bool
  90   is_relocatable() const
  91   { return this->is_relocatable_; }
  92
  93   // --eh-frame-hdr: Whether to generate an exception frame header.
  94   bool
  95   create_eh_frame_hdr() const
  96   { return this->create_eh_frame_hdr_; }
  97
  98   // --rpath: The runtime search path.
  99   const Dir_list&
 100   rpath() const
 101   { return this->rpath_; }
 102
 103   // --rpath-link: The link time search patch for shared libraries.
 104   const Dir_list&
 105   rpath_link() const
 106   { return this->rpath_link_; }
 107
 108   // --shared: Whether generating a shared object.
 109   bool
 110   is_shared() const
 111   { return this->is_shared_; }
 112
 113   // --static: Whether doing a static link.
 114   bool
 115   is_static() const
 116   { return this->is_static_; }
 117
 118  private:
 119   // Don't copy this structure.
 120   General_options(const General_options&);
 121   General_options& operator=(const General_options&);
 122
 123   friend class Command_line;
 124   friend class options::Command_line_options;
 125
 126   void
 127   set_export_dynamic()
 128   { this->export_dynamic_ = true; }
 129
 130   void
 131   set_dynamic_linker(const char* arg)
 132   { this->dynamic_linker_ = arg; }
 133
 134   void
 135   add_to_search_path(const char* arg)
 136   { this->search_path_.push_back(arg); }
 137
 138   void
 139   set_optimization_level(const char* arg)
 140   { this->optimization_level_ = atoi(arg); }
 141
 142   void
 143   set_output_file_name(const char* arg)
 144   { this->output_file_name_ = arg; }
 145
 146   void
 147   set_relocatable()
 148   { this->is_relocatable_ = true; }
 149
 150   void
 151   set_create_eh_frame_hdr()
 152   { this->create_eh_frame_hdr_ = true; }
 153
 154   void
 155   add_to_rpath(const char* arg)
 156   { this->rpath_.push_back(arg); }
 157
 158   void
 159   add_to_rpath_link(const char* arg)
 160   { this->rpath_link_.push_back(arg); }
 161
 162   void
 163   set_shared()
 164   { this->is_shared_ = true; }
 165
 166   void
 167   set_static()
 168   { this->is_static_ = true; }
 169
 170   void
 171   ignore(const char*)
 172   { }
 173
 174   bool export_dynamic_;
 175   const char* dynamic_linker_;
 176   Dir_list search_path_;
 177   int optimization_level_;
 178   const char* output_file_name_;
 179   bool is_relocatable_;
 180   bool create_eh_frame_hdr_;
 181   Dir_list rpath_;
 182   Dir_list rpath_link_;
 183   bool is_shared_;
 184   bool is_static_;
 185 };
 186
 187 // The current state of the position dependent options.
 188
 189 class Position_dependent_options
 190 {
 191  public:
 192   Position_dependent_options();
 193
 194   // -Bstatic: Whether we are searching for a static archive rather
 195   // than a shared object.
 196   bool
 197   do_static_search() const
 198   { return this->do_static_search_; }
 199
 200   // --as-needed: Whether to add a DT_NEEDED argument only if the
 201   // dynamic object is used.
 202   bool
 203   as_needed() const
 204   { return this->as_needed_; }
 205
 206   // --whole-archive: Whether to include the entire contents of an
 207   // --archive.
 208   bool
 209   include_whole_archive() const
 210   { return this->include_whole_archive_; }
 211
 212   void
 213   set_static_search()
 214   { this->do_static_search_ = true; }
 215
 216   void
 217   set_dynamic_search()
 218   { this->do_static_search_ = false; }
 219
 220   void
 221   set_as_needed()
 222   { this->as_needed_ = true; }
 223
 224   void
 225   clear_as_needed()
 226   { this->as_needed_ = false; }
 227
 228   void
 229   set_whole_archive()
 230   { this->include_whole_archive_ = true; }
 231
 232   void
 233   clear_whole_archive()
 234   { this->include_whole_archive_ = false; }
 235
 236  private:
 237   bool do_static_search_;
 238   bool as_needed_;
 239   bool include_whole_archive_;
 240 };
 241
 242 // A single file or library argument from the command line.
 243
 244 class Input_file_argument
 245 {
 246  public:
 247   // name: file name or library name
 248   // is_lib: true if name is a library name: that is, emits the leading
 249   //         "lib" and trailing ".so"/".a" from the name
 250   // extra_search_path: an extra directory to look for the file, prior
 251   //         to checking the normal library search path.  If this is "",
 252   //         then no extra directory is added.
 253   // options: The position dependent options at this point in the
 254   //         command line, such as --group.
 255   Input_file_argument()
 256     : name_(), is_lib_(false), extra_search_path_(""), options_()
 257   { }
 258
 259   Input_file_argument(const char* name, bool is_lib,
 260                       const char* extra_search_path,
 261                       const Position_dependent_options& options)
 262     : name_(name), is_lib_(is_lib), extra_search_path_(extra_search_path),
 263       options_(options)
 264   { }
 265
 266   const char*
 267   name() const
 268   { return this->name_.c_str(); }
 269
 270   const Position_dependent_options&
 271   options() const
 272   { return this->options_; }
 273
 274   bool
 275   is_lib() const
 276   { return this->is_lib_; }
 277
 278   const char*
 279   extra_search_path() const
 280   {
 281     return (this->extra_search_path_.empty()
 282             ? NULL
 283             : this->extra_search_path_.c_str());
 284   }
 285
 286   // Return whether this file may require a search using the -L
 287   // options.
 288   bool
 289   may_need_search() const
 290   { return this->is_lib_ || !this->extra_search_path_.empty(); }
 291
 292  private:
 293   // We use std::string, not const char*, here for convenience when
 294   // using script files, so that we do not have to preserve the string
 295   // in that case.
 296   std::string name_;
 297   bool is_lib_;
 298   std::string extra_search_path_;
 299   Position_dependent_options options_;
 300 };
 301
 302 // A file or library, or a group, from the command line.
 303
 304 class Input_argument
 305 {
 306  public:
 307   // Create a file or library argument.
 308   explicit Input_argument(Input_file_argument file)
 309     : is_file_(true), file_(file), group_(NULL)
 310   { }
 311
 312   // Create a group argument.
 313   explicit Input_argument(Input_file_group* group)
 314     : is_file_(false), group_(group)
 315   { }
 316
 317   // Return whether this is a file.
 318   bool
 319   is_file() const
 320   { return this->is_file_; }
 321
 322   // Return whether this is a group.
 323   bool
 324   is_group() const
 325   { return !this->is_file_; }
 326
 327   // Return the information about the file.
 328   const Input_file_argument&
 329   file() const
 330   {
 331     gold_assert(this->is_file_);
 332     return this->file_;
 333   }
 334
 335   // Return the information about the group.
 336   const Input_file_group*
 337   group() const
 338   {
 339     gold_assert(!this->is_file_);
 340     return this->group_;
 341   }
 342
 343   Input_file_group*
 344   group()
 345   {
 346     gold_assert(!this->is_file_);
 347     return this->group_;
 348   }
 349
 350  private:
 351   bool is_file_;
 352   Input_file_argument file_;
 353   Input_file_group* group_;
 354 };
 355
 356 // A group from the command line.  This is a set of arguments within
 357 // --start-group ... --end-group.
 358
 359 class Input_file_group
 360 {
 361  public:
 362   typedef std::vector<Input_argument> Files;
 363   typedef Files::const_iterator const_iterator;
 364
 365   Input_file_group()
 366     : files_()
 367   { }
 368
 369   // Add a file to the end of the group.
 370   void
 371   add_file(const Input_file_argument& arg)
 372   { this->files_.push_back(Input_argument(arg)); }
 373
 374   // Iterators to iterate over the group contents.
 375
 376   const_iterator
 377   begin() const
 378   { return this->files_.begin(); }
 379
 380   const_iterator
 381   end() const
 382   { return this->files_.end(); }
 383
 384  private:
 385   Files files_;
 386 };
 387
 388 // A list of files from the command line or a script.
 389
 390 class Input_arguments
 391 {
 392  public:
 393   typedef std::vector<Input_argument> Input_argument_list;
 394   typedef Input_argument_list::const_iterator const_iterator;
 395
 396   Input_arguments()
 397     : input_argument_list_(), in_group_(false)
 398   { }
 399
 400   // Add a file.
 401   void
 402   add_file(const Input_file_argument& arg);
 403
 404   // Start a group (the --start-group option).
 405   void
 406   start_group();
 407
 408   // End a group (the --end-group option).
 409   void
 410   end_group();
 411
 412   // Return whether we are currently in a group.
 413   bool
 414   in_group() const
 415   { return this->in_group_; }
 416
 417   // Iterators to iterate over the list of input files.
 418
 419   const_iterator
 420   begin() const
 421   { return this->input_argument_list_.begin(); }
 422
 423   const_iterator
 424   end() const
 425   { return this->input_argument_list_.end(); }
 426
 427   // Return whether the list is empty.
 428   bool
 429   empty() const
 430   { return this->input_argument_list_.empty(); }
 431
 432  private:
 433   Input_argument_list input_argument_list_;
 434   bool in_group_;
 435 };
 436
 437 // All the information read from the command line.
 438
 439 class Command_line
 440 {
 441  public:
 442   typedef Input_arguments::const_iterator const_iterator;
 443
 444   Command_line();
 445
 446   // Process the command line options.  This will exit with an
 447   // appropriate error message if an unrecognized option is seen.
 448   void
 449   process(int argc, char** argv);
 450
 451   // Handle a -l option.
 452   int
 453   process_l_option(int, char**, char*);
 454
 455   // Handle a --start-group option.
 456   void
 457   start_group(const char* arg);
 458
 459   // Handle a --end-group option.
 460   void
 461   end_group(const char* arg);
 462
 463   // Get the general options.
 464   const General_options&
 465   options() const
 466   { return this->options_; }
 467
 468   // Iterators to iterate over the list of input files.
 469
 470   const_iterator
 471   begin() const
 472   { return this->inputs_.begin(); }
 473
 474   const_iterator
 475   end() const
 476   { return this->inputs_.end(); }
 477
 478  private:
 479   Command_line(const Command_line&);
 480   Command_line& operator=(const Command_line&);
 481
 482   // Report usage error.
 483   void
 484   usage() ATTRIBUTE_NORETURN;
 485   void
 486   usage(const char* msg, const char* opt) ATTRIBUTE_NORETURN;
 487   void
 488   usage(const char* msg, char opt) ATTRIBUTE_NORETURN;
 489
 490   // Apply a command line option.
 491   void
 492   apply_option(const gold::options::One_option&, const char*);
 493
 494   // Add a file.
 495   void
 496   add_file(const char* name, bool is_lib);
 497
 498   General_options options_;
 499   Position_dependent_options position_options_;
 500   Input_arguments inputs_;
 501 };
 502
 503 } // End namespace gold.
 504
 505 #endif // !defined(GOLD_OPTIONS_H)