// parameters.h -- general parameters for a link using gold -*- C++ -*-
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
{
class General_options;
+class Errors;
+class Target;
+template<int size, bool big_endian>
+class Sized_target;
+class Set_parameters_target_once;
// Here we define the Parameters class which simply holds simple
// general parameters which apply to the entire link. We use a global
-// variable for this. This is in contrast to the General_options
-// class, which holds the complete state of position independent
-// command line options. The hope is that Parameters will stay fairly
-// simple, so that if this turns into a library it will be clear how
-// these parameters should be set.
+// variable for this. The parameters class holds three types of data:
+// 1) An Errors struct. Any part of the code that wants to log an
+// error can use parameters->errors().
+// 2) A const General_options. These are the options as read on
+// the commandline.
+// 3) Target information, such as size and endian-ness. This is
+// available as soon as we've decided on the Target (after
+// parsing the first .o file).
+// 4) Whether we're doing a static link or not. This is set
+// after all inputs have been read and we know if any is a
+// dynamic library.
class Parameters
{
public:
- Parameters(const General_options*);
+ Parameters();
- // Whether we are generating a regular executable.
- bool
- output_is_executable() const
- { return this->output_file_type_ == OUTPUT_EXECUTABLE; }
+ // These should be called as soon as they are known.
+ void
+ set_errors(Errors* errors);
- // Whether we are generating a shared library.
- bool
- output_is_shared() const
- { return this->output_file_type_ == OUTPUT_SHARED; }
+ void
+ set_options(const General_options* options);
+
+ void
+ set_target(Target* target);
+
+ void
+ set_doing_static_link(bool doing_static_link);
+
+ // Return the error object.
+ Errors*
+ errors() const
+ { return this->errors_; }
- // Whether we are generating an object file.
+ // Whether the options are valid. This should not normally be
+ // called, but it is needed by gold_exit.
bool
- output_is_object() const
- { return this->output_file_type_ == OUTPUT_OBJECT; }
+ options_valid() const
+ { return this->options_ != NULL; }
- // The target system root directory. This is NULL if there isn't
- // one.
- const std::string&
- sysroot() const
- { return this->sysroot_; }
+ // Return the options object.
+ const General_options&
+ options() const
+ {
+ gold_assert(this->options_valid());
+ return *this->options_;
+ }
- // Whether to strip all symbols.
+ // Return whether the target field has been set.
bool
- strip_all() const
- { return this->strip_ == STRIP_ALL; }
+ target_valid() const
+ { return this->target_ != NULL; }
+
+ // The target of the output file we are generating.
+ const Target&
+ target() const
+ {
+ gold_assert(this->target_valid());
+ return *this->target_;
+ }
+
+ // The Sized_target of the output file. The caller must request the
+ // right size and endianness.
+ template<int size, bool big_endian>
+ Sized_target<size, big_endian>*
+ sized_target() const
+ {
+ gold_assert(this->target_valid());
+ return static_cast<Sized_target<size, big_endian>*>(this->target_);
+ }
+
+ // Clear the target, for testing.
+ void
+ clear_target();
- // Whether to strip debugging information.
+ // Return true if TARGET is compatible with the current target.
bool
- strip_debug() const
- { return this->strip_ == STRIP_ALL || this->strip_ == STRIP_DEBUG; }
+ is_compatible_target(const Target*) const;
- // Whether we are doing a static link--a link in which none of the
- // input files are shared libraries. This is only known after we
- // have seen all the input files.
bool
doing_static_link() const
{
- gold_assert(this->is_doing_static_link_valid_);
+ gold_assert(this->doing_static_link_valid_);
return this->doing_static_link_;
}
- // The size of the output file we are generating. This should
- // return 32 or 64.
+ // This is just a copy of options().debug(). We make a copy so we
+ // don't have to #include options.h in order to inline
+ // is_debugging_enabled, below.
int
- get_size() const
+ debug() const
{
- gold_assert(this->is_size_and_endian_valid_);
- return this->size_;
+ // This can be called before the options are set up.
+ if (!this->options_valid())
+ return 0;
+ return debug_;
}
- // Whether the output is big endian.
- bool
- is_big_endian() const
- {
- gold_assert(this->is_size_and_endian_valid_);
- return this->is_big_endian_;
- }
+ // A convenience routine for combining size and endianness. It also
+ // checks the HAVE_TARGET_FOO configure options and dies if the
+ // current target's size/endianness is not supported according to
+ // HAVE_TARGET_FOO. Otherwise it returns this enum
+ enum Target_size_endianness
+ { TARGET_32_LITTLE, TARGET_32_BIG, TARGET_64_LITTLE, TARGET_64_BIG };
- // The general linker optimization level.
- int
- optimization_level() const
- { return this->optimization_level_; }
+ Target_size_endianness
+ size_and_endianness() const;
- // Set whether we are doing a static link.
+
+ private:
void
- set_doing_static_link(bool doing_static_link);
+ set_target_once(Target*);
- // Set the size and endianness.
void
- set_size_and_endianness(int size, bool is_big_endian);
+ check_target_endianness();
- private:
- // The types of output files.
- enum Output_file_type
- {
- // Generating executable.
- OUTPUT_EXECUTABLE,
- // Generating shared library.
- OUTPUT_SHARED,
- // Generating object file.
- OUTPUT_OBJECT
- };
-
- // Which symbols to strip.
- enum Strip
- {
- // Don't strip any symbols.
- STRIP_NONE,
- // Strip all symbols.
- STRIP_ALL,
- // Strip debugging information.
- STRIP_DEBUG
- };
-
- // The type of the output file.
- Output_file_type output_file_type_;
- // The target system root directory.
- std::string sysroot_;
- // Which symbols to strip.
- Strip strip_;
-
- // Whether the doing_static_link_ field is valid.
- bool is_doing_static_link_valid_;
- // Whether we are doing a static link.
+ friend class Set_parameters_target_once;
+
+ Errors* errors_;
+ const General_options* options_;
+ Target* target_;
+ bool doing_static_link_valid_;
bool doing_static_link_;
- // Whether the size_ and is_big_endian_ fields are valid.
- bool is_size_and_endian_valid_;
- // The size of the output file--32 or 64.
- int size_;
- // Whether the output file is big endian.
- bool is_big_endian_;
- // The optimization level.
- int optimization_level_;
+ int debug_;
+ Set_parameters_target_once* set_parameters_target_once_;
};
// This is a global variable.
extern const Parameters* parameters;
-// Initialize the global variable.
-extern void initialize_parameters(const General_options*);
+// We use free functions for these since they affect a global variable
+// that is internal to parameters.cc.
+
+extern void
+set_parameters_errors(Errors* errors);
+
+extern void
+set_parameters_options(const General_options* options);
+
+extern void
+set_parameters_target(Target* target);
+
+extern void
+set_parameters_doing_static_link(bool doing_static_link);
+
+// Ensure that the target to be valid by using the default target if
+// necessary.
+
+extern void
+parameters_force_valid_target();
+
+// Clear the current target, for testing.
+
+extern void
+parameters_clear_target();
-// Set the size and endianness of the global parameters variable.
-extern void set_parameters_size_and_endianness(int size, bool is_big_endian);
+// Return whether we are doing a particular debugging type. The
+// argument is one of the flags from debug.h.
-// Set whether we are doing a static link.
-extern void set_parameters_doing_static_link(bool doing_static_link);
+inline bool
+is_debugging_enabled(unsigned int type)
+{ return (parameters->debug() & type) != 0; }
} // End namespace gold.