Home | History | Annotate | Download | only in gold
      1 // parameters.h -- general parameters for a link using gold  -*- C++ -*-
      2 
      3 // Copyright (C) 2006-2014 Free Software Foundation, Inc.
      4 // Written by Ian Lance Taylor <iant (at) 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)
    247