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