parameters.h revision 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