gold/parameters.h

   1 // parameters.h -- general parameters for a link using gold  -*- C++ -*-
   2
   3 // Copyright 2006, 2007, 2008 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 #ifndef GOLD_PARAMETERS_H
  24 #define GOLD_PARAMETERS_H
  25
  26 namespace gold
  27 {
  28
  29 class General_options;
  30 class Errors;
  31 class Target;
  32
  33 // Here we define the Parameters class which simply holds simple
  34 // general parameters which apply to the entire link.  We use a global
  35 // variable for this.  The parameters class holds three types of data:
  36 //    1) An Errors struct.  Any part of the code that wants to log an
  37 //       error can use parameters->errors().
  38 //    2) A const General_options.  These are the options as read on
  39 //       the commandline.
  40 //    3) Target information, such as size and endian-ness.  This is
  41 //       available as soon as we've decided on the Target (after
  42 //       parsing the first .o file).
  43 //    4) Whether we're doing a static link or not.  This is set
  44 //       after all inputs have been read and we know if any is a
  45 //       dynamic library.
  46
  47 class Parameters
  48 {
  49  public:
  50   Parameters()
  51     : errors_(NULL), options_(NULL), target_(NULL),
  52       doing_static_link_valid_(false), doing_static_link_(false),
  53       debug_(0)
  54   { }
  55
  56   // These should be called as soon as they are known.
  57   void
  58   set_errors(Errors* errors);
  59
  60   void
  61   set_options(const General_options* options);
  62
  63   void
  64   set_target(const Target* target);
  65
  66   void
  67   set_doing_static_link(bool doing_static_link);
  68
  69   // Return the error object.
  70   Errors*
  71   errors() const
  72   { return this->errors_; }
  73
  74   // Whether the options are valid.  This should not normally be
  75   // called, but it is needed by gold_exit.
  76   bool
  77   options_valid() const
  78   { return this->options_ != NULL; }
  79
  80   // Return the options object.
  81   const General_options&
  82   options() const
  83   {
  84     gold_assert(this->options_valid());
  85     return *this->options_;
  86   }
  87
  88   // Return whether the target field has been set.
  89   bool
  90   target_valid() const
  91   { return this->target_ != NULL; }
  92
  93   // The target of the output file we are generating.
  94   const Target&
  95   target() const
  96   {
  97     gold_assert(this->target_valid());
  98     return *this->target_;
  99   }
 100
 101   // When we don't have an output file to associate a target, make a
 102   // default one, with guesses about size and endianness.
 103   const Target&
 104   default_target() const;
 105
 106   // Return true if TARGET is compatible with the current target.
 107   bool
 108   is_compatible_target(const Target*) const;
 109
 110   bool
 111   doing_static_link() const
 112   {
 113     gold_assert(this->doing_static_link_valid_);
 114     return this->doing_static_link_;
 115   }
 116
 117   // This is just a copy of options().debug().  We make a copy so we
 118   // don't have to #include options.h in order to inline
 119   // is_debugging_enabled, below.
 120   int
 121   debug() const
 122   {
 123     // This can be called before the options are set up.
 124     if (!this->options_valid())
 125       return 0;
 126     return debug_;
 127   }
 128
 129   // A convenience routine for combining size and endianness.  It also
 130   // checks the HAVE_TARGET_FOO configure options and dies if the
 131   // current target's size/endianness is not supported according to
 132   // HAVE_TARGET_FOO.  Otherwise it returns this enum
 133   enum Target_size_endianness
 134   { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG };
 135
 136   Target_size_endianness
 137   size_and_endianness() const;
 138
 139
 140  private:
 141   Errors* errors_;
 142   const General_options* options_;
 143   const Target* target_;
 144   bool doing_static_link_valid_;
 145   bool doing_static_link_;
 146   int debug_;
 147 };
 148
 149 // This is a global variable.
 150 extern const Parameters* parameters;
 151
 152 // We use free functions for these since they affect a global variable
 153 // that is internal to parameters.cc.
 154
 155 extern void
 156 set_parameters_errors(Errors* errors);
 157
 158 extern void
 159 set_parameters_options(const General_options* options);
 160
 161 extern void
 162 set_parameters_target(const Target* target);
 163
 164 extern void
 165 set_parameters_doing_static_link(bool doing_static_link);
 166
 167 // Return whether we are doing a particular debugging type.  The
 168 // argument is one of the flags from debug.h.
 169
 170 inline bool
 171 is_debugging_enabled(unsigned int type)
 172 { return (parameters->debug() & type) != 0; }
 173
 174 } // End namespace gold.
 175
 176 #endif // !defined(GOLD_PARAMETERS_H)