gold/parameters.h

   1 // parameters.h -- general parameters for a link using gold  -*- C++ -*-
   2
   3 // Copyright (C) 2006-2023 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 Timer;
  32 class Target;
  33 template<int size, bool big_endian>
  34 class Sized_target;
  35 class Set_parameters_target_once;
  36
  37 // Here we define the Parameters class which simply holds simple
  38 // general parameters which apply to the entire link.  We use a global
  39 // variable for this.  The parameters class holds three types of data:
  40 //    1) An Errors struct.  Any part of the code that wants to log an
  41 //       error can use parameters->errors().
  42 //    2) A const General_options.  These are the options as read on
  43 //       the commandline.
  44 //    3) Target information, such as size and endian-ness.  This is
  45 //       available as soon as we've decided on the Target (after
  46 //       parsing the first .o file).
  47 //    4) Whether we're doing a static link or not.  This is set
  48 //       after all inputs have been read and we know if any is a
  49 //       dynamic library.
  50
  51 class Parameters
  52 {
  53  public:
  54   Parameters();
  55
  56   // These should be called as soon as they are known.
  57   void
  58   set_errors(Errors* errors);
  59
  60   void
  61   set_timer(Timer* timer);
  62
  63   void
  64   set_options(const General_options* options);
  65
  66   void
  67   set_target(Target* target);
  68
  69   void
  70   set_doing_static_link(bool doing_static_link);
  71
  72   // Return the error object.
  73   Errors*
  74   errors() const
  75   { return this->errors_; }
  76
  77   // Return the timer object.
  78   Timer*
  79   timer() const
  80   { return this->timer_; }
  81
  82   // Whether the options are valid.  This should not normally be
  83   // called, but it is needed by gold_exit.
  84   bool
  85   options_valid() const
  86   { return this->options_ != NULL; }
  87
  88   // Return the options object.
  89   const General_options&
  90   options() const
  91   {
  92     gold_assert(this->options_valid());
  93     return *this->options_;
  94   }
  95
  96   // Return whether the target field has been set.
  97   bool
  98   target_valid() const
  99   { return this->target_ != NULL; }
 100
 101   // The target of the output file we are generating.
 102   const Target&
 103   target() const
 104   {
 105     gold_assert(this->target_valid());
 106     return *this->target_;
 107   }
 108
 109   // The Sized_target of the output file.  The caller must request the
 110   // right size and endianness.
 111   template<int size, bool big_endian>
 112   Sized_target<size, big_endian>*
 113   sized_target() const
 114   {
 115     gold_assert(this->target_valid());
 116     return static_cast<Sized_target<size, big_endian>*>(this->target_);
 117   }
 118
 119   // Clear the target, for testing.
 120   void
 121   clear_target();
 122
 123   // Return true if TARGET is compatible with the current target.
 124   bool
 125   is_compatible_target(const Target*) const;
 126
 127   bool
 128   doing_static_link() const
 129   {
 130     gold_assert(this->doing_static_link_valid_);
 131     return this->doing_static_link_;
 132   }
 133
 134   // This is just a copy of options().debug().  We make a copy so we
 135   // don't have to #include options.h in order to inline
 136   // is_debugging_enabled, below.
 137   int
 138   debug() const
 139   {
 140     // This can be called before the options are set up.
 141     if (!this->options_valid())
 142       return 0;
 143     return debug_;
 144   }
 145
 146   // Return the name of the entry symbol.
 147   const char*
 148   entry() const;
 149
 150   // A convenience routine for combining size and endianness.  It also
 151   // checks the HAVE_TARGET_FOO configure options and dies if the
 152   // current target's size/endianness is not supported according to
 153   // HAVE_TARGET_FOO.  Otherwise it returns this enum
 154   enum Target_size_endianness
 155   { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG };
 156
 157   Target_size_endianness
 158   size_and_endianness() const;
 159
 160   // Set the incremental linking mode to INCREMENTAL_FULL.  Used when
 161   // the linker determines that an incremental update is not possible.
 162   // Returns false if the incremental mode was INCREMENTAL_UPDATE,
 163   // indicating that the linker should exit if an update is not possible.
 164   bool
 165   set_incremental_full();
 166
 167   // Return true if we need to prepare incremental linking information.
 168   bool
 169   incremental() const;
 170
 171   // Return true if we are doing a full incremental link.
 172   bool
 173   incremental_full() const;
 174
 175   // Return true if we are doing an incremental update.
 176   bool
 177   incremental_update() const;
 178
 179  private:
 180   void
 181   set_target_once(Target*);
 182
 183   void
 184   check_target_endianness();
 185
 186   void
 187   check_rodata_segment();
 188
 189   friend class Set_parameters_target_once;
 190
 191   Errors* errors_;
 192   Timer* timer_;
 193   const General_options* options_;
 194   Target* target_;
 195   bool doing_static_link_valid_;
 196   bool doing_static_link_;
 197   int debug_;
 198   int incremental_mode_;
 199   Set_parameters_target_once* set_parameters_target_once_;
 200 };
 201
 202 // This is a global variable.
 203 extern const Parameters* parameters;
 204
 205 // We use free functions for these since they affect a global variable
 206 // that is internal to parameters.cc.
 207
 208 extern void
 209 set_parameters_errors(Errors* errors);
 210
 211 extern void
 212 set_parameters_timer(Timer* timer);
 213
 214 extern void
 215 set_parameters_options(const General_options* options);
 216
 217 extern void
 218 set_parameters_target(Target* target);
 219
 220 extern void
 221 set_parameters_doing_static_link(bool doing_static_link);
 222
 223 extern bool
 224 set_parameters_incremental_full();
 225
 226 // Ensure that the target to be valid by using the default target if
 227 // necessary.
 228
 229 extern void
 230 parameters_force_valid_target();
 231
 232 // Clear the current target, for testing.
 233
 234 extern void
 235 parameters_clear_target();
 236
 237 // Return whether we are doing a particular debugging type.  The
 238 // argument is one of the flags from debug.h.
 239
 240 inline bool
 241 is_debugging_enabled(unsigned int type)
 242 { return (parameters->debug() & type) != 0; }
 243
 244 } // End namespace gold.
 245
 246 #endif // !defined(GOLD_PARAMETERS_H)