parameters.h revision 1.1.1.1
1// parameters.h -- general parameters for a link using gold -*- C++ -*- 2 3// Copyright 2006, 2007, 2008 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; 32 33// Here we define the Parameters class which simply holds simple 34// general parameters which apply to the entire link. We use a global 35// variable for this. The parameters class holds three types of data: 36// 1) An Errors struct. Any part of the code that wants to log an 37// error can use parameters->errors(). 38// 2) A const General_options. These are the options as read on 39// the commandline. 40// 3) Target information, such as size and endian-ness. This is 41// available as soon as we've decided on the Target (after 42// parsing the first .o file). 43// 4) Whether we're doing a static link or not. This is set 44// after all inputs have been read and we know if any is a 45// dynamic library. 46 47class Parameters 48{ 49 public: 50 Parameters() 51 : errors_(NULL), options_(NULL), target_(NULL), 52 doing_static_link_valid_(false), doing_static_link_(false), 53 debug_(0) 54 { } 55 56 // These should be called as soon as they are known. 57 void 58 set_errors(Errors* errors); 59 60 void 61 set_options(const General_options* options); 62 63 void 64 set_target(const Target* target); 65 66 void 67 set_doing_static_link(bool doing_static_link); 68 69 // Return the error object. 70 Errors* 71 errors() const 72 { return this->errors_; } 73 74 // Whether the options are valid. This should not normally be 75 // called, but it is needed by gold_exit. 76 bool 77 options_valid() const 78 { return this->options_ != NULL; } 79 80 // Return the options object. 81 const General_options& 82 options() const 83 { 84 gold_assert(this->options_valid()); 85 return *this->options_; 86 } 87 88 // Return whether the target field has been set. 89 bool 90 target_valid() const 91 { return this->target_ != NULL; } 92 93 // The target of the output file we are generating. 94 const Target& 95 target() const 96 { 97 gold_assert(this->target_valid()); 98 return *this->target_; 99 } 100 101 // When we don't have an output file to associate a target, make a 102 // default one, with guesses about size and endianness. 103 const Target& 104 default_target() const; 105 106 bool 107 doing_static_link() const 108 { 109 gold_assert(this->doing_static_link_valid_); 110 return this->doing_static_link_; 111 } 112 113 // This is just a copy of options().debug(). We make a copy so we 114 // don't have to #include options.h in order to inline 115 // is_debugging_enabled, below. 116 int 117 debug() const 118 { 119 // This can be called before the options are set up. 120 if (!this->options_valid()) 121 return 0; 122 return debug_; 123 } 124 125 // A convenience routine for combining size and endianness. It also 126 // checks the HAVE_TARGET_FOO configure options and dies if the 127 // current target's size/endianness is not supported according to 128 // HAVE_TARGET_FOO. Otherwise it returns this enum 129 enum Target_size_endianness 130 { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG }; 131 132 Target_size_endianness 133 size_and_endianness() const; 134 135 136 private: 137 Errors* errors_; 138 const General_options* options_; 139 const Target* target_; 140 bool doing_static_link_valid_; 141 bool doing_static_link_; 142 int debug_; 143}; 144 145// This is a global variable. 146extern const Parameters* parameters; 147 148// We use free functions for these since they affect a global variable 149// that is internal to parameters.cc. 150 151extern void 152set_parameters_errors(Errors* errors); 153 154extern void 155set_parameters_options(const General_options* options); 156 157extern void 158set_parameters_target(const Target* target); 159 160extern void 161set_parameters_doing_static_link(bool doing_static_link); 162 163// Return whether we are doing a particular debugging type. The 164// argument is one of the flags from debug.h. 165 166inline bool 167is_debugging_enabled(unsigned int type) 168{ return (parameters->debug() & type) != 0; } 169 170} // End namespace gold. 171 172#endif // !defined(GOLD_PARAMETERS_H) 173