summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
21ff468)
* options.h (General_options): Remove leading space from help
messages for -nostdlib and --rosegment.
+2013-05-10 Roland McGrath <mcgrathr@google.com>
+
+ * options.h (General_options): Remove leading space from help
+ messages for -nostdlib and --rosegment.
+
2013-05-03 Maciej W. Rozycki <macro@codesourcery.com>
PR ld/15365
2013-05-03 Maciej W. Rozycki <macro@codesourcery.com>
PR ld/15365
* Added source code to GNU binutils.
\f
* Added source code to GNU binutils.
\f
-Copyright (C) 2008-2012 Free Software Foundation, Inc.
+Copyright (C) 2008-2013 Free Software Foundation, Inc.
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
// options.h -- handle command line options for gold -*- C++ -*-
// options.h -- handle command line options for gold -*- C++ -*-
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2013
+// Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
extern void
parse_choices(const char* option_name, const char* arg, const char** retval,
extern void
parse_choices(const char* option_name, const char* arg, const char** retval,
- const char* choices[], int num_choices);
+ const char* choices[], int num_choices);
Struct_var* reader;
One_option(const char* ln, Dashes d, char sn, const char* dv,
Struct_var* reader;
One_option(const char* ln, Dashes d, char sn, const char* dv,
- const char* hs, const char* ha, bool oa, Struct_var* r)
+ const char* hs, const char* ha, bool oa, Struct_var* r)
: longname(ln), dashes(d), shortname(sn), default_value(dv ? dv : ""),
helpstring(hs), helparg(ha), optional_arg(oa), reader(r)
{
: longname(ln), dashes(d), shortname(sn), default_value(dv ? dv : ""),
helpstring(hs), helparg(ha), optional_arg(oa), reader(r)
{
// OPTIONS: the global General_options object. Used by DEFINE_special.
virtual void
parse_to_value(const char* option, const char* arg,
// OPTIONS: the global General_options object. Used by DEFINE_special.
virtual void
parse_to_value(const char* option, const char* arg,
- Command_line* cmdline, General_options* options) = 0;
+ Command_line* cmdline, General_options* options) = 0;
virtual
~Struct_var() // To make gcc happy.
{ }
virtual
~Struct_var() // To make gcc happy.
{ }
{
// If you change this, change the parse-fn in DEFINE_special as well.
typedef void (General_options::*Parse_function)(const char*, const char*,
{
// If you change this, change the parse-fn in DEFINE_special as well.
typedef void (General_options::*Parse_function)(const char*, const char*,
Struct_special(const char* varname, Dashes dashes, char shortname,
Struct_special(const char* varname, Dashes dashes, char shortname,
- Parse_function parse_function,
- const char* helpstring, const char* helparg)
+ Parse_function parse_function,
+ const char* helpstring, const char* helparg)
: option(varname, dashes, shortname, "", helpstring, helparg, false, this),
parse(parse_function)
{ }
void parse_to_value(const char* option, const char* arg,
: option(varname, dashes, shortname, "", helpstring, helparg, false, this),
parse(parse_function)
{ }
void parse_to_value(const char* option, const char* arg,
- Command_line* cmdline, General_options* options)
+ Command_line* cmdline, General_options* options)
{ (options->*(this->parse))(option, arg, cmdline); }
One_option option;
{ (options->*(this->parse))(option, arg, cmdline); }
One_option option;
// avoid unintended macro substitution of "assert()", we need to enclose
// varname__ with parenthese.
#define DEFINE_var(varname__, dashes__, shortname__, default_value__, \
// 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__) \
+ default_value_as_string__, helpstring__, helparg__, \
+ optional_arg__, type__, param_type__, parse_fn__) \
public: \
param_type__ \
(varname__)() const \
{ return this->varname__##_.value; } \
public: \
param_type__ \
(varname__)() const \
{ return this->varname__##_.value; } \
bool \
user_set_##varname__() const \
{ return this->varname__##_.user_set_via_option; } \
bool \
user_set_##varname__() const \
{ return this->varname__##_.user_set_via_option; } \
void \
set_user_set_##varname__() \
{ this->varname__##_.user_set_via_option = true; } \
void \
set_user_set_##varname__() \
{ this->varname__##_.user_set_via_option = true; } \
{ \
Struct_##varname__() \
: option(#varname__, dashes__, shortname__, default_value_as_string__, \
{ \
Struct_##varname__() \
: option(#varname__, dashes__, shortname__, default_value_as_string__, \
- helpstring__, helparg__, optional_arg__, this), \
- user_set_via_option(false), value(default_value__) \
+ helpstring__, helparg__, optional_arg__, this), \
+ user_set_via_option(false), value(default_value__) \
void \
parse_to_value(const char* option_name, const char* arg, \
void \
parse_to_value(const char* option_name, const char* arg, \
- Command_line*, General_options*) \
+ Command_line*, General_options*) \
{ \
parse_fn__(option_name, arg, &this->value); \
this->user_set_via_option = true; \
} \
{ \
parse_fn__(option_name, arg, &this->value); \
this->user_set_via_option = true; \
} \
options::One_option option; \
bool user_set_via_option; \
type__ value; \
options::One_option option; \
bool user_set_via_option; \
type__ value; \
// VARNAME, we also create an option called no-VARNAME (or, for a -z
// option, noVARNAME).
#define DEFINE_bool(varname__, dashes__, shortname__, default_value__, \
// VARNAME, we also create an option called no-VARNAME (or, for a -z
// option, noVARNAME).
#define DEFINE_bool(varname__, dashes__, shortname__, default_value__, \
- helpstring__, no_helpstring__) \
+ helpstring__, no_helpstring__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- default_value__ ? "true" : "false", helpstring__, NULL, \
- false, bool, bool, options::parse_bool) \
+ default_value__ ? "true" : "false", helpstring__, NULL, \
+ false, bool, bool, options::parse_bool) \
struct Struct_no_##varname__ : public options::Struct_var \
{ \
Struct_no_##varname__() : option((dashes__ == options::DASH_Z \
? "no" #varname__ \
: "no-" #varname__), \
dashes__, '\0', \
struct Struct_no_##varname__ : public options::Struct_var \
{ \
Struct_no_##varname__() : option((dashes__ == options::DASH_Z \
? "no" #varname__ \
: "no-" #varname__), \
dashes__, '\0', \
- default_value__ ? "false" : "true", \
- no_helpstring__, NULL, false, this) \
+ default_value__ ? "false" : "true", \
+ no_helpstring__, NULL, false, this) \
void \
parse_to_value(const char*, const char*, \
void \
parse_to_value(const char*, const char*, \
- Command_line*, General_options* options) \
+ Command_line*, General_options* options) \
{ \
options->set_##varname__(false); \
options->set_user_set_##varname__(); \
} \
{ \
options->set_##varname__(false); \
options->set_user_set_##varname__(); \
} \
options::One_option option; \
}; \
Struct_no_##varname__ no_##varname__##_initializer_
#define DEFINE_enable(varname__, dashes__, shortname__, default_value__, \
options::One_option option; \
}; \
Struct_no_##varname__ no_##varname__##_initializer_
#define DEFINE_enable(varname__, dashes__, shortname__, default_value__, \
- helpstring__, no_helpstring__) \
+ helpstring__, no_helpstring__) \
DEFINE_var(enable_##varname__, dashes__, shortname__, default_value__, \
DEFINE_var(enable_##varname__, dashes__, shortname__, default_value__, \
- default_value__ ? "true" : "false", helpstring__, NULL, \
- false, bool, bool, options::parse_bool) \
+ default_value__ ? "true" : "false", helpstring__, NULL, \
+ false, bool, bool, options::parse_bool) \
struct Struct_disable_##varname__ : public options::Struct_var \
{ \
Struct_disable_##varname__() : option("disable-" #varname__, \
struct Struct_disable_##varname__ : public options::Struct_var \
{ \
Struct_disable_##varname__() : option("disable-" #varname__, \
- dashes__, '\0', \
- default_value__ ? "false" : "true", \
- no_helpstring__, NULL, false, this) \
+ dashes__, '\0', \
+ default_value__ ? "false" : "true", \
+ no_helpstring__, NULL, false, this) \
void \
parse_to_value(const char*, const char*, \
void \
parse_to_value(const char*, const char*, \
- Command_line*, General_options* options) \
+ Command_line*, General_options* options) \
{ options->set_enable_##varname__(false); } \
{ options->set_enable_##varname__(false); } \
options::One_option option; \
}; \
Struct_disable_##varname__ disable_##varname__##_initializer_
#define DEFINE_int(varname__, dashes__, shortname__, default_value__, \
options::One_option option; \
}; \
Struct_disable_##varname__ disable_##varname__##_initializer_
#define DEFINE_int(varname__, dashes__, shortname__, default_value__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- #default_value__, helpstring__, helparg__, false, \
- int, int, options::parse_int)
+ #default_value__, helpstring__, helparg__, false, \
+ int, int, options::parse_int)
#define DEFINE_uint(varname__, dashes__, shortname__, default_value__, \
#define DEFINE_uint(varname__, dashes__, shortname__, default_value__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- #default_value__, helpstring__, helparg__, false, \
- int, int, options::parse_uint)
+ #default_value__, helpstring__, helparg__, false, \
+ int, int, options::parse_uint)
#define DEFINE_uint64(varname__, dashes__, shortname__, default_value__, \
#define DEFINE_uint64(varname__, dashes__, shortname__, default_value__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- #default_value__, helpstring__, helparg__, false, \
- uint64_t, uint64_t, options::parse_uint64)
+ #default_value__, helpstring__, helparg__, false, \
+ uint64_t, uint64_t, options::parse_uint64)
#define DEFINE_double(varname__, dashes__, shortname__, default_value__, \
helpstring__, helparg__) \
#define DEFINE_double(varname__, dashes__, shortname__, default_value__, \
helpstring__, helparg__) \
double, double, options::parse_percent)
#define DEFINE_string(varname__, dashes__, shortname__, default_value__, \
double, double, options::parse_percent)
#define DEFINE_string(varname__, dashes__, shortname__, default_value__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- default_value__, helpstring__, helparg__, false, \
- const char*, const char*, options::parse_string)
+ default_value__, helpstring__, helparg__, false, \
+ const char*, const char*, options::parse_string)
// This is like DEFINE_string, but we convert each occurrence to a
// Search_directory and store it in a vector. Thus we also have the
// add_to_VARNAME() method, to append to the vector.
#define DEFINE_dirlist(varname__, dashes__, shortname__, \
// This is like DEFINE_string, but we convert each occurrence to a
// Search_directory and store it in a vector. Thus we also have the
// add_to_VARNAME() method, to append to the vector.
#define DEFINE_dirlist(varname__, dashes__, shortname__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, , \
DEFINE_var(varname__, dashes__, shortname__, , \
- "", helpstring__, helparg__, false, options::Dir_list, \
- const options::Dir_list&, options::parse_dirlist) \
+ "", helpstring__, helparg__, false, options::Dir_list, \
+ const options::Dir_list&, options::parse_dirlist) \
void \
add_to_##varname__(const char* new_value) \
{ options::parse_dirlist(NULL, new_value, &this->varname__##_.value); } \
void \
add_to_##varname__(const char* new_value) \
{ options::parse_dirlist(NULL, new_value, &this->varname__##_.value); } \
// This is like DEFINE_string, but we store a set of strings.
#define DEFINE_set(varname__, dashes__, shortname__, \
// This is like DEFINE_string, but we store a set of strings.
#define DEFINE_set(varname__, dashes__, shortname__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, , \
DEFINE_var(varname__, dashes__, shortname__, , \
- "", helpstring__, helparg__, false, options::String_set, \
- const options::String_set&, options::parse_set) \
+ "", helpstring__, helparg__, false, options::String_set, \
+ const options::String_set&, options::parse_set) \
public: \
bool \
any_##varname__() const \
public: \
bool \
any_##varname__() const \
is_##varname__(const char* symbol) const \
{ \
return (!this->varname__##_.value.empty() \
is_##varname__(const char* symbol) const \
{ \
return (!this->varname__##_.value.empty() \
- && (this->varname__##_.value.find(std::string(symbol)) \
- != this->varname__##_.value.end())); \
+ && (this->varname__##_.value.find(std::string(symbol)) \
+ != this->varname__##_.value.end())); \
} \
\
options::String_set::const_iterator \
} \
\
options::String_set::const_iterator \
// After helparg__ should come an initializer list, like
// {"foo", "bar", "baz"}
#define DEFINE_enum(varname__, dashes__, shortname__, default_value__, \
// After helparg__ should come an initializer list, like
// {"foo", "bar", "baz"}
#define DEFINE_enum(varname__, dashes__, shortname__, default_value__, \
- helpstring__, helparg__, ...) \
+ helpstring__, helparg__, ...) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- default_value__, helpstring__, helparg__, false, \
- const char*, const char*, parse_choices_##varname__) \
+ default_value__, helpstring__, helparg__, false, \
+ const char*, const char*, parse_choices_##varname__) \
private: \
static void parse_choices_##varname__(const char* option_name, \
private: \
static void parse_choices_##varname__(const char* option_name, \
- const char* arg, \
- const char** retval) { \
+ const char* arg, \
+ const char** retval) { \
const char* choices[] = __VA_ARGS__; \
options::parse_choices(option_name, arg, retval, \
const char* choices[] = __VA_ARGS__; \
options::parse_choices(option_name, arg, retval, \
- choices, sizeof(choices) / sizeof(*choices)); \
+ choices, sizeof(choices) / sizeof(*choices)); \
}
// This is like DEFINE_bool, but VARNAME is the name of a different
}
// This is like DEFINE_bool, but VARNAME is the name of a different
// General_options; you are responsible for defining it there.
// helparg__ should be NULL iff this special-option is a boolean.
#define DEFINE_special(varname__, dashes__, shortname__, \
// General_options; you are responsible for defining it there.
// helparg__ should be NULL iff this special-option is a boolean.
#define DEFINE_special(varname__, dashes__, shortname__, \
- helpstring__, helparg__) \
+ helpstring__, helparg__) \
private: \
void parse_##varname__(const char* option, const char* arg, \
private: \
void parse_##varname__(const char* option, const char* arg, \
- Command_line* inputs); \
+ Command_line* inputs); \
struct Struct_##varname__ : public options::Struct_special \
{ \
Struct_##varname__() \
: options::Struct_special(#varname__, dashes__, shortname__, \
struct Struct_##varname__ : public options::Struct_special \
{ \
Struct_##varname__() \
: options::Struct_special(#varname__, dashes__, shortname__, \
- &General_options::parse_##varname__, \
- helpstring__, helparg__) \
+ &General_options::parse_##varname__, \
+ helpstring__, helparg__) \
{ } \
}; \
Struct_##varname__ varname__##_initializer_
{ } \
}; \
Struct_##varname__ varname__##_initializer_
default_value__, \
helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
default_value__, \
helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \
- default_value__, helpstring__, helparg__, true, \
- const char*, const char*, options::parse_optional_string)
+ default_value__, helpstring__, helparg__, true, \
+ const char*, const char*, options::parse_optional_string)
// A directory to search. For each directory we record whether it is
// in the sysroot. We need to know this so that, if a linker script
// A directory to search. For each directory we record whether it is
// in the sysroot. We need to know this so that, if a linker script
// NOTE: For every option that you add here, also consider if you
// should add it to Position_dependent_options.
DEFINE_special(help, options::TWO_DASHES, '\0',
// NOTE: For every option that you add here, also consider if you
// should add it to Position_dependent_options.
DEFINE_special(help, options::TWO_DASHES, '\0',
- N_("Report usage information"), NULL);
+ N_("Report usage information"), NULL);
DEFINE_special(version, options::TWO_DASHES, 'v',
DEFINE_special(version, options::TWO_DASHES, 'v',
- N_("Report version information"), NULL);
+ N_("Report version information"), NULL);
DEFINE_special(V, options::EXACTLY_ONE_DASH, '\0',
DEFINE_special(V, options::EXACTLY_ONE_DASH, '\0',
- N_("Report version and target information"), NULL);
+ N_("Report version and target information"), NULL);
// These options are sorted approximately so that for each letter in
// the alphabet, we show the option whose shortname is that letter
// These options are sorted approximately so that for each letter in
// the alphabet, we show the option whose shortname is that letter
N_("Do not allow multiple definitions"), false);
DEFINE_bool(allow_shlib_undefined, options::TWO_DASHES, '\0', false,
N_("Do not allow multiple definitions"), false);
DEFINE_bool(allow_shlib_undefined, options::TWO_DASHES, '\0', false,
- N_("Allow unresolved references in shared libraries"),
- N_("Do not allow unresolved references in shared libraries"));
+ N_("Allow unresolved references in shared libraries"),
+ N_("Do not allow unresolved references in shared libraries"));
DEFINE_bool(as_needed, options::TWO_DASHES, '\0', false,
DEFINE_bool(as_needed, options::TWO_DASHES, '\0', false,
- N_("Only set DT_NEEDED for shared libraries if used"),
- N_("Always DT_NEEDED for shared libraries"));
+ N_("Only set DT_NEEDED for shared libraries if used"),
+ N_("Always DT_NEEDED for shared libraries"));
DEFINE_enum(assert, options::ONE_DASH, '\0', NULL,
N_("Ignored"), N_("[ignored]"),
DEFINE_enum(assert, options::ONE_DASH, '\0', NULL,
N_("Ignored"), N_("[ignored]"),
// accept any string. We'll fail later (when the string is parsed),
// if the target isn't actually supported.
DEFINE_string(format, options::TWO_DASHES, 'b', "elf",
// accept any string. We'll fail later (when the string is parsed),
// if the target isn't actually supported.
DEFINE_string(format, options::TWO_DASHES, 'b', "elf",
- N_("Set input format"), ("[elf,binary]"));
+ N_("Set input format"), ("[elf,binary]"));
DEFINE_bool(Bdynamic, options::ONE_DASH, '\0', true,
DEFINE_bool(Bdynamic, options::ONE_DASH, '\0', true,
- N_("-l searches for shared libraries"), NULL);
+ N_("-l searches for shared libraries"), NULL);
DEFINE_bool_alias(Bstatic, Bdynamic, options::ONE_DASH, '\0',
N_("-l does not search for shared libraries"), NULL,
true);
DEFINE_bool_alias(Bstatic, Bdynamic, options::ONE_DASH, '\0',
N_("-l does not search for shared libraries"), NULL,
true);
N_("Use group name lookup rules for shared library"), NULL);
DEFINE_bool(Bsymbolic, options::ONE_DASH, '\0', false,
N_("Use group name lookup rules for shared library"), NULL);
DEFINE_bool(Bsymbolic, options::ONE_DASH, '\0', false,
- N_("Bind defined symbols locally"), NULL);
+ N_("Bind defined symbols locally"), NULL);
DEFINE_bool(Bsymbolic_functions, options::ONE_DASH, '\0', false,
N_("Bind defined function symbols locally"), NULL);
DEFINE_bool(Bsymbolic_functions, options::ONE_DASH, '\0', false,
N_("Bind defined function symbols locally"), NULL);
N_("[=STYLE]"));
DEFINE_uint64(build_id_chunk_size_for_treehash,
N_("[=STYLE]"));
DEFINE_uint64(build_id_chunk_size_for_treehash,
- options::TWO_DASHES, '\0', 2 << 20,
- N_("Chunk size for '--build-id=tree'"), N_("SIZE"));
+ options::TWO_DASHES, '\0', 2 << 20,
+ N_("Chunk size for '--build-id=tree'"), N_("SIZE"));
DEFINE_uint64(build_id_min_file_size_for_treehash, options::TWO_DASHES,
DEFINE_uint64(build_id_min_file_size_for_treehash, options::TWO_DASHES,
- '\0', 40 << 20,
- N_("Minimum output file size for '--build-id=tree' to work"
- " differently than '--build-id=sha1'"), N_("SIZE"));
+ '\0', 40 << 20,
+ N_("Minimum output file size for '--build-id=tree' to work"
+ " differently than '--build-id=sha1'"), N_("SIZE"));
DEFINE_bool(check_sections, options::TWO_DASHES, '\0', true,
N_("Check segment addresses for overlaps (default)"),
DEFINE_bool(check_sections, options::TWO_DASHES, '\0', true,
N_("Check segment addresses for overlaps (default)"),
#ifdef HAVE_ZLIB_H
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
#ifdef HAVE_ZLIB_H
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
- N_("Compress .debug_* sections in the output file"),
- ("[none,zlib]"),
- {"none", "zlib"});
+ N_("Compress .debug_* sections in the output file"),
+ ("[none,zlib]"),
+ {"none", "zlib"});
#else
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
#else
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
- N_("Compress .debug_* sections in the output file"),
- N_("[none]"),
- {"none"});
+ N_("Compress .debug_* sections in the output file"),
+ N_("[none]"),
+ {"none"});
#endif
DEFINE_bool(copy_dt_needed_entries, options::TWO_DASHES, '\0', false,
#endif
DEFINE_bool(copy_dt_needed_entries, options::TWO_DASHES, '\0', false,
N_("Handle constructors as directed by compiler"));
DEFINE_bool(define_common, options::TWO_DASHES, 'd', false,
N_("Handle constructors as directed by compiler"));
DEFINE_bool(define_common, options::TWO_DASHES, 'd', false,
- N_("Define common symbols"),
- N_("Do not define common symbols"));
+ N_("Define common symbols"),
+ N_("Do not define common symbols"));
DEFINE_bool(dc, options::ONE_DASH, '\0', false,
DEFINE_bool(dc, options::ONE_DASH, '\0', false,
- N_("Alias for -d"), NULL);
+ N_("Alias for -d"), NULL);
DEFINE_bool(dp, options::ONE_DASH, '\0', false,
DEFINE_bool(dp, options::ONE_DASH, '\0', false,
- N_("Alias for -d"), NULL);
+ N_("Alias for -d"), NULL);
DEFINE_string(debug, options::TWO_DASHES, '\0', "",
DEFINE_string(debug, options::TWO_DASHES, '\0', "",
- N_("Turn on debugging"),
- N_("[all,files,script,task][,...]"));
+ N_("Turn on debugging"),
+ N_("[all,files,script,task][,...]"));
DEFINE_special(defsym, options::TWO_DASHES, '\0',
DEFINE_special(defsym, options::TWO_DASHES, '\0',
- N_("Define a symbol"), N_("SYMBOL=EXPRESSION"));
+ N_("Define a symbol"), N_("SYMBOL=EXPRESSION"));
DEFINE_optional_string(demangle, options::TWO_DASHES, '\0', NULL,
N_("Demangle C++ symbols in log messages"),
DEFINE_optional_string(demangle, options::TWO_DASHES, '\0', NULL,
N_("Demangle C++ symbols in log messages"),
NULL);
DEFINE_bool(detect_odr_violations, options::TWO_DASHES, '\0', false,
NULL);
DEFINE_bool(detect_odr_violations, options::TWO_DASHES, '\0', false,
- N_("Look for violations of the C++ One Definition Rule"),
+ N_("Look for violations of the C++ One Definition Rule"),
N_("Do not look for violations of the C++ One Definition Rule"));
DEFINE_bool(discard_all, options::TWO_DASHES, 'x', false,
N_("Delete all local symbols"), NULL);
DEFINE_bool(discard_locals, options::TWO_DASHES, 'X', false,
N_("Do not look for violations of the C++ One Definition Rule"));
DEFINE_bool(discard_all, options::TWO_DASHES, 'x', false,
N_("Delete all local symbols"), NULL);
DEFINE_bool(discard_locals, options::TWO_DASHES, 'X', false,
- N_("Delete all temporary local symbols"), NULL);
+ N_("Delete all temporary local symbols"), NULL);
DEFINE_bool(dynamic_list_data, options::TWO_DASHES, '\0', false,
DEFINE_bool(dynamic_list_data, options::TWO_DASHES, '\0', false,
- N_("Add data symbols to dynamic symbols"), NULL);
+ N_("Add data symbols to dynamic symbols"), NULL);
DEFINE_bool(dynamic_list_cpp_new, options::TWO_DASHES, '\0', false,
DEFINE_bool(dynamic_list_cpp_new, options::TWO_DASHES, '\0', false,
- N_("Add C++ operator new/delete to dynamic symbols"), NULL);
+ N_("Add C++ operator new/delete to dynamic symbols"), NULL);
DEFINE_bool(dynamic_list_cpp_typeinfo, options::TWO_DASHES, '\0', false,
DEFINE_bool(dynamic_list_cpp_typeinfo, options::TWO_DASHES, '\0', false,
- N_("Add C++ typeinfo to dynamic symbols"), NULL);
+ N_("Add C++ typeinfo to dynamic symbols"), NULL);
DEFINE_special(dynamic_list, options::TWO_DASHES, '\0',
DEFINE_special(dynamic_list, options::TWO_DASHES, '\0',
- N_("Read a list of dynamic symbols"), N_("FILE"));
+ N_("Read a list of dynamic symbols"), N_("FILE"));
DEFINE_string(entry, options::TWO_DASHES, 'e', NULL,
DEFINE_string(entry, options::TWO_DASHES, 'e', NULL,
- N_("Set program start address"), N_("ADDRESS"));
+ N_("Set program start address"), N_("ADDRESS"));
DEFINE_special(exclude_libs, options::TWO_DASHES, '\0',
N_("Exclude libraries from automatic export"),
N_(("lib,lib ...")));
DEFINE_bool(export_dynamic, options::TWO_DASHES, 'E', false,
DEFINE_special(exclude_libs, options::TWO_DASHES, '\0',
N_("Exclude libraries from automatic export"),
N_(("lib,lib ...")));
DEFINE_bool(export_dynamic, options::TWO_DASHES, 'E', false,
- N_("Export all dynamic symbols"),
+ N_("Export all dynamic symbols"),
N_("Do not export all dynamic symbols (default)"));
DEFINE_set(export_dynamic_symbol, options::TWO_DASHES, '\0',
N_("Do not export all dynamic symbols (default)"));
DEFINE_set(export_dynamic_symbol, options::TWO_DASHES, '\0',
N_("Link little-endian objects."), NULL);
DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false,
N_("Link little-endian objects."), NULL);
DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false,
- N_("Create exception frame header"), NULL);
+ N_("Create exception frame header"), NULL);
DEFINE_bool(enum_size_warning, options::TWO_DASHES, '\0', true, NULL,
N_("(ARM only) Do not warn about objects with incompatible "
DEFINE_bool(enum_size_warning, options::TWO_DASHES, '\0', true, NULL,
N_("(ARM only) Do not warn about objects with incompatible "
N_("Do not treat warnings as errors"));
DEFINE_string(fini, options::ONE_DASH, '\0', "_fini",
N_("Do not treat warnings as errors"));
DEFINE_string(fini, options::ONE_DASH, '\0', "_fini",
- N_("Call SYMBOL at unload-time"), N_("SYMBOL"));
+ 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."),
DEFINE_bool(fix_cortex_a8, options::TWO_DASHES, '\0', false,
N_("(ARM only) Fix binaries for Cortex-A8 erratum."),
N_("(ARM only) Do not merge exidx entries in debuginfo."));
DEFINE_special(fix_v4bx, options::TWO_DASHES, '\0',
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);
+ N_("(ARM only) Rewrite BX rn as MOV pc, rn for ARMv4"),
+ NULL);
DEFINE_special(fix_v4bx_interworking, options::TWO_DASHES, '\0',
DEFINE_special(fix_v4bx_interworking, options::TWO_DASHES, '\0',
- N_("(ARM only) Rewrite BX rn branch to ARMv4 interworking "
- "veneer"),
- NULL);
+ 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_bool(g, options::EXACTLY_ONE_DASH, '\0', false,
N_("Ignored"), NULL);
N_("Disable STB_GNU_UNIQUE symbol binding"));
DEFINE_string(soname, options::ONE_DASH, 'h', NULL,
N_("Disable STB_GNU_UNIQUE symbol binding"));
DEFINE_string(soname, options::ONE_DASH, 'h', NULL,
- N_("Set shared library name"), N_("FILENAME"));
+ N_("Set shared library name"), N_("FILENAME"));
DEFINE_double(hash_bucket_empty_fraction, options::TWO_DASHES, '\0', 0.0,
N_("Min fraction of empty buckets in dynamic hash"),
DEFINE_double(hash_bucket_empty_fraction, options::TWO_DASHES, '\0', 0.0,
N_("Min fraction of empty buckets in dynamic hash"),
{"sysv", "gnu", "both"});
DEFINE_string(dynamic_linker, options::TWO_DASHES, 'I', NULL,
{"sysv", "gnu", "both"});
DEFINE_string(dynamic_linker, options::TWO_DASHES, 'I', NULL,
- N_("Set dynamic linker path"), N_("PROGRAM"));
+ N_("Set dynamic linker path"), N_("PROGRAM"));
DEFINE_special(incremental, options::TWO_DASHES, '\0',
N_("Do an incremental link if possible; "
DEFINE_special(incremental, options::TWO_DASHES, '\0',
N_("Do an incremental link if possible; "
N_("Do an incremental link; exit if not possible"), NULL);
DEFINE_string(incremental_base, options::TWO_DASHES, '\0', NULL,
N_("Do an incremental link; exit if not possible"), NULL);
DEFINE_string(incremental_base, options::TWO_DASHES, '\0', NULL,
- N_("Set base file for incremental linking"
- " (default is output file)"),
- N_("FILE"));
+ N_("Set base file for incremental linking"
+ " (default is output file)"),
+ N_("FILE"));
DEFINE_special(incremental_changed, options::TWO_DASHES, '\0',
DEFINE_special(incremental_changed, options::TWO_DASHES, '\0',
- N_("Assume files changed"), NULL);
+ N_("Assume files changed"), NULL);
DEFINE_special(incremental_unchanged, options::TWO_DASHES, '\0',
DEFINE_special(incremental_unchanged, options::TWO_DASHES, '\0',
- N_("Assume files didn't change"), NULL);
+ N_("Assume files didn't change"), NULL);
DEFINE_special(incremental_unknown, options::TWO_DASHES, '\0',
DEFINE_special(incremental_unknown, options::TWO_DASHES, '\0',
- N_("Use timestamps to check files (default)"), NULL);
+ N_("Use timestamps to check files (default)"), NULL);
DEFINE_special(incremental_startup_unchanged, options::TWO_DASHES, '\0',
DEFINE_special(incremental_startup_unchanged, options::TWO_DASHES, '\0',
- N_("Assume startup files unchanged "
+ N_("Assume startup files unchanged "
"(files preceding this option)"), NULL);
DEFINE_percent(incremental_patch, options::TWO_DASHES, '\0', 10,
"(files preceding this option)"), NULL);
DEFINE_percent(incremental_patch, options::TWO_DASHES, '\0', 10,
N_("PERCENT"));
DEFINE_string(init, options::ONE_DASH, '\0', "_init",
N_("PERCENT"));
DEFINE_string(init, options::ONE_DASH, '\0', "_init",
- N_("Call SYMBOL at load-time"), N_("SYMBOL"));
+ N_("Call SYMBOL at load-time"), N_("SYMBOL"));
DEFINE_special(just_symbols, options::TWO_DASHES, '\0',
DEFINE_special(just_symbols, options::TWO_DASHES, '\0',
- N_("Read only symbol values from FILE"), N_("FILE"));
+ N_("Read only symbol values from FILE"), N_("FILE"));
DEFINE_bool(map_whole_files, options::TWO_DASHES, '\0',
sizeof(void*) >= 8,
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)"));
+ 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,
DEFINE_bool(keep_files_mapped, options::TWO_DASHES, '\0', true,
- N_("Keep files mapped across passes (default)"),
- N_("Release mapped files after each pass"));
+ N_("Keep files mapped across passes (default)"),
+ N_("Release mapped files after each pass"));
DEFINE_bool(ld_generated_unwind_info, options::TWO_DASHES, '\0', true,
N_("Generate unwind information for PLT (default)"),
N_("Do not generate unwind information for PLT"));
DEFINE_special(library, options::TWO_DASHES, 'l',
DEFINE_bool(ld_generated_unwind_info, options::TWO_DASHES, '\0', true,
N_("Generate unwind information for PLT (default)"),
N_("Do not generate unwind information for PLT"));
DEFINE_special(library, options::TWO_DASHES, 'l',
- N_("Search for library LIBNAME"), N_("LIBNAME"));
+ N_("Search for library LIBNAME"), N_("LIBNAME"));
DEFINE_dirlist(library_path, options::TWO_DASHES, 'L',
DEFINE_dirlist(library_path, options::TWO_DASHES, 'L',
- N_("Add directory to search path"), N_("DIR"));
+ N_("Add directory to search path"), N_("DIR"));
DEFINE_bool(text_reorder, options::TWO_DASHES, '\0', true,
N_("Enable text section reordering for GCC section names "
DEFINE_bool(text_reorder, options::TWO_DASHES, '\0', true,
N_("Enable text section reordering for GCC section names "
N_("Disable text section reordering for GCC section names"));
DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false,
N_("Disable text section reordering for GCC section names"));
DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false,
- N_(" Only search directories specified on the command line."),
- NULL);
+ N_("Only search directories specified on the command line."),
+ NULL);
DEFINE_bool(rosegment, options::TWO_DASHES, '\0', false,
DEFINE_bool(rosegment, options::TWO_DASHES, '\0', false,
- N_(" Put read-only non-executable sections in their own segment"),
- NULL);
+ N_("Put read-only non-executable sections in their own segment"),
+ NULL);
DEFINE_string(m, options::EXACTLY_ONE_DASH, 'm', "",
DEFINE_string(m, options::EXACTLY_ONE_DASH, 'm', "",
- N_("Set GNU linker emulation; obsolete"), N_("EMULATION"));
+ N_("Set GNU linker emulation; obsolete"), N_("EMULATION"));
DEFINE_bool(mmap_output_file, options::TWO_DASHES, '\0', true,
DEFINE_bool(mmap_output_file, options::TWO_DASHES, '\0', true,
- N_("Map the output file for writing (default)."),
- N_("Do not map the output file for writing."));
+ N_("Map the output file for writing (default)."),
+ N_("Do not map the output file for writing."));
DEFINE_bool(print_map, options::TWO_DASHES, 'M', false,
N_("Write map file on standard output"), NULL);
DEFINE_bool(print_map, options::TWO_DASHES, 'M', false,
N_("Write map file on standard output"), NULL);
NULL, false);
DEFINE_string(output, options::TWO_DASHES, 'o', "a.out",
NULL, false);
DEFINE_string(output, options::TWO_DASHES, 'o', "a.out",
- N_("Set output file name"), N_("FILE"));
+ N_("Set output file name"), N_("FILE"));
DEFINE_uint(optimize, options::EXACTLY_ONE_DASH, 'O', 0,
DEFINE_uint(optimize, options::EXACTLY_ONE_DASH, 'O', 0,
- N_("Optimize output file size"), N_("LEVEL"));
+ N_("Optimize output file size"), N_("LEVEL"));
DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
N_("Set output format"), N_("[binary]"));
DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
N_("Set output format"), N_("[binary]"));
#ifdef ENABLE_PLUGINS
DEFINE_special(plugin, options::TWO_DASHES, '\0',
#ifdef ENABLE_PLUGINS
DEFINE_special(plugin, options::TWO_DASHES, '\0',
- N_("Load a plugin library"), N_("PLUGIN"));
+ N_("Load a plugin library"), N_("PLUGIN"));
DEFINE_special(plugin_opt, options::TWO_DASHES, '\0',
DEFINE_special(plugin_opt, options::TWO_DASHES, '\0',
- N_("Pass an option to the plugin"), N_("OPTION"));
+ N_("Pass an option to the plugin"), N_("OPTION"));
#endif
DEFINE_bool(posix_fallocate, options::TWO_DASHES, '\0', true,
#endif
DEFINE_bool(posix_fallocate, options::TWO_DASHES, '\0', true,
- N_("Use posix_fallocate to reserve space in the output file"
+ N_("Use posix_fallocate to reserve space in the output file"
- N_("Use fallocate or ftruncate to reserve space."));
+ N_("Use fallocate or ftruncate to reserve space."));
DEFINE_bool(preread_archive_symbols, options::TWO_DASHES, '\0', false,
DEFINE_bool(preread_archive_symbols, options::TWO_DASHES, '\0', false,
- N_("Preread archive symbols when multi-threaded"), NULL);
+ N_("Preread archive symbols when multi-threaded"), NULL);
DEFINE_bool(print_output_format, options::TWO_DASHES, '\0', false,
N_("Print default output format"), NULL);
DEFINE_bool(print_output_format, options::TWO_DASHES, '\0', false,
N_("Print default output format"), NULL);
N_("Ignored for SVR4 compatibility"), NULL);
DEFINE_bool(emit_relocs, options::TWO_DASHES, 'q', false,
N_("Ignored for SVR4 compatibility"), NULL);
DEFINE_bool(emit_relocs, options::TWO_DASHES, 'q', false,
- N_("Generate relocations in output"), NULL);
+ N_("Generate relocations in output"), NULL);
DEFINE_bool(relocatable, options::EXACTLY_ONE_DASH, 'r', false,
DEFINE_bool(relocatable, options::EXACTLY_ONE_DASH, 'r', false,
- N_("Generate relocatable output"), NULL);
+ N_("Generate relocatable output"), NULL);
DEFINE_bool_alias(i, relocatable, options::EXACTLY_ONE_DASH, '\0',
N_("Synonym for -r"), NULL, false);
DEFINE_bool_alias(i, relocatable, options::EXACTLY_ONE_DASH, '\0',
N_("Synonym for -r"), NULL, false);
N_("Relax branches on certain targets"), NULL);
DEFINE_string(retain_symbols_file, options::TWO_DASHES, '\0', NULL,
N_("Relax branches on certain targets"), NULL);
DEFINE_string(retain_symbols_file, options::TWO_DASHES, '\0', NULL,
- N_("keep only symbols listed in this file"), N_("FILE"));
+ N_("keep only symbols listed in this file"), N_("FILE"));
// -R really means -rpath, but can mean --just-symbols for
// compatibility with GNU ld. -rpath is always -rpath, so we list
// it separately.
DEFINE_special(R, options::EXACTLY_ONE_DASH, 'R',
// -R really means -rpath, but can mean --just-symbols for
// compatibility with GNU ld. -rpath is always -rpath, so we list
// it separately.
DEFINE_special(R, options::EXACTLY_ONE_DASH, 'R',
- N_("Add DIR to runtime search path"), N_("DIR"));
+ N_("Add DIR to runtime search path"), N_("DIR"));
DEFINE_dirlist(rpath, options::ONE_DASH, '\0',
DEFINE_dirlist(rpath, options::ONE_DASH, '\0',
- N_("Add DIR to runtime search path"), N_("DIR"));
+ N_("Add DIR to runtime search path"), N_("DIR"));
DEFINE_dirlist(rpath_link, options::TWO_DASHES, '\0',
DEFINE_dirlist(rpath_link, options::TWO_DASHES, '\0',
- N_("Add DIR to link time shared library search path"),
- N_("DIR"));
+ 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."),
DEFINE_string(section_ordering_file, options::TWO_DASHES, '\0', NULL,
N_("Layout sections in the order specified."),
N_("COUNT"));
DEFINE_bool(strip_all, options::TWO_DASHES, 's', false,
N_("COUNT"));
DEFINE_bool(strip_all, options::TWO_DASHES, 's', false,
- N_("Strip all symbols"), NULL);
+ N_("Strip all symbols"), NULL);
DEFINE_bool(strip_debug, options::TWO_DASHES, 'S', false,
DEFINE_bool(strip_debug, options::TWO_DASHES, 'S', false,
- N_("Strip debugging information"), NULL);
+ N_("Strip debugging information"), NULL);
DEFINE_bool(strip_debug_non_line, options::TWO_DASHES, '\0', false,
DEFINE_bool(strip_debug_non_line, options::TWO_DASHES, '\0', false,
- N_("Emit only debug line number information"), NULL);
+ N_("Emit only debug line number information"), NULL);
DEFINE_bool(strip_debug_gdb, options::TWO_DASHES, '\0', false,
DEFINE_bool(strip_debug_gdb, options::TWO_DASHES, '\0', false,
- N_("Strip debug symbols that are unused by gdb "
- "(at least versions <= 7.4)"), NULL);
+ N_("Strip debug symbols that are unused by gdb "
+ "(at least versions <= 7.4)"), NULL);
DEFINE_bool(strip_lto_sections, options::TWO_DASHES, '\0', true,
DEFINE_bool(strip_lto_sections, options::TWO_DASHES, '\0', true,
- N_("Strip LTO intermediate code sections"), NULL);
+ N_("Strip LTO intermediate code sections"), NULL);
DEFINE_int(stub_group_size, options::TWO_DASHES , '\0', 1,
DEFINE_int(stub_group_size, options::TWO_DASHES , '\0', 1,
- N_("(ARM, PowerPC only) The maximum distance from instructions "
+ N_("(ARM, PowerPC only) The maximum distance from instructions "
"in a group of sections to their stubs. Negative values mean "
"stubs are always after (PowerPC before) the group. 1 means "
"use default size.\n"),
N_("SIZE"));
DEFINE_bool(no_keep_memory, options::TWO_DASHES, '\0', false,
"in a group of sections to their stubs. Negative values mean "
"stubs are always after (PowerPC before) the group. 1 means "
"use default size.\n"),
N_("SIZE"));
DEFINE_bool(no_keep_memory, options::TWO_DASHES, '\0', false,
- N_("Use less memory and more disk I/O "
- "(included only for compatibility with GNU ld)"), NULL);
+ N_("Use less memory and more disk I/O "
+ "(included only for compatibility with GNU ld)"), NULL);
DEFINE_bool(shared, options::ONE_DASH, 'G', false,
DEFINE_bool(shared, options::ONE_DASH, 'G', false,
- N_("Generate shared library"), NULL);
+ N_("Generate shared library"), NULL);
DEFINE_bool(Bshareable, options::ONE_DASH, '\0', false,
DEFINE_bool(Bshareable, options::ONE_DASH, '\0', false,
- N_("Generate shared library"), NULL);
+ N_("Generate shared library"), NULL);
DEFINE_uint(split_stack_adjust_size, options::TWO_DASHES, '\0', 0x4000,
N_("Stack size when -fsplit-stack function calls non-split"),
DEFINE_uint(split_stack_adjust_size, options::TWO_DASHES, '\0', 0x4000,
N_("Stack size when -fsplit-stack function calls non-split"),
// This is not actually special in any way, but I need to give it
// a non-standard accessor-function name because 'static' is a keyword.
DEFINE_special(static, options::ONE_DASH, '\0',
// This is not actually special in any way, but I need to give it
// a non-standard accessor-function name because 'static' is a keyword.
DEFINE_special(static, options::ONE_DASH, '\0',
- N_("Do not link against shared libraries"), NULL);
+ N_("Do not link against shared libraries"), NULL);
DEFINE_enum(icf, options::TWO_DASHES, '\0', "none",
DEFINE_enum(icf, options::TWO_DASHES, '\0', "none",
- N_("Identical Code Folding. "
- "\'--icf=safe\' Folds ctors, dtors and functions whose"
- " pointers are definitely not taken."),
- ("[none,all,safe]"),
- {"none", "all", "safe"});
+ N_("Identical Code Folding. "
+ "\'--icf=safe\' Folds ctors, dtors and functions whose"
+ " pointers are definitely not taken."),
+ ("[none,all,safe]"),
+ {"none", "all", "safe"});
DEFINE_uint(icf_iterations, options::TWO_DASHES , '\0', 0,
DEFINE_uint(icf_iterations, options::TWO_DASHES , '\0', 0,
- N_("Number of iterations of ICF (default 2)"), N_("COUNT"));
+ N_("Number of iterations of ICF (default 2)"), N_("COUNT"));
DEFINE_bool(print_icf_sections, options::TWO_DASHES, '\0', false,
DEFINE_bool(print_icf_sections, options::TWO_DASHES, '\0', false,
- N_("List folded identical sections on stderr"),
- N_("Do not list folded identical sections"));
+ N_("List folded identical sections on stderr"),
+ N_("Do not list folded identical sections"));
DEFINE_set(keep_unique, options::TWO_DASHES, '\0',
N_("Do not fold this symbol during ICF"), N_("SYMBOL"));
DEFINE_bool(gc_sections, options::TWO_DASHES, '\0', false,
DEFINE_set(keep_unique, options::TWO_DASHES, '\0',
N_("Do not fold this symbol during ICF"), N_("SYMBOL"));
DEFINE_bool(gc_sections, options::TWO_DASHES, '\0', false,
- N_("Remove unused sections"),
- N_("Don't remove unused sections (default)"));
+ N_("Remove unused sections"),
+ N_("Don't remove unused sections (default)"));
DEFINE_bool(print_gc_sections, options::TWO_DASHES, '\0', false,
DEFINE_bool(print_gc_sections, options::TWO_DASHES, '\0', false,
- N_("List removed unused sections on stderr"),
- N_("Do not list removed unused sections"));
+ N_("List removed unused sections on stderr"),
+ N_("Do not list removed unused sections"));
DEFINE_bool(stats, options::TWO_DASHES, '\0', false,
DEFINE_bool(stats, options::TWO_DASHES, '\0', false,
- N_("Print resource usage statistics"), NULL);
+ N_("Print resource usage statistics"), NULL);
DEFINE_string(sysroot, options::TWO_DASHES, '\0', "",
DEFINE_string(sysroot, options::TWO_DASHES, '\0', "",
- N_("Set target system root directory"), N_("DIR"));
+ N_("Set target system root directory"), N_("DIR"));
DEFINE_bool(trace, options::TWO_DASHES, 't', false,
DEFINE_bool(trace, options::TWO_DASHES, 't', false,
- N_("Print the name of each input file"), NULL);
+ N_("Print the name of each input file"), NULL);
DEFINE_special(script, options::TWO_DASHES, 'T',
DEFINE_special(script, options::TWO_DASHES, 'T',
- N_("Read linker script"), N_("FILE"));
+ N_("Read linker script"), N_("FILE"));
DEFINE_bool(threads, options::TWO_DASHES, '\0', false,
DEFINE_bool(threads, options::TWO_DASHES, '\0', false,
- N_("Run the linker multi-threaded"),
- N_("Do not run the linker multi-threaded"));
+ N_("Run the linker multi-threaded"),
+ N_("Do not run the linker multi-threaded"));
DEFINE_uint(thread_count, options::TWO_DASHES, '\0', 0,
DEFINE_uint(thread_count, options::TWO_DASHES, '\0', 0,
- N_("Number of threads to use"), N_("COUNT"));
+ N_("Number of threads to use"), N_("COUNT"));
DEFINE_uint(thread_count_initial, options::TWO_DASHES, '\0', 0,
DEFINE_uint(thread_count_initial, options::TWO_DASHES, '\0', 0,
- N_("Number of threads to use in initial pass"), N_("COUNT"));
+ N_("Number of threads to use in initial pass"), N_("COUNT"));
DEFINE_uint(thread_count_middle, options::TWO_DASHES, '\0', 0,
DEFINE_uint(thread_count_middle, options::TWO_DASHES, '\0', 0,
- N_("Number of threads to use in middle pass"), N_("COUNT"));
+ N_("Number of threads to use in middle pass"), N_("COUNT"));
DEFINE_uint(thread_count_final, options::TWO_DASHES, '\0', 0,
DEFINE_uint(thread_count_final, options::TWO_DASHES, '\0', 0,
- N_("Number of threads to use in final pass"), N_("COUNT"));
+ N_("Number of threads to use in final pass"), N_("COUNT"));
DEFINE_uint64(Tbss, options::ONE_DASH, '\0', -1U,
DEFINE_uint64(Tbss, options::ONE_DASH, '\0', -1U,
- N_("Set the address of the bss segment"), N_("ADDRESS"));
+ N_("Set the address of the bss segment"), N_("ADDRESS"));
DEFINE_uint64(Tdata, options::ONE_DASH, '\0', -1U,
DEFINE_uint64(Tdata, options::ONE_DASH, '\0', -1U,
- N_("Set the address of the data segment"), N_("ADDRESS"));
+ N_("Set the address of the data segment"), N_("ADDRESS"));
DEFINE_uint64(Ttext, options::ONE_DASH, '\0', -1U,
DEFINE_uint64(Ttext, options::ONE_DASH, '\0', -1U,
- N_("Set the address of the text segment"), N_("ADDRESS"));
+ N_("Set the address of the text segment"), N_("ADDRESS"));
DEFINE_uint64_alias(Ttext_segment, Ttext, options::ONE_DASH, '\0',
N_("Set the address of the text segment"),
N_("ADDRESS"));
DEFINE_uint64_alias(Ttext_segment, Ttext, options::ONE_DASH, '\0',
N_("Set the address of the text segment"),
N_("ADDRESS"));
"ignore-in-shared-libs"});
DEFINE_bool(verbose, options::TWO_DASHES, '\0', false,
"ignore-in-shared-libs"});
DEFINE_bool(verbose, options::TWO_DASHES, '\0', false,
- N_("Synonym for --debug=files"), NULL);
+ N_("Synonym for --debug=files"), NULL);
DEFINE_special(version_script, options::TWO_DASHES, '\0',
DEFINE_special(version_script, options::TWO_DASHES, '\0',
- N_("Read version script"), N_("FILE"));
+ N_("Read version script"), N_("FILE"));
DEFINE_bool(warn_common, options::TWO_DASHES, '\0', false,
N_("Warn about duplicate common symbols"),
DEFINE_bool(warn_common, options::TWO_DASHES, '\0', false,
N_("Warn about duplicate common symbols"),
"wchar_t sizes"));
DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false,
"wchar_t sizes"));
DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false,
- N_("Include all archive contents"),
- N_("Include only needed archive contents"));
+ N_("Include all archive contents"),
+ N_("Include only needed archive contents"));
DEFINE_set(wrap, options::TWO_DASHES, '\0',
N_("Use wrapper functions for SYMBOL"), N_("SYMBOL"));
DEFINE_set(trace_symbol, options::TWO_DASHES, 'y',
DEFINE_set(wrap, options::TWO_DASHES, '\0',
N_("Use wrapper functions for SYMBOL"), N_("SYMBOL"));
DEFINE_set(trace_symbol, options::TWO_DASHES, 'y',
- N_("Trace references to symbol"), N_("SYMBOL"));
+ N_("Trace references to symbol"), N_("SYMBOL"));
DEFINE_bool(undefined_version, options::TWO_DASHES, '\0', true,
N_("Allow unused version in script (default)"),
DEFINE_bool(undefined_version, options::TWO_DASHES, '\0', true,
N_("Allow unused version in script (default)"),
N_("PATH"));
DEFINE_special(start_group, options::TWO_DASHES, '(',
N_("PATH"));
DEFINE_special(start_group, options::TWO_DASHES, '(',
- N_("Start a library search group"), NULL);
+ N_("Start a library search group"), NULL);
DEFINE_special(end_group, options::TWO_DASHES, ')',
DEFINE_special(end_group, options::TWO_DASHES, ')',
- N_("End a library search group"), NULL);
+ N_("End a library search group"), NULL);
DEFINE_special(start_lib, options::TWO_DASHES, '\0',
DEFINE_special(start_lib, options::TWO_DASHES, '\0',
- N_("Start a library"), NULL);
+ N_("Start a library"), NULL);
DEFINE_special(end_lib, options::TWO_DASHES, '\0',
DEFINE_special(end_lib, options::TWO_DASHES, '\0',
- N_("End a library "), NULL);
+ N_("End a library "), NULL);
DEFINE_string(fuse_ld, options::ONE_DASH, '\0', "",
N_("Ignored for GCC linker option compatibility"),
DEFINE_string(fuse_ld, options::ONE_DASH, '\0', "",
N_("Ignored for GCC linker option compatibility"),
N_("Sort dynamic relocs"),
N_("Do not sort dynamic relocs"));
DEFINE_uint64(common_page_size, options::DASH_Z, '\0', 0,
N_("Sort dynamic relocs"),
N_("Do not sort dynamic relocs"));
DEFINE_uint64(common_page_size, options::DASH_Z, '\0', 0,
- N_("Set common page size to SIZE"), N_("SIZE"));
+ N_("Set common page size to SIZE"), N_("SIZE"));
DEFINE_bool(defs, options::DASH_Z, '\0', false,
DEFINE_bool(defs, options::DASH_Z, '\0', false,
- N_("Report undefined symbols (even with --shared)"),
- NULL);
+ N_("Report undefined symbols (even with --shared)"),
+ NULL);
DEFINE_bool(execstack, options::DASH_Z, '\0', false,
DEFINE_bool(execstack, options::DASH_Z, '\0', false,
- N_("Mark output as requiring executable stack"), NULL);
+ N_("Mark output as requiring executable stack"), NULL);
DEFINE_bool(initfirst, options::DASH_Z, '\0', false,
N_("Mark DSO to be initialized first at runtime"),
NULL);
DEFINE_bool(initfirst, options::DASH_Z, '\0', false,
N_("Mark DSO to be initialized first at runtime"),
NULL);
N_("Mark object requiring immediate process"),
NULL);
DEFINE_uint64(max_page_size, options::DASH_Z, '\0', 0,
N_("Mark object requiring immediate process"),
NULL);
DEFINE_uint64(max_page_size, options::DASH_Z, '\0', 0,
- N_("Set maximum page size to SIZE"), N_("SIZE"));
+ N_("Set maximum page size to SIZE"), N_("SIZE"));
DEFINE_bool(muldefs, options::DASH_Z, '\0', false,
N_("Allow multiple definitions of symbols"),
NULL);
DEFINE_bool(muldefs, options::DASH_Z, '\0', false,
N_("Allow multiple definitions of symbols"),
NULL);
N_("Mark DSO not available to dldump"),
NULL);
DEFINE_bool(noexecstack, options::DASH_Z, '\0', false,
N_("Mark DSO not available to dldump"),
NULL);
DEFINE_bool(noexecstack, options::DASH_Z, '\0', false,
- N_("Mark output as not requiring executable stack"), NULL);
+ N_("Mark output as not requiring executable stack"), NULL);
DEFINE_bool(now, options::DASH_Z, '\0', false,
N_("Mark object for immediate function binding"),
NULL);
DEFINE_bool(origin, options::DASH_Z, '\0', false,
N_("Mark DSO to indicate that needs immediate $ORIGIN "
DEFINE_bool(now, options::DASH_Z, '\0', false,
N_("Mark object for immediate function binding"),
NULL);
DEFINE_bool(origin, options::DASH_Z, '\0', false,
N_("Mark DSO to indicate that needs immediate $ORIGIN "
- "processing at runtime"), NULL);
+ "processing at runtime"), NULL);
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(relro, options::DASH_Z, '\0', false,
N_("Where possible mark variables read-only after relocation"),
N_("Don't mark variables read-only after relocation"));
should_retain_symbol(const char* symbol_name) const
{
if (symbols_to_retain_.empty()) // means flag wasn't specified
should_retain_symbol(const char* symbol_name) const
{
if (symbols_to_retain_.empty()) // means flag wasn't specified
return symbols_to_retain_.find(symbol_name) != symbols_to_retain_.end();
}
return symbols_to_retain_.find(symbol_name) != symbols_to_retain_.end();
}
// Do not fold any functions (Default or --icf=none).
ICF_NONE,
// All functions are candidates for folding. (--icf=all).
// Do not fold any functions (Default or --icf=none).
ICF_NONE,
// All functions are candidates for folding. (--icf=all).
// Only ctors and dtors are candidates for folding. (--icf=safe).
ICF_SAFE
};
// Only ctors and dtors are candidates for folding. (--icf=safe).
ICF_SAFE
};
type__ \
varname__() const \
{ return this->varname__##_; } \
type__ \
varname__() const \
{ return this->varname__##_; } \
void \
set_##varname__(type__ value) \
{ this->varname__##_ = value; } \
void \
set_##varname__(type__ value) \
{ this->varname__##_ = value; } \
{
public:
Position_dependent_options(const General_options& options
{
public:
Position_dependent_options(const General_options& options
- = Position_dependent_options::default_options_)
+ = Position_dependent_options::default_options_)
{ copy_from_options(options); }
void copy_from_options(const General_options& options)
{ copy_from_options(options); }
void copy_from_options(const General_options& options)
{ }
Input_file_argument(const char* name, Input_file_type type,
{ }
Input_file_argument(const char* name, Input_file_type type,
- const char* extra_search_path,
- bool just_symbols,
- const Position_dependent_options& options)
+ const char* extra_search_path,
+ bool just_symbols,
+ const Position_dependent_options& options)
: name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ }
: name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ }
// position-independent vars from the General_options and only store
// those.
Input_file_argument(const char* name, Input_file_type type,
// position-independent vars from the General_options and only store
// those.
Input_file_argument(const char* name, Input_file_type type,
- const char* extra_search_path,
- bool just_symbols,
- const General_options& options)
+ const char* extra_search_path,
+ bool just_symbols,
+ const General_options& options)
: name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ }
: name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ }
extra_search_path() const
{
return (this->extra_search_path_.empty()
extra_search_path() const
{
return (this->extra_search_path_.empty()
- ? NULL
- : this->extra_search_path_.c_str());
+ ? NULL
+ : this->extra_search_path_.c_str());
}
// Return whether we should only read symbols from this file.
}
// Return whether we should only read symbols from this file.
// is set to true if argv[i] is "--".
int
process_one_option(int argc, const char** argv, int i,
// is set to true if argv[i] is "--".
int
process_one_option(int argc, const char** argv, int i,
- bool* no_more_options);
+ bool* no_more_options);
// Get the general options.
const General_options&
// Get the general options.
const General_options&