From Craig Silverstein and Ian Lance Taylor: Process --script option.
[external/binutils.git] / gold / parameters.h
1 // parameters.h -- general parameters for a link using gold  -*- C++ -*-
2
3 // Copyright 2006, 2007 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
32 // Here we define the Parameters class which simply holds simple
33 // general parameters which apply to the entire link.  We use a global
34 // variable for this.  This is in contrast to the General_options
35 // class, which holds the complete state of position independent
36 // command line options.  The hope is that Parameters will stay fairly
37 // simple, so that if this turns into a library it will be clear how
38 // these parameters should be set.
39
40 class Parameters
41 {
42  public:
43   Parameters(Errors*);
44
45   // Return the error object.
46   Errors*
47   errors() const
48   { return this->errors_; }
49
50   // Return the output file name.
51   const char*
52   output_file_name() const
53   {
54     gold_assert(this->options_valid_);
55     return this->output_file_name_;
56   }
57
58   // Whether we are generating a regular executable.
59   bool
60   output_is_executable() const
61   {
62     gold_assert(this->output_file_type_ != OUTPUT_INVALID);
63     return this->output_file_type_ == OUTPUT_EXECUTABLE;
64   }
65
66   // Whether we are generating a shared library.
67   bool
68   output_is_shared() const
69   {
70     gold_assert(this->output_file_type_ != OUTPUT_INVALID);
71     return this->output_file_type_ == OUTPUT_SHARED;
72   }
73
74   // Whether we are generating an object file.
75   bool
76   output_is_object() const
77   {
78     gold_assert(this->output_file_type_ != OUTPUT_INVALID);
79     return this->output_file_type_ == OUTPUT_OBJECT;
80   }
81
82   // Whether we are generating position-independent output.
83   // This is the case when generating either a shared library
84   // or a regular executable with the --pic-executable option.
85   // FIXME: support --pic-executable
86   bool
87   output_is_position_independent() const
88   { return output_is_shared(); }
89
90   // The target system root directory.  This is NULL if there isn't
91   // one.
92   const std::string&
93   sysroot() const
94   {
95     gold_assert(this->options_valid_);
96     return this->sysroot_;
97   }
98
99   // Whether to strip all symbols.
100   bool
101   strip_all() const
102   {
103     gold_assert(this->strip_ != STRIP_INVALID);
104     return this->strip_ == STRIP_ALL;
105   }
106
107   // Whether to strip debugging information.
108   bool
109   strip_debug() const
110   {
111     gold_assert(this->strip_ != STRIP_INVALID);
112     return this->strip_ == STRIP_ALL || this->strip_ == STRIP_DEBUG;
113   }
114
115   // Whether we are doing a symbolic link, in which all defined
116   // symbols are bound locally.
117   bool
118   symbolic() const
119   {
120     gold_assert(this->options_valid_);
121     return this->symbolic_;
122   }
123
124   // The general linker optimization level.
125   int
126   optimization_level() const
127   {
128     gold_assert(this->options_valid_);
129     return this->optimization_level_;
130   }
131
132   // Whether the -E/--export-dynamic flag is set.
133   bool
134   export_dynamic() const
135   {
136     gold_assert(this->options_valid_);
137     return this->export_dynamic_;
138   }
139
140   // Whether we are doing a static link--a link in which none of the
141   // input files are shared libraries.  This is only known after we
142   // have seen all the input files.
143   bool
144   doing_static_link() const
145   {
146     gold_assert(this->is_doing_static_link_valid_);
147     return this->doing_static_link_;
148   }
149
150   // The size of the output file we are generating.  This should
151   // return 32 or 64.
152   int
153   get_size() const
154   {
155     gold_assert(this->is_size_and_endian_valid_);
156     return this->size_;
157   }
158
159   // Whether the output is big endian.
160   bool
161   is_big_endian() const
162   {
163     gold_assert(this->is_size_and_endian_valid_);
164     return this->is_big_endian_;
165   }
166
167   // Set values recorded from options.
168   void
169   set_from_options(const General_options*);
170
171   // Set whether we are doing a static link.
172   void
173   set_doing_static_link(bool doing_static_link);
174
175   // Set the size and endianness.
176   void
177   set_size_and_endianness(int size, bool is_big_endian);
178
179  private:
180   // The types of output files.
181   enum Output_file_type
182     {
183       // Uninitialized.
184       OUTPUT_INVALID,
185       // Generating executable.
186       OUTPUT_EXECUTABLE,
187       // Generating shared library.
188       OUTPUT_SHARED,
189       // Generating object file.
190       OUTPUT_OBJECT
191     };
192
193   // Which symbols to strip.
194   enum Strip
195   {
196     // Uninitialize.
197     STRIP_INVALID,
198     // Don't strip any symbols.
199     STRIP_NONE,
200     // Strip all symbols.
201     STRIP_ALL,
202     // Strip debugging information.
203     STRIP_DEBUG
204   };
205
206   // A pointer to the error handling object.
207   Errors* errors_;
208
209   // Whether the fields set from the options are valid.
210   bool options_valid_;
211   // The output file name.
212   const char* output_file_name_;
213   // The type of the output file.
214   Output_file_type output_file_type_;
215   // The target system root directory.
216   std::string sysroot_;
217   // Which symbols to strip.
218   Strip strip_;
219   // Whether we are doing a symbolic link.
220   bool symbolic_;
221   // The optimization level.
222   int optimization_level_;
223   // Whether the -E/--export-dynamic flag is set.
224   bool export_dynamic_;
225
226   // Whether the doing_static_link_ field is valid.
227   bool is_doing_static_link_valid_;
228   // Whether we are doing a static link.
229   bool doing_static_link_;
230   // Whether the size_ and is_big_endian_ fields are valid.
231   bool is_size_and_endian_valid_;
232   // The size of the output file--32 or 64.
233   int size_;
234   // Whether the output file is big endian.
235   bool is_big_endian_;
236 };
237
238 // This is a global variable.
239 extern const Parameters* parameters;
240
241 // Initialize the global variable.
242 extern void initialize_parameters(Errors*);
243
244 // Set the options.
245 extern void set_parameters_from_options(const General_options*);
246
247 // Set the size and endianness of the global parameters variable.
248 extern void set_parameters_size_and_endianness(int size, bool is_big_endian);
249
250 // Set whether we are doing a static link.
251 extern void set_parameters_doing_static_link(bool doing_static_link);
252
253 } // End namespace gold.
254
255 #endif // !defined(GOLD_PARAMETERS_H)