Upload Tizen:Base source
[external/binutils.git] / gold / parameters.h
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)