yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gold/

Browse Source 
* options.h (General_options): Remove leading space from help
	messages for -nostdlib and --rosegment.
This commit is contained in:
Roland McGrath 2013-05-10 20:35:47 +00:00
parent 21ff46861c
commit 0c6e6c39ad
2 changed files with 221 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gold/ChangeLog
View File

@ -1,3 +1,8 @@
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> 2013-05-03 Maciej W. Rozycki <macro@codesourcery.com>
PR ld/15365 PR ld/15365
@ -14802,7 +14807,7 @@
* Added source code to GNU binutils. * Added source code to GNU binutils.
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, Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright are permitted in any medium without royalty provided the copyright

429
gold/options.h
View File

@ -1,6 +1,7 @@
// 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>. // Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold. // This file is part of gold.
@ -120,7 +121,7 @@ parse_set(const char* option_name, const char* arg, String_set* retval);
extern void extern void
parse_choices(const char* option_name, const char* arg, const char** retval, 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 Struct_var; struct Struct_var;
@ -168,7 +169,7 @@ struct One_option
Struct_var* reader; Struct_var* reader;
One_option(const char* ln, Dashes d, char sn, const char* dv, 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 : ""), : longname(ln), dashes(d), shortname(sn), default_value(dv ? dv : ""),
helpstring(hs), helparg(ha), optional_arg(oa), reader(r) helpstring(hs), helparg(ha), optional_arg(oa), reader(r)
{ {
@ -219,7 +220,7 @@ struct Struct_var
// OPTIONS: the global General_options object. Used by DEFINE_special. // OPTIONS: the global General_options object. Used by DEFINE_special.
virtual void virtual void
parse_to_value(const char* option, const char* arg, parse_to_value(const char* option, const char* arg,
Command_line* cmdline, General_options* options) = 0; Command_line* cmdline, General_options* options) = 0;
virtual virtual
~Struct_var() // To make gcc happy. ~Struct_var() // To make gcc happy.
{ } { }
@ -230,16 +231,16 @@ struct Struct_special : public Struct_var
{ {
// If you change this, change the parse-fn in DEFINE_special as well. // If you change this, change the parse-fn in DEFINE_special as well.
typedef void (General_options::*Parse_function)(const char*, const char*, typedef void (General_options::*Parse_function)(const char*, const char*,
Command_line*); Command_line*);
Struct_special(const char* varname, Dashes dashes, char shortname, Struct_special(const char* varname, Dashes dashes, char shortname,
Parse_function parse_function, Parse_function parse_function,
const char* helpstring, const char* helparg) const char* helpstring, const char* helparg)
: option(varname, dashes, shortname, "", helpstring, helparg, false, this), : option(varname, dashes, shortname, "", helpstring, helparg, false, this),
parse(parse_function) parse(parse_function)
{ } { }
void parse_to_value(const char* option, const char* arg, 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); } { (options->*(this->parse))(option, arg, cmdline); }
One_option option; One_option option;
@ -261,17 +262,17 @@ struct Struct_special : public Struct_var
// avoid unintended macro substitution of "assert()", we need to enclose // avoid unintended macro substitution of "assert()", we need to enclose
// varname__ with parenthese. // varname__ with parenthese.
#define DEFINE_var(varname__, dashes__, shortname__, default_value__, \ #define DEFINE_var(varname__, dashes__, shortname__, default_value__, \
default_value_as_string__, helpstring__, helparg__, \ default_value_as_string__, helpstring__, helparg__, \
optional_arg__, type__, param_type__, parse_fn__) \ optional_arg__, type__, param_type__, parse_fn__) \
public: \ public: \
param_type__ \ param_type__ \
(varname__)() const \ (varname__)() const \
{ return this->varname__##_.value; } \ { return this->varname__##_.value; } \
\ \
bool \ bool \
user_set_##varname__() const \ user_set_##varname__() const \
{ return this->varname__##_.user_set_via_option; } \ { return this->varname__##_.user_set_via_option; } \
\ \
void \ void \
set_user_set_##varname__() \ set_user_set_##varname__() \
{ this->varname__##_.user_set_via_option = true; } \ { this->varname__##_.user_set_via_option = true; } \
@ -281,18 +282,18 @@ struct Struct_special : public Struct_var
{ \ { \
Struct_##varname__() \ Struct_##varname__() \
: option(#varname__, dashes__, shortname__, default_value_as_string__, \ : option(#varname__, dashes__, shortname__, default_value_as_string__, \
helpstring__, helparg__, optional_arg__, this), \ helpstring__, helparg__, optional_arg__, this), \
user_set_via_option(false), value(default_value__) \ user_set_via_option(false), value(default_value__) \
{ } \ { } \
\ \
void \ void \
parse_to_value(const char* option_name, const char* arg, \ 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); \ parse_fn__(option_name, arg, &this->value); \
this->user_set_via_option = true; \ this->user_set_via_option = true; \
} \ } \
\ \
options::One_option option; \ options::One_option option; \
bool user_set_via_option; \ bool user_set_via_option; \
type__ value; \ type__ value; \
@ -308,71 +309,71 @@ struct Struct_special : public Struct_var
// VARNAME, we also create an option called no-VARNAME (or, for a -z // VARNAME, we also create an option called no-VARNAME (or, for a -z
// option, noVARNAME). // option, noVARNAME).
#define DEFINE_bool(varname__, dashes__, shortname__, default_value__, \ #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, \ default_value__ ? "true" : "false", helpstring__, NULL, \
false, bool, bool, options::parse_bool) \ false, bool, bool, options::parse_bool) \
struct Struct_no_##varname__ : public options::Struct_var \ struct Struct_no_##varname__ : public options::Struct_var \
{ \ { \
Struct_no_##varname__() : option((dashes__ == options::DASH_Z \ Struct_no_##varname__() : option((dashes__ == options::DASH_Z \
? "no" #varname__ \ ? "no" #varname__ \
: "no-" #varname__), \ : "no-" #varname__), \
dashes__, '\0', \ dashes__, '\0', \
default_value__ ? "false" : "true", \ default_value__ ? "false" : "true", \
no_helpstring__, NULL, false, this) \ no_helpstring__, NULL, false, this) \
{ } \ { } \
\ \
void \ void \
parse_to_value(const char*, const char*, \ parse_to_value(const char*, const char*, \
Command_line*, General_options* options) \ Command_line*, General_options* options) \
{ \ { \
options->set_##varname__(false); \ options->set_##varname__(false); \
options->set_user_set_##varname__(); \ options->set_user_set_##varname__(); \
} \ } \
\ \
options::One_option option; \ options::One_option option; \
}; \ }; \
Struct_no_##varname__ no_##varname__##_initializer_ Struct_no_##varname__ no_##varname__##_initializer_
#define DEFINE_enable(varname__, dashes__, shortname__, default_value__, \ #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, \ default_value__ ? "true" : "false", helpstring__, NULL, \
false, bool, bool, options::parse_bool) \ false, bool, bool, options::parse_bool) \
struct Struct_disable_##varname__ : public options::Struct_var \ struct Struct_disable_##varname__ : public options::Struct_var \
{ \ { \
Struct_disable_##varname__() : option("disable-" #varname__, \ Struct_disable_##varname__() : option("disable-" #varname__, \
dashes__, '\0', \ dashes__, '\0', \
default_value__ ? "false" : "true", \ default_value__ ? "false" : "true", \
no_helpstring__, NULL, false, this) \ no_helpstring__, NULL, false, this) \
{ } \ { } \
\ \
void \ void \
parse_to_value(const char*, const char*, \ 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; \ options::One_option option; \
}; \ }; \
Struct_disable_##varname__ disable_##varname__##_initializer_ Struct_disable_##varname__ disable_##varname__##_initializer_
#define DEFINE_int(varname__, dashes__, shortname__, default_value__, \ #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, \ #default_value__, helpstring__, helparg__, false, \
int, int, options::parse_int) 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, \ #default_value__, helpstring__, helparg__, false, \
int, int, options::parse_uint) 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, \ #default_value__, helpstring__, helparg__, false, \
uint64_t, uint64_t, options::parse_uint64) uint64_t, uint64_t, options::parse_uint64)
#define DEFINE_double(varname__, dashes__, shortname__, default_value__, \ #define DEFINE_double(varname__, dashes__, shortname__, default_value__, \
helpstring__, helparg__) \ helpstring__, helparg__) \
@ -387,19 +388,19 @@ struct Struct_special : public Struct_var
double, double, options::parse_percent) double, double, options::parse_percent)
#define DEFINE_string(varname__, dashes__, shortname__, default_value__, \ #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, \ default_value__, helpstring__, helparg__, false, \
const char*, const char*, options::parse_string) const char*, const char*, options::parse_string)
// This is like DEFINE_string, but we convert each occurrence to a // 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 // Search_directory and store it in a vector. Thus we also have the
// add_to_VARNAME() method, to append to the vector. // add_to_VARNAME() method, to append to the vector.
#define DEFINE_dirlist(varname__, dashes__, shortname__, \ #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, \ "", helpstring__, helparg__, false, options::Dir_list, \
const options::Dir_list&, options::parse_dirlist) \ const options::Dir_list&, options::parse_dirlist) \
void \ void \
add_to_##varname__(const char* new_value) \ add_to_##varname__(const char* new_value) \
{ options::parse_dirlist(NULL, new_value, &this->varname__##_.value); } \ { options::parse_dirlist(NULL, new_value, &this->varname__##_.value); } \
@ -409,10 +410,10 @@ struct Struct_special : public Struct_var
// This is like DEFINE_string, but we store a set of strings. // This is like DEFINE_string, but we store a set of strings.
#define DEFINE_set(varname__, dashes__, shortname__, \ #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, \ "", helpstring__, helparg__, false, options::String_set, \
const options::String_set&, options::parse_set) \ const options::String_set&, options::parse_set) \
public: \ public: \
bool \ bool \
any_##varname__() const \ any_##varname__() const \
@ -422,8 +423,8 @@ struct Struct_special : public Struct_var
is_##varname__(const char* symbol) const \ is_##varname__(const char* symbol) const \
{ \ { \
return (!this->varname__##_.value.empty() \ return (!this->varname__##_.value.empty() \
&& (this->varname__##_.value.find(std::string(symbol)) \ && (this->varname__##_.value.find(std::string(symbol)) \
!= this->varname__##_.value.end())); \ != this->varname__##_.value.end())); \
} \ } \
\ \
options::String_set::const_iterator \ options::String_set::const_iterator \
@ -438,17 +439,17 @@ struct Struct_special : public Struct_var
// After helparg__ should come an initializer list, like // After helparg__ should come an initializer list, like
// {"foo", "bar", "baz"} // {"foo", "bar", "baz"}
#define DEFINE_enum(varname__, dashes__, shortname__, default_value__, \ #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, \ default_value__, helpstring__, helparg__, false, \
const char*, const char*, parse_choices_##varname__) \ const char*, const char*, parse_choices_##varname__) \
private: \ private: \
static void parse_choices_##varname__(const char* option_name, \ static void parse_choices_##varname__(const char* option_name, \
const char* arg, \ const char* arg, \
const char** retval) { \ const char** retval) { \
const char* choices[] = __VA_ARGS__; \ const char* choices[] = __VA_ARGS__; \
options::parse_choices(option_name, arg, retval, \ 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
@ -530,16 +531,16 @@ struct Struct_special : public Struct_var
// General_options; you are responsible for defining it there. // General_options; you are responsible for defining it there.
// helparg__ should be NULL iff this special-option is a boolean. // helparg__ should be NULL iff this special-option is a boolean.
#define DEFINE_special(varname__, dashes__, shortname__, \ #define DEFINE_special(varname__, dashes__, shortname__, \
helpstring__, helparg__) \ helpstring__, helparg__) \
private: \ private: \
void parse_##varname__(const char* option, const char* arg, \ void parse_##varname__(const char* option, const char* arg, \
Command_line* inputs); \ Command_line* inputs); \
struct Struct_##varname__ : public options::Struct_special \ struct Struct_##varname__ : public options::Struct_special \
{ \ { \
Struct_##varname__() \ Struct_##varname__() \
: options::Struct_special(#varname__, dashes__, shortname__, \ : options::Struct_special(#varname__, dashes__, shortname__, \
&General_options::parse_##varname__, \ &General_options::parse_##varname__, \
helpstring__, helparg__) \ helpstring__, helparg__) \
{ } \ { } \
}; \ }; \
Struct_##varname__ varname__##_initializer_ Struct_##varname__ varname__##_initializer_
@ -551,8 +552,8 @@ struct Struct_special : public Struct_var
default_value__, \ default_value__, \
helpstring__, helparg__) \ helpstring__, helparg__) \
DEFINE_var(varname__, dashes__, shortname__, default_value__, \ DEFINE_var(varname__, dashes__, shortname__, default_value__, \
default_value__, helpstring__, helparg__, true, \ default_value__, helpstring__, helparg__, true, \
const char*, const char*, options::parse_optional_string) const char*, const char*, options::parse_optional_string)
// A directory to search. For each directory we record whether it is // 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 // in the sysroot. We need to know this so that, if a linker script
@ -620,11 +621,11 @@ class General_options
// NOTE: For every option that you add here, also consider if you // NOTE: For every option that you add here, also consider if you
// should add it to Position_dependent_options. // should add it to Position_dependent_options.
DEFINE_special(help, options::TWO_DASHES, '\0', 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 // These options are sorted approximately so that for each letter in
// the alphabet, we show the option whose shortname is that letter // the alphabet, we show the option whose shortname is that letter
@ -641,12 +642,12 @@ class General_options
N_("Do not allow multiple definitions"), false); N_("Do not allow multiple definitions"), false);
DEFINE_bool(allow_shlib_undefined, options::TWO_DASHES, '\0', false, DEFINE_bool(allow_shlib_undefined, options::TWO_DASHES, '\0', false,
N_("Allow unresolved references in shared libraries"), N_("Allow unresolved references in shared libraries"),
N_("Do not 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_("Only set DT_NEEDED for shared libraries if used"),
N_("Always DT_NEEDED for shared libraries")); N_("Always DT_NEEDED for shared libraries"));
DEFINE_enum(assert, options::ONE_DASH, '\0', NULL, DEFINE_enum(assert, options::ONE_DASH, '\0', NULL,
N_("Ignored"), N_("[ignored]"), N_("Ignored"), N_("[ignored]"),
@ -657,10 +658,10 @@ class General_options
// accept any string. We'll fail later (when the string is parsed), // accept any string. We'll fail later (when the string is parsed),
// if the target isn't actually supported. // if the target isn't actually supported.
DEFINE_string(format, options::TWO_DASHES, 'b', "elf", 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', DEFINE_bool_alias(Bstatic, Bdynamic, options::ONE_DASH, '\0',
N_("-l does not search for shared libraries"), NULL, N_("-l does not search for shared libraries"), NULL,
true); true);
@ -673,7 +674,7 @@ class General_options
N_("Use group name lookup rules for shared library"), NULL); N_("Use group name lookup rules for shared library"), NULL);
DEFINE_bool(Bsymbolic, options::ONE_DASH, '\0', false, 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, DEFINE_bool(Bsymbolic_functions, options::ONE_DASH, '\0', false,
N_("Bind defined function symbols locally"), NULL); N_("Bind defined function symbols locally"), NULL);
@ -683,13 +684,13 @@ class General_options
N_("[=STYLE]")); N_("[=STYLE]"));
DEFINE_uint64(build_id_chunk_size_for_treehash, DEFINE_uint64(build_id_chunk_size_for_treehash,
options::TWO_DASHES, '\0', 2 << 20, options::TWO_DASHES, '\0', 2 << 20,
N_("Chunk size for '--build-id=tree'"), N_("SIZE")); 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, '\0', 40 << 20,
N_("Minimum output file size for '--build-id=tree' to work" N_("Minimum output file size for '--build-id=tree' to work"
" differently than '--build-id=sha1'"), N_("SIZE")); " differently than '--build-id=sha1'"), N_("SIZE"));
DEFINE_bool(check_sections, options::TWO_DASHES, '\0', true, DEFINE_bool(check_sections, options::TWO_DASHES, '\0', true,
N_("Check segment addresses for overlaps (default)"), N_("Check segment addresses for overlaps (default)"),
@ -697,14 +698,14 @@ class General_options
#ifdef HAVE_ZLIB_H #ifdef HAVE_ZLIB_H
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none", DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
N_("Compress .debug_* sections in the output file"), N_("Compress .debug_* sections in the output file"),
("[none,zlib]"), ("[none,zlib]"),
{"none", "zlib"}); {"none", "zlib"});
#else #else
DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none", DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
N_("Compress .debug_* sections in the output file"), N_("Compress .debug_* sections in the output file"),
N_("[none]"), N_("[none]"),
{"none"}); {"none"});
#endif #endif
DEFINE_bool(copy_dt_needed_entries, options::TWO_DASHES, '\0', false, DEFINE_bool(copy_dt_needed_entries, options::TWO_DASHES, '\0', false,
@ -720,19 +721,19 @@ class General_options
N_("Handle constructors as directed by compiler")); N_("Handle constructors as directed by compiler"));
DEFINE_bool(define_common, options::TWO_DASHES, 'd', false, DEFINE_bool(define_common, options::TWO_DASHES, 'd', false,
N_("Define common symbols"), N_("Define common symbols"),
N_("Do not 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_("Turn on debugging"),
N_("[all,files,script,task][,...]")); 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, DEFINE_optional_string(demangle, options::TWO_DASHES, '\0', NULL,
N_("Demangle C++ symbols in log messages"), N_("Demangle C++ symbols in log messages"),
@ -743,35 +744,35 @@ class General_options
NULL); NULL);
DEFINE_bool(detect_odr_violations, options::TWO_DASHES, '\0', false, 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")); N_("Do not look for violations of the C++ One Definition Rule"));
DEFINE_bool(discard_all, options::TWO_DASHES, 'x', false, DEFINE_bool(discard_all, options::TWO_DASHES, 'x', false,
N_("Delete all local symbols"), NULL); N_("Delete all local symbols"), NULL);
DEFINE_bool(discard_locals, options::TWO_DASHES, 'X', false, 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', DEFINE_special(exclude_libs, options::TWO_DASHES, '\0',
N_("Exclude libraries from automatic export"), N_("Exclude libraries from automatic export"),
N_(("lib,lib ..."))); N_(("lib,lib ...")));
DEFINE_bool(export_dynamic, options::TWO_DASHES, 'E', false, 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)")); N_("Do not export all dynamic symbols (default)"));
DEFINE_set(export_dynamic_symbol, options::TWO_DASHES, '\0', DEFINE_set(export_dynamic_symbol, options::TWO_DASHES, '\0',
@ -784,7 +785,7 @@ class General_options
N_("Link little-endian objects."), NULL); N_("Link little-endian objects."), NULL);
DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false, 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, DEFINE_bool(enum_size_warning, options::TWO_DASHES, '\0', true, NULL,
N_("(ARM only) Do not warn about objects with incompatible " N_("(ARM only) Do not warn about objects with incompatible "
@ -803,7 +804,7 @@ class General_options
N_("Do not treat warnings as errors")); N_("Do not treat warnings as errors"));
DEFINE_string(fini, options::ONE_DASH, '\0', "_fini", 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, DEFINE_bool(fix_cortex_a8, options::TWO_DASHES, '\0', false,
N_("(ARM only) Fix binaries for Cortex-A8 erratum."), N_("(ARM only) Fix binaries for Cortex-A8 erratum."),
@ -818,13 +819,13 @@ class General_options
N_("(ARM only) Do not merge exidx entries in debuginfo.")); N_("(ARM only) Do not merge exidx entries in debuginfo."));
DEFINE_special(fix_v4bx, options::TWO_DASHES, '\0', DEFINE_special(fix_v4bx, options::TWO_DASHES, '\0',
N_("(ARM only) Rewrite BX rn as MOV pc, rn for ARMv4"), N_("(ARM only) Rewrite BX rn as MOV pc, rn for ARMv4"),
NULL); 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 " N_("(ARM only) Rewrite BX rn branch to ARMv4 interworking "
"veneer"), "veneer"),
NULL); NULL);
DEFINE_bool(g, options::EXACTLY_ONE_DASH, '\0', false, DEFINE_bool(g, options::EXACTLY_ONE_DASH, '\0', false,
N_("Ignored"), NULL); N_("Ignored"), NULL);
@ -838,7 +839,7 @@ class General_options
N_("Disable STB_GNU_UNIQUE symbol binding")); N_("Disable STB_GNU_UNIQUE symbol binding"));
DEFINE_string(soname, options::ONE_DASH, 'h', NULL, 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, DEFINE_double(hash_bucket_empty_fraction, options::TWO_DASHES, '\0', 0.0,
N_("Min fraction of empty buckets in dynamic hash"), N_("Min fraction of empty buckets in dynamic hash"),
@ -849,7 +850,7 @@ class General_options
{"sysv", "gnu", "both"}); {"sysv", "gnu", "both"});
DEFINE_string(dynamic_linker, options::TWO_DASHES, 'I', NULL, 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', DEFINE_special(incremental, options::TWO_DASHES, '\0',
N_("Do an incremental link if possible; " N_("Do an incremental link if possible; "
@ -867,21 +868,21 @@ class General_options
N_("Do an incremental link; exit if not possible"), NULL); N_("Do an incremental link; exit if not possible"), NULL);
DEFINE_string(incremental_base, options::TWO_DASHES, '\0', NULL, DEFINE_string(incremental_base, options::TWO_DASHES, '\0', NULL,
N_("Set base file for incremental linking" N_("Set base file for incremental linking"
" (default is output file)"), " (default is output file)"),
N_("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); "(files preceding this option)"), NULL);
DEFINE_percent(incremental_patch, options::TWO_DASHES, '\0', 10, DEFINE_percent(incremental_patch, options::TWO_DASHES, '\0', 10,
@ -889,29 +890,29 @@ class General_options
N_("PERCENT")); N_("PERCENT"));
DEFINE_string(init, options::ONE_DASH, '\0', "_init", 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', DEFINE_bool(map_whole_files, options::TWO_DASHES, '\0',
sizeof(void*) >= 8, sizeof(void*) >= 8,
N_("Map whole files to memory (default on 64-bit hosts)"), N_("Map whole files to memory (default on 64-bit hosts)"),
N_("Map relevant file parts to memory (default on 32-bit " N_("Map relevant file parts to memory (default on 32-bit "
"hosts)")); "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_("Keep files mapped across passes (default)"),
N_("Release mapped files after each pass")); N_("Release mapped files after each pass"));
DEFINE_bool(ld_generated_unwind_info, options::TWO_DASHES, '\0', true, DEFINE_bool(ld_generated_unwind_info, options::TWO_DASHES, '\0', true,
N_("Generate unwind information for PLT (default)"), N_("Generate unwind information for PLT (default)"),
N_("Do not generate unwind information for PLT")); N_("Do not generate unwind information for PLT"));
DEFINE_special(library, options::TWO_DASHES, 'l', 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, DEFINE_bool(text_reorder, options::TWO_DASHES, '\0', true,
N_("Enable text section reordering for GCC section names " N_("Enable text section reordering for GCC section names "
@ -919,19 +920,19 @@ class General_options
N_("Disable text section reordering for GCC section names")); N_("Disable text section reordering for GCC section names"));
DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false, DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false,
N_(" Only search directories specified on the command line."), N_("Only search directories specified on the command line."),
NULL); 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"), N_("Put read-only non-executable sections in their own segment"),
NULL); 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_("Map the output file for writing (default)."),
N_("Do not map the output file for writing.")); N_("Do not map the output file for writing."));
DEFINE_bool(print_map, options::TWO_DASHES, 'M', false, DEFINE_bool(print_map, options::TWO_DASHES, 'M', false,
N_("Write map file on standard output"), NULL); N_("Write map file on standard output"), NULL);
@ -956,10 +957,10 @@ class General_options
NULL, false); NULL, false);
DEFINE_string(output, options::TWO_DASHES, 'o', "a.out", 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", DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
N_("Set output format"), N_("[binary]")); N_("Set output format"), N_("[binary]"));
@ -990,18 +991,18 @@ class General_options
#ifdef ENABLE_PLUGINS #ifdef ENABLE_PLUGINS
DEFINE_special(plugin, options::TWO_DASHES, '\0', 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 #endif
DEFINE_bool(posix_fallocate, options::TWO_DASHES, '\0', true, 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"
" (default)."), " (default)."),
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, DEFINE_bool(print_output_format, options::TWO_DASHES, '\0', false,
N_("Print default output format"), NULL); N_("Print default output format"), NULL);
@ -1014,10 +1015,10 @@ class General_options
N_("Ignored for SVR4 compatibility"), NULL); N_("Ignored for SVR4 compatibility"), NULL);
DEFINE_bool(emit_relocs, options::TWO_DASHES, 'q', false, 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', DEFINE_bool_alias(i, relocatable, options::EXACTLY_ONE_DASH, '\0',
N_("Synonym for -r"), NULL, false); N_("Synonym for -r"), NULL, false);
@ -1025,20 +1026,20 @@ class General_options
N_("Relax branches on certain targets"), NULL); N_("Relax branches on certain targets"), NULL);
DEFINE_string(retain_symbols_file, options::TWO_DASHES, '\0', 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 // -R really means -rpath, but can mean --just-symbols for
// compatibility with GNU ld. -rpath is always -rpath, so we list // compatibility with GNU ld. -rpath is always -rpath, so we list
// it separately. // it separately.
DEFINE_special(R, options::EXACTLY_ONE_DASH, 'R', 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_("Add DIR to link time shared library search path"),
N_("DIR")); N_("DIR"));
DEFINE_string(section_ordering_file, options::TWO_DASHES, '\0', NULL, DEFINE_string(section_ordering_file, options::TWO_DASHES, '\0', NULL,
N_("Layout sections in the order specified."), N_("Layout sections in the order specified."),
@ -1056,33 +1057,33 @@ class General_options
N_("COUNT")); N_("COUNT"));
DEFINE_bool(strip_all, options::TWO_DASHES, 's', false, 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 " N_("Strip debug symbols that are unused by gdb "
"(at least versions <= 7.4)"), NULL); "(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 " "in a group of sections to their stubs. Negative values mean "
"stubs are always after (PowerPC before) the group. 1 means " "stubs are always after (PowerPC before) the group. 1 means "
"use default size.\n"), "use default size.\n"),
N_("SIZE")); N_("SIZE"));
DEFINE_bool(no_keep_memory, options::TWO_DASHES, '\0', false, DEFINE_bool(no_keep_memory, options::TWO_DASHES, '\0', false,
N_("Use less memory and more disk I/O " N_("Use less memory and more disk I/O "
"(included only for compatibility with GNU ld)"), NULL); "(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, DEFINE_uint(split_stack_adjust_size, options::TWO_DASHES, '\0', 0x4000,
N_("Stack size when -fsplit-stack function calls non-split"), N_("Stack size when -fsplit-stack function calls non-split"),
@ -1091,63 +1092,63 @@ class General_options
// This is not actually special in any way, but I need to give it // 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. // a non-standard accessor-function name because 'static' is a keyword.
DEFINE_special(static, options::ONE_DASH, '\0', 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. " N_("Identical Code Folding. "
"\'--icf=safe\' Folds ctors, dtors and functions whose" "\'--icf=safe\' Folds ctors, dtors and functions whose"
" pointers are definitely not taken."), " pointers are definitely not taken."),
("[none,all,safe]"), ("[none,all,safe]"),
{"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_("List folded identical sections on stderr"),
N_("Do not list folded identical sections")); N_("Do not list folded identical sections"));
DEFINE_set(keep_unique, options::TWO_DASHES, '\0', DEFINE_set(keep_unique, options::TWO_DASHES, '\0',
N_("Do not fold this symbol during ICF"), N_("SYMBOL")); N_("Do not fold this symbol during ICF"), N_("SYMBOL"));
DEFINE_bool(gc_sections, options::TWO_DASHES, '\0', false, DEFINE_bool(gc_sections, options::TWO_DASHES, '\0', false,
N_("Remove unused sections"), N_("Remove unused sections"),
N_("Don't remove unused sections (default)")); 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_("List removed unused sections on stderr"),
N_("Do not list removed unused sections")); 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_("Run the linker multi-threaded"),
N_("Do not 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', DEFINE_uint64_alias(Ttext_segment, Ttext, options::ONE_DASH, '\0',
N_("Set the address of the text segment"), N_("Set the address of the text segment"),
N_("ADDRESS")); N_("ADDRESS"));
@ -1171,10 +1172,10 @@ class General_options
"ignore-in-shared-libs"}); "ignore-in-shared-libs"});
DEFINE_bool(verbose, options::TWO_DASHES, '\0', false, 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, DEFINE_bool(warn_common, options::TWO_DASHES, '\0', false,
N_("Warn about duplicate common symbols"), N_("Warn about duplicate common symbols"),
@ -1214,14 +1215,14 @@ class General_options
"wchar_t sizes")); "wchar_t sizes"));
DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false, DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false,
N_("Include all archive contents"), N_("Include all archive contents"),
N_("Include only needed archive contents")); N_("Include only needed archive contents"));
DEFINE_set(wrap, options::TWO_DASHES, '\0', DEFINE_set(wrap, options::TWO_DASHES, '\0',
N_("Use wrapper functions for SYMBOL"), N_("SYMBOL")); N_("Use wrapper functions for SYMBOL"), N_("SYMBOL"));
DEFINE_set(trace_symbol, options::TWO_DASHES, 'y', 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, DEFINE_bool(undefined_version, options::TWO_DASHES, '\0', true,
N_("Allow unused version in script (default)"), N_("Allow unused version in script (default)"),
@ -1232,15 +1233,15 @@ class General_options
N_("PATH")); N_("PATH"));
DEFINE_special(start_group, options::TWO_DASHES, '(', 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', "", DEFINE_string(fuse_ld, options::ONE_DASH, '\0', "",
N_("Ignored for GCC linker option compatibility"), N_("Ignored for GCC linker option compatibility"),
@ -1252,12 +1253,12 @@ class General_options
N_("Sort dynamic relocs"), N_("Sort dynamic relocs"),
N_("Do not sort dynamic relocs")); N_("Do not sort dynamic relocs"));
DEFINE_uint64(common_page_size, options::DASH_Z, '\0', 0, 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)"), N_("Report undefined symbols (even with --shared)"),
NULL); 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, DEFINE_bool(initfirst, options::DASH_Z, '\0', false,
N_("Mark DSO to be initialized first at runtime"), N_("Mark DSO to be initialized first at runtime"),
NULL); NULL);
@ -1271,7 +1272,7 @@ class General_options
N_("Mark object requiring immediate process"), N_("Mark object requiring immediate process"),
NULL); NULL);
DEFINE_uint64(max_page_size, options::DASH_Z, '\0', 0, 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, DEFINE_bool(muldefs, options::DASH_Z, '\0', false,
N_("Allow multiple definitions of symbols"), N_("Allow multiple definitions of symbols"),
NULL); NULL);
@ -1293,13 +1294,13 @@ class General_options
N_("Mark DSO not available to dldump"), N_("Mark DSO not available to dldump"),
NULL); NULL);
DEFINE_bool(noexecstack, options::DASH_Z, '\0', false, 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, DEFINE_bool(now, options::DASH_Z, '\0', false,
N_("Mark object for immediate function binding"), N_("Mark object for immediate function binding"),
NULL); NULL);
DEFINE_bool(origin, options::DASH_Z, '\0', false, DEFINE_bool(origin, options::DASH_Z, '\0', false,
N_("Mark DSO to indicate that needs immediate $ORIGIN " 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, DEFINE_bool(relro, options::DASH_Z, '\0', false,
N_("Where possible mark variables read-only after relocation"), N_("Where possible mark variables read-only after relocation"),
N_("Don't mark variables read-only after relocation")); N_("Don't mark variables read-only after relocation"));
@ -1381,7 +1382,7 @@ class General_options
should_retain_symbol(const char* symbol_name) const should_retain_symbol(const char* symbol_name) const
{ {
if (symbols_to_retain_.empty()) // means flag wasn't specified if (symbols_to_retain_.empty()) // means flag wasn't specified
return true; return true;
return symbols_to_retain_.find(symbol_name) != symbols_to_retain_.end(); return symbols_to_retain_.find(symbol_name) != symbols_to_retain_.end();
} }
@ -1524,7 +1525,7 @@ class General_options
// Do not fold any functions (Default or --icf=none). // Do not fold any functions (Default or --icf=none).
ICF_NONE, ICF_NONE,
// All functions are candidates for folding. (--icf=all). // All functions are candidates for folding. (--icf=all).
ICF_ALL, ICF_ALL,
// Only ctors and dtors are candidates for folding. (--icf=safe). // Only ctors and dtors are candidates for folding. (--icf=safe).
ICF_SAFE ICF_SAFE
}; };
@ -1617,7 +1618,7 @@ class General_options
type__ \ type__ \
varname__() const \ varname__() const \
{ return this->varname__##_; } \ { return this->varname__##_; } \
\ \
void \ void \
set_##varname__(type__ value) \ set_##varname__(type__ value) \
{ this->varname__##_ = value; } \ { this->varname__##_ = value; } \
@ -1628,7 +1629,7 @@ class Position_dependent_options
{ {
public: public:
Position_dependent_options(const General_options& options Position_dependent_options(const General_options& options
= Position_dependent_options::default_options_) = Position_dependent_options::default_options_)
{ copy_from_options(options); } { copy_from_options(options); }
void copy_from_options(const General_options& options) void copy_from_options(const General_options& options)
@ -1685,9 +1686,9 @@ class Input_file_argument
{ } { }
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, const char* extra_search_path,
bool just_symbols, bool just_symbols,
const Position_dependent_options& options) const Position_dependent_options& options)
: name_(name), type_(type), extra_search_path_(extra_search_path), : name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0) just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ } { }
@ -1697,9 +1698,9 @@ class Input_file_argument
// position-independent vars from the General_options and only store // position-independent vars from the General_options and only store
// those. // those.
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, const char* extra_search_path,
bool just_symbols, bool just_symbols,
const General_options& options) const General_options& options)
: name_(name), type_(type), extra_search_path_(extra_search_path), : name_(name), type_(type), extra_search_path_(extra_search_path),
just_symbols_(just_symbols), options_(options), arg_serial_(0) just_symbols_(just_symbols), options_(options), arg_serial_(0)
{ } { }
@ -1724,8 +1725,8 @@ class Input_file_argument
extra_search_path() const extra_search_path() const
{ {
return (this->extra_search_path_.empty() return (this->extra_search_path_.empty()
? NULL ? NULL
: this->extra_search_path_.c_str()); : 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.
@ -2038,7 +2039,7 @@ class Command_line
// is set to true if argv[i] is "--". // is set to true if argv[i] is "--".
int int
process_one_option(int argc, const char** argv, int i, process_one_option(int argc, const char** argv, int i,
bool* no_more_options); bool* no_more_options);
// Get the general options. // Get the general options.
const General_options& const General_options&