1 // parameters.h -- general parameters for a link using gold -*- C++ -*- 2 3 // Copyright (C) 2006-2016 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) 247