// parameters.h -- general parameters for a link using gold -*- C++ -*- // Copyright 2006, 2007 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, // MA 02110-1301, USA. #ifndef GOLD_PARAMETERS_H #define GOLD_PARAMETERS_H namespace gold { class General_options; class Errors; class Target; // 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. class Parameters { public: Parameters(Errors*); // Return the error object. Errors* errors() const { return this->errors_; } // Whether the options are valid. This should not normally be // called, but it is needed by gold_exit. bool options_valid() const { return this->options_valid_; } // Whether to use threads. bool threads() const { gold_assert(this->options_valid_); return this->threads_; } // Return the output file name. const char* output_file_name() const { gold_assert(this->options_valid_); return this->output_file_name_; } // Whether we are generating a regular executable. bool output_is_executable() const { gold_assert(this->output_file_type_ != OUTPUT_INVALID); return this->output_file_type_ == OUTPUT_EXECUTABLE; } // Whether we are generating a shared library. bool output_is_shared() const { gold_assert(this->output_file_type_ != OUTPUT_INVALID); return this->output_file_type_ == OUTPUT_SHARED; } // Whether we are generating an object file. bool output_is_object() const { gold_assert(this->output_file_type_ != OUTPUT_INVALID); return this->output_file_type_ == OUTPUT_OBJECT; } // Whether we are generating position-independent output. // This is the case when generating either a shared library // or a regular executable with the --pic-executable option. // FIXME: support --pic-executable bool output_is_position_independent() const { return output_is_shared(); } // The target system root directory. This is NULL if there isn't // one. const std::string& sysroot() const { gold_assert(this->options_valid_); return this->sysroot_; } // Whether to strip all symbols. bool strip_all() const { gold_assert(this->strip_ != STRIP_INVALID); return this->strip_ == STRIP_ALL; } // Whether to strip debugging information. bool strip_debug() const { gold_assert(this->strip_ != STRIP_INVALID); return this->strip_ == STRIP_ALL || this->strip_ == STRIP_DEBUG; } // Whether to strip debugging information that's not used by gdb. bool strip_debug_gdb() const { gold_assert(this->strip_ != STRIP_INVALID); return this->strip_debug() || this->strip_ == STRIP_DEBUG_UNUSED_BY_GDB; } // Whether to permit unresolved references from shared libraries. bool allow_shlib_undefined() const { gold_assert(this->options_valid_); return this->allow_shlib_undefined_; } // Whether we are doing a symbolic link, in which all defined // symbols are bound locally. bool symbolic() const { gold_assert(this->options_valid_); return this->symbolic_; } // Whether we should demangle C++ symbols in our log messages. bool demangle() const { return this->demangle_; } // Whether we should try to detect violations of the One Definition Rule. bool detect_odr_violations() const { gold_assert(this->options_valid_); return this->detect_odr_violations_; } // The general linker optimization level. int optimization_level() const { gold_assert(this->options_valid_); return this->optimization_level_; } // Whether the -E/--export-dynamic flag is set. bool export_dynamic() const { gold_assert(this->options_valid_); return this->export_dynamic_; } // Return the debug flags. These are the flags for which we should // report internal debugging information. unsigned int debug() const { gold_assert(this->options_valid_); return this->debug_; } // 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_); return this->doing_static_link_; } // The target of the output file we are generating. Target* target() const { gold_assert(this->is_target_valid_); return this->target_; } // The size of the output file we are generating. This should // return 32 or 64. int get_size() const { gold_assert(this->is_target_valid_); return this->size_; } // Whether the output is big endian. bool is_big_endian() const { gold_assert(this->is_target_valid_); return this->is_big_endian_; } // Set values recorded from options. void set_from_options(const General_options*); // Set whether we are doing a static link. void set_doing_static_link(bool doing_static_link); // Set the target. void set_target(Target* target); private: // The types of output files. enum Output_file_type { // Uninitialized. OUTPUT_INVALID, // Generating executable. OUTPUT_EXECUTABLE, // Generating shared library. OUTPUT_SHARED, // Generating object file. OUTPUT_OBJECT }; // Which symbols to strip. enum Strip { // Uninitialize. STRIP_INVALID, // Don't strip any symbols. STRIP_NONE, // Strip all symbols. STRIP_ALL, // Strip debugging information. STRIP_DEBUG, // Strip debugging information that's not used by gdb (at least <= 6.7) STRIP_DEBUG_UNUSED_BY_GDB }; // A pointer to the error handling object. Errors* errors_; // Whether the fields set from the options are valid. bool options_valid_; // Whether to use threads. bool threads_; // The output file name. const char* output_file_name_; // 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 to allow undefined references from shared libraries. bool allow_shlib_undefined_; // Whether we are doing a symbolic link. bool symbolic_; // Whether we should demangle C++ symbols in our log messages. bool demangle_; // Whether we try to detect One Definition Rule violations. bool detect_odr_violations_; // The optimization level. int optimization_level_; // Whether the -E/--export-dynamic flag is set. bool export_dynamic_; // The debug flags. unsigned int debug_; // Whether the doing_static_link_ field is valid. bool is_doing_static_link_valid_; // Whether we are doing a static link. bool doing_static_link_; // Whether the target_ field is valid. bool is_target_valid_; // The target. Target* target_; // The size of the output file--32 or 64. int size_; // Whether the output file is big endian. bool is_big_endian_; }; // This is a global variable. extern const Parameters* parameters; // Initialize the global variable. extern void initialize_parameters(Errors*); // Set the options. extern void set_parameters_from_options(const General_options*); // Set the target recorded in the global parameters variable. extern void set_parameters_target(Target* target); // Set whether we are doing a static link. extern void set_parameters_doing_static_link(bool doing_static_link); // Return whether we are doing a particular debugging type. The // argument is one of the flags from debug.h. inline bool is_debugging_enabled(unsigned int type) { return (parameters->debug() & type) != 0; } } // End namespace gold. #endif // !defined(GOLD_PARAMETERS_H)