#include <cstdlib>
#include <cstring>
#include <list>
+#include <map>
#include <string>
#include <vector>
class General_options;
class Search_directory;
class Input_file_group;
+class Input_file_lib;
class Position_dependent_options;
class Target;
class Plugin_manager;
// var() and set_var() as General_options methods. Arguments as are
// for the constructor for One_option. param_type__ is the same as
// type__ for built-in types, and "const type__ &" otherwise.
+//
+// When we define the linker command option "assert", the macro argument
+// varname__ of DEFINE_var below will be replaced by "assert". On Mac OSX
+// assert.h is included implicitly by one of the library headers we use. To
+// avoid unintended macro substitution of "assert()", we need to enclose
+// varname__ with parenthese.
#define DEFINE_var(varname__, dashes__, shortname__, default_value__, \
default_value_as_string__, helpstring__, helparg__, \
optional_arg__, type__, param_type__, parse_fn__) \
public: \
param_type__ \
- varname__() const \
+ (varname__)() const \
{ return this->varname__##_.value; } \
\
bool \
void \
parse_to_value(const char*, const char*, \
Command_line*, General_options* options) \
- { options->set_##varname__(false); } \
+ { \
+ options->set_##varname__(false); \
+ options->set_user_set_##varname__(); \
+ } \
\
options::One_option option; \
}; \
N_("Export all dynamic symbols"),
N_("Do not export all dynamic symbols (default)"));
+ DEFINE_special(EB, options::ONE_DASH, '\0',
+ N_("Link big-endian objects."), NULL);
+
DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false,
N_("Create exception frame header"), NULL);
+ DEFINE_special(EL, options::ONE_DASH, '\0',
+ N_("Link little-endian objects."), NULL);
+
+ DEFINE_bool(enum_size_warning, options::TWO_DASHES, '\0', true, NULL,
+ N_("(ARM only) Do not warn about objects with incompatible "
+ "enum sizes"));
+
DEFINE_bool(fatal_warnings, options::TWO_DASHES, '\0', false,
N_("Treat warnings as errors"),
N_("Do not treat warnings as errors"));
DEFINE_string(fini, options::ONE_DASH, '\0', "_fini",
N_("Call SYMBOL at unload-time"), N_("SYMBOL"));
+ DEFINE_bool(fix_cortex_a8, options::TWO_DASHES, '\0', false,
+ N_("(ARM only) Fix binaries for Cortex-A8 erratum."),
+ N_("(ARM only) Do not fix binaries for Cortex-A8 erratum."));
+
+ DEFINE_bool(merge_exidx_entries, options::TWO_DASHES, '\0', true,
+ N_("(ARM only) Merge exidx entries in debuginfo."),
+ N_("(ARM only) Do not merge exidx entries in debuginfo."));
+
+ DEFINE_special(fix_v4bx, options::TWO_DASHES, '\0',
+ N_("(ARM only) Rewrite BX rn as MOV pc, rn for ARMv4"),
+ NULL);
+
+ DEFINE_special(fix_v4bx_interworking, options::TWO_DASHES, '\0',
+ N_("(ARM only) Rewrite BX rn branch to ARMv4 interworking "
+ "veneer"),
+ NULL);
+
DEFINE_bool(g, options::EXACTLY_ONE_DASH, '\0', false,
N_("Ignored"), NULL);
DEFINE_special(just_symbols, options::TWO_DASHES, '\0',
N_("Read only symbol values from FILE"), N_("FILE"));
- DEFINE_bool(keep_files_mapped, options::TWO_DASHES, '\0',
+ DEFINE_bool(map_whole_files, options::TWO_DASHES, '\0',
sizeof(void*) >= 8,
N_("Map whole files to memory (default on 64-bit hosts)"),
N_("Map relevant file parts to memory (default on 32-bit "
"hosts)"));
+ DEFINE_bool(keep_files_mapped, options::TWO_DASHES, '\0', true,
+ N_("Keep files mapped across passes (default)"),
+ N_("Release mapped files after each pass"));
DEFINE_special(library, options::TWO_DASHES, 'l',
N_("Search for library LIBNAME"), N_("LIBNAME"));
DEFINE_dirlist(library_path, options::TWO_DASHES, 'L',
N_("Add directory to search path"), N_("DIR"));
+ DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false,
+ N_(" Only search directories specified on the command line."),
+ NULL);
+
+ DEFINE_bool(rosegment, options::TWO_DASHES, '\0', false,
+ N_(" Put read-only non-executable sections in their own segment"),
+ NULL);
+
DEFINE_string(m, options::EXACTLY_ONE_DASH, 'm', "",
N_("Ignored for compatibility"), N_("EMULATION"));
DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
N_("Set output format"), N_("[binary]"));
+ DEFINE_bool(p, options::ONE_DASH, '\0', false,
+ N_("(ARM only) Ignore for backward compatibility"), NULL);
+
DEFINE_bool(pie, options::ONE_DASH, '\0', false,
N_("Create a position independent executable"), NULL);
DEFINE_bool_alias(pic_executable, pie, options::TWO_DASHES, '\0',
N_("Create a position independent executable"), NULL,
false);
+ DEFINE_bool(pipeline_knowledge, options::ONE_DASH, '\0', false,
+ NULL, N_("(ARM only) Ignore for backward compatibility"));
+
#ifdef ENABLE_PLUGINS
DEFINE_special(plugin, options::TWO_DASHES, '\0',
N_("Load a plugin library"), N_("PLUGIN"));
N_("Add DIR to link time shared library search path"),
N_("DIR"));
+ DEFINE_string(section_ordering_file, options::TWO_DASHES, '\0', NULL,
+ N_("Layout sections in the order specified."),
+ N_("FILENAME"));
+
+ DEFINE_special(section_start, options::TWO_DASHES, '\0',
+ N_("Set address of section"), N_("SECTION=ADDRESS"));
+
DEFINE_optional_string(sort_common, options::TWO_DASHES, '\0', NULL,
N_("Sort common symbols by alignment"),
N_("[={ascending,descending}]"));
+ DEFINE_uint(spare_dynamic_tags, options::TWO_DASHES, '\0', 5,
+ N_("Dynamic tag slots to reserve (default 5)"),
+ N_("COUNT"));
+
DEFINE_bool(strip_all, options::TWO_DASHES, 's', false,
N_("Strip all symbols"), NULL);
DEFINE_bool(strip_debug, options::TWO_DASHES, 'S', false,
DEFINE_enum(icf, options::TWO_DASHES, '\0', "none",
N_("Identical Code Folding. "
- "\'--icf=safe\' folds only ctors and dtors."),
+ "\'--icf=safe\' Folds ctors, dtors and functions whose"
+ " pointers are definitely not taken."),
("[none,all,safe]"),
{"none", "all", "safe"});
DEFINE_bool(warn_constructors, options::TWO_DASHES, '\0', false,
N_("Ignored"), N_("Ignored"));
+ DEFINE_bool(warn_mismatch, options::TWO_DASHES, '\0', true,
+ NULL, N_("Don't warn about mismatched input files"));
+
+ DEFINE_bool(warn_multiple_gp, options::TWO_DASHES, '\0', false,
+ N_("Ignored"), NULL);
+
DEFINE_bool(warn_search_mismatch, options::TWO_DASHES, '\0', true,
N_("Warn when skipping an incompatible library"),
N_("Don't warn when skipping an incompatible library"));
+ DEFINE_bool(warn_shared_textrel, options::TWO_DASHES, '\0', false,
+ N_("Warn if text segment is not shareable"),
+ N_("Do not warn if text segment is not shareable (default)"));
+
+ DEFINE_bool(warn_unresolved_symbols, options::TWO_DASHES, '\0', false,
+ N_("Report unresolved symbols as warnings"),
+ NULL);
+ DEFINE_bool_alias(error_unresolved_symbols, warn_unresolved_symbols,
+ options::TWO_DASHES, '\0',
+ N_("Report unresolved symbols as errors"),
+ NULL, true);
+
+ DEFINE_bool(wchar_size_warning, options::TWO_DASHES, '\0', true, NULL,
+ N_("(ARM only) Do not warn about objects with incompatible "
+ "wchar_t sizes"));
+
DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false,
N_("Include all archive contents"),
N_("Include only needed archive contents"));
DEFINE_set(trace_symbol, options::TWO_DASHES, 'y',
N_("Trace references to symbol"), N_("SYMBOL"));
+ DEFINE_bool(undefined_version, options::TWO_DASHES, '\0', true,
+ N_("Allow unused version in script (default)"),
+ N_("Do not allow unused version in script"));
+
DEFINE_string(Y, options::EXACTLY_ONE_DASH, 'Y', "",
N_("Default search path for Solaris compatibility"),
N_("PATH"));
DEFINE_special(end_group, options::TWO_DASHES, ')',
N_("End a library search group"), NULL);
+
+ DEFINE_special(start_lib, options::TWO_DASHES, '\0',
+ N_("Start a library"), NULL);
+ DEFINE_special(end_lib, options::TWO_DASHES, '\0',
+ N_("End a library "), NULL);
+
// The -z options.
DEFINE_bool(combreloc, options::DASH_Z, '\0', true,
DEFINE_bool(relro, options::DASH_Z, '\0', false,
N_("Where possible mark variables read-only after relocation"),
N_("Don't mark variables read-only after relocation"));
+ DEFINE_bool(text, options::DASH_Z, '\0', false,
+ N_("Do not permit relocations in read-only segments"),
+ NULL);
+ DEFINE_bool_alias(textoff, text, options::DASH_Z, '\0',
+ N_("Permit relocations in read-only segments (default)"),
+ NULL, true);
public:
typedef options::Dir_list Dir_list;
// Return true if S is the name of a library excluded from automatic
// symbol export.
bool
- check_excluded_libs (const std::string &s) const;
+ check_excluded_libs(const std::string &s) const;
+
+ // If an explicit start address was given for section SECNAME with
+ // the --section-start option, return true and set *PADDR to the
+ // address. Otherwise return false.
+ bool
+ section_start(const char* secname, uint64_t* paddr) const;
+
+ enum Fix_v4bx
+ {
+ // Leave original instruction.
+ FIX_V4BX_NONE,
+ // Replace instruction.
+ FIX_V4BX_REPLACE,
+ // Generate an interworking veneer.
+ FIX_V4BX_INTERWORKING
+ };
+
+ Fix_v4bx
+ fix_v4bx() const
+ { return (this->fix_v4bx_); }
+
+ enum Endianness
+ {
+ ENDIANNESS_NOT_SET,
+ ENDIANNESS_BIG,
+ ENDIANNESS_LITTLE
+ };
+
+ Endianness
+ endianness() const
+ { return this->endianness_; }
private:
// Don't copy this structure.
// Add a plugin and its arguments to the list of plugins.
void
- add_plugin(const char *filename);
+ add_plugin(const char* filename);
// Add a plugin option.
void
Unordered_set<std::string> excluded_libs_;
// List of symbol-names to keep, via -retain-symbol-info.
Unordered_set<std::string> symbols_to_retain_;
+ // Map from section name to address from --section-start.
+ std::map<std::string, uint64_t> section_starts_;
+ // Whether to process armv4 bx instruction relocation.
+ Fix_v4bx fix_v4bx_;
+ // Endianness.
+ Endianness endianness_;
};
// The position-dependent options. We use this to store the state of
public:
// Create a file or library argument.
explicit Input_argument(Input_file_argument file)
- : is_file_(true), file_(file), group_(NULL)
+ : is_file_(true), file_(file), group_(NULL), lib_(NULL)
{ }
// Create a group argument.
explicit Input_argument(Input_file_group* group)
- : is_file_(false), group_(group)
+ : is_file_(false), group_(group), lib_(NULL)
+ { }
+
+ // Create a lib argument.
+ explicit Input_argument(Input_file_lib* lib)
+ : is_file_(false), group_(NULL), lib_(lib)
{ }
// Return whether this is a file.
// Return whether this is a group.
bool
is_group() const
- { return !this->is_file_; }
+ { return !this->is_file_ && this->lib_ == NULL; }
+
+ // Return whether this is a lib.
+ bool
+ is_lib() const
+ { return this->lib_ != NULL; }
// Return the information about the file.
const Input_file_argument&
return this->group_;
}
+ // Return the information about the lib.
+ const Input_file_lib*
+ lib() const
+ {
+ gold_assert(!this->is_file_);
+ gold_assert(this->lib_);
+ return this->lib_;
+ }
+
+ Input_file_lib*
+ lib()
+ {
+ gold_assert(!this->is_file_);
+ gold_assert(this->lib_);
+ return this->lib_;
+ }
+
private:
bool is_file_;
Input_file_argument file_;
Input_file_group* group_;
+ Input_file_lib* lib_;
};
typedef std::vector<Input_argument> Input_argument_list;
Input_argument_list files_;
};
+// A lib from the command line. This is a set of arguments within
+// --start-lib ... --end-lib.
+
+class Input_file_lib
+{
+ public:
+ typedef Input_argument_list::const_iterator const_iterator;
+
+ Input_file_lib(const Position_dependent_options& options)
+ : files_(), options_(options)
+ { }
+
+ // Add a file to the end of the lib.
+ void
+ add_file(const Input_file_argument& arg)
+ { this->files_.push_back(Input_argument(arg)); }
+
+ const Position_dependent_options&
+ options() const
+ { return this->options_; }
+
+ // Iterators to iterate over the lib contents.
+
+ const_iterator
+ begin() const
+ { return this->files_.begin(); }
+
+ const_iterator
+ end() const
+ { return this->files_.end(); }
+
+ size_t
+ size() const
+ { return this->files_.size(); }
+
+ private:
+ Input_argument_list files_;
+ Position_dependent_options options_;
+};
+
// A list of files from the command line or a script.
class Input_arguments
typedef Input_argument_list::const_iterator const_iterator;
Input_arguments()
- : input_argument_list_(), in_group_(false)
+ : input_argument_list_(), in_group_(false), in_lib_(false)
{ }
// Add a file.
void
end_group();
+ // Start a lib (the --start-lib option).
+ void
+ start_lib(const Position_dependent_options&);
+
+ // End a lib (the --end-lib option).
+ void
+ end_lib();
+
// Return whether we are currently in a group.
bool
in_group() const
{ return this->in_group_; }
+ // Return whether we are currently in a lib.
+ bool
+ in_lib() const
+ { return this->in_lib_; }
+
// The number of entries in the list.
int
size() const
private:
Input_argument_list input_argument_list_;
bool in_group_;
+ bool in_lib_;
};