parameters.h revision 1.1.1.2.8.1
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 26namespace gold 27{ 28 29class General_options; 30class Errors; 31class Timer; 32class Target; 33template<int size, bool big_endian> 34class Sized_target; 35class 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 51class 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 friend class Set_parameters_target_once; 187 188 Errors* errors_; 189 Timer* timer_; 190 const General_options* options_; 191 Target* target_; 192 bool doing_static_link_valid_; 193 bool doing_static_link_; 194 int debug_; 195 int incremental_mode_; 196 Set_parameters_target_once* set_parameters_target_once_; 197}; 198 199// This is a global variable. 200extern const Parameters* parameters; 201 202// We use free functions for these since they affect a global variable 203// that is internal to parameters.cc. 204 205extern void 206set_parameters_errors(Errors* errors); 207 208extern void 209set_parameters_timer(Timer* timer); 210 211extern void 212set_parameters_options(const General_options* options); 213 214extern void 215set_parameters_target(Target* target); 216 217extern void 218set_parameters_doing_static_link(bool doing_static_link); 219 220extern bool 221set_parameters_incremental_full(); 222 223// Ensure that the target to be valid by using the default target if 224// necessary. 225 226extern void 227parameters_force_valid_target(); 228 229// Clear the current target, for testing. 230 231extern void 232parameters_clear_target(); 233 234// Return whether we are doing a particular debugging type. The 235// argument is one of the flags from debug.h. 236 237inline bool 238is_debugging_enabled(unsigned int type) 239{ return (parameters->debug() & type) != 0; } 240 241} // End namespace gold. 242 243#endif // !defined(GOLD_PARAMETERS_H) 244