parameters.h revision 1.1.1.2
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 Target; 32template<int size, bool big_endian> 33class Sized_target; 34class 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 50class 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. 182extern 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 187extern void 188set_parameters_errors(Errors* errors); 189 190extern void 191set_parameters_options(const General_options* options); 192 193extern void 194set_parameters_target(Target* target); 195 196extern void 197set_parameters_doing_static_link(bool doing_static_link); 198 199extern bool 200set_parameters_incremental_full(); 201 202// Ensure that the target to be valid by using the default target if 203// necessary. 204 205extern void 206parameters_force_valid_target(); 207 208// Clear the current target, for testing. 209 210extern void 211parameters_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 216inline bool 217is_debugging_enabled(unsigned int type) 218{ return (parameters->debug() & type) != 0; } 219 220} // End namespace gold. 221 222#endif // !defined(GOLD_PARAMETERS_H) 223