Print the default for all binary options; clean up --help output.

gold/
	PR gold/20346
	* options.cc (One_option::print): Print "(default)" when appropriate.
	* options.h: Clean up and re-sort options.
	(One_option::is_default): New data member.
	(One_option::One_option): Add is_default parameter; adjust all calls.
	(DEFINE_var): Add is_default__ parameter; adjust all calls.
	(DEFINE_bool): Set is_default based on default_value__.
	(DEFINE_bool_ignore): New macro.
	(--no-eh-frame-hdr): New option.
	(--enable-new-dtags): Remove mention of DT_FLAGS.

1 files changed, 309 insertions, 213 deletions

diff --git a/gold/options.h b/gold/options.h
index ac0306d..0aba4b7 100644
--- a/gold/options.h
+++ b/gold/options.h
@@ -154,6 +154,8 @@ enum Dashes
 //    --OPTION VALUE.
 // READER provides parse_to_value, which is a function that will convert
 //    a char* argument into the proper type and store it in some variable.
+// IS_DEFAULT is true for boolean options that are on by default,
+//    and thus should have "(default)" printed with the helpstring.
 // A One_option struct initializes itself with the global list of options
 // at constructor time, so be careful making one of these.
 struct One_option
@@ -166,11 +168,14 @@ struct One_option
   const char* helparg;
   bool optional_arg;
   Struct_var* reader;
+  bool is_default;
 
   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,
+	     bool id)
     : 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),
+      is_default(id)
   {
     // In longname, we convert all underscores to dashes, since GNU
     // style uses dashes in option names.  longname is likely to have
@@ -234,7 +239,8 @@ struct Struct_special : public Struct_var
   Struct_special(const char* varname, Dashes dashes, char shortname,
 		 Parse_function parse_function,
 		 const char* helpstring, const char* helparg)
-    : option(varname, dashes, shortname, "", helpstring, helparg, false, this),
+    : option(varname, dashes, shortname, "", helpstring, helparg, false, this,
+	     false),
       parse(parse_function)
   { }
 
@@ -262,7 +268,8 @@ struct Struct_special : public Struct_var
 // varname__ with parenthese.
 #define DEFINE_var(varname__, dashes__, shortname__, default_value__,        \
 		   default_value_as_string__, helpstring__, helparg__,       \
-		   optional_arg__, type__, param_type__, parse_fn__)	     \
+		   optional_arg__, type__, param_type__, parse_fn__,         \
+		   is_default__)					     \
  public:                                                                     \
   param_type__                                                               \
   (varname__)() const                                                        \
@@ -276,12 +283,14 @@ struct Struct_special : public Struct_var
   set_user_set_##varname__()						     \
   { this->varname__##_.user_set_via_option = true; }			     \
 									     \
+  static const bool varname__##is_default = is_default__;		     \
+									     \
  private:                                                                    \
   struct Struct_##varname__ : public options::Struct_var                     \
   {                                                                          \
     Struct_##varname__()                                                     \
       : option(#varname__, dashes__, shortname__, default_value_as_string__, \
-	       helpstring__, helparg__, optional_arg__, this),		     \
+	       helpstring__, helparg__, optional_arg__, this, is_default__), \
 	user_set_via_option(false), value(default_value__)                   \
     { }                                                                      \
 									     \
@@ -311,7 +320,7 @@ struct Struct_special : public Struct_var
 		    helpstring__, no_helpstring__)                       \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,          \
 	     default_value__ ? "true" : "false", helpstring__, NULL,     \
-	     false, bool, bool, options::parse_bool)			 \
+	     false, bool, bool, options::parse_bool, default_value__)	 \
   struct Struct_no_##varname__ : public options::Struct_var              \
   {                                                                      \
     Struct_no_##varname__() : option((dashes__ == options::DASH_Z	 \
@@ -319,7 +328,36 @@ struct Struct_special : public Struct_var
 				      : "no-" #varname__),		 \
 				     dashes__, '\0',			 \
 				     default_value__ ? "false" : "true", \
-				     no_helpstring__, NULL, false, this) \
+				     no_helpstring__, NULL, false, this, \
+				     !(default_value__))                 \
+    { }                                                                  \
+									 \
+    void                                                                 \
+    parse_to_value(const char*, const char*,                             \
+		   Command_line*, General_options* options)              \
+    {                                                                    \
+      options->set_##varname__(false);                                   \
+      options->set_user_set_##varname__();                               \
+    }                                                                    \
+									 \
+    options::One_option option;                                          \
+  };                                                                     \
+  Struct_no_##varname__ no_##varname__##_initializer_
+
+#define DEFINE_bool_ignore(varname__, dashes__, shortname__,		 \
+		    helpstring__, no_helpstring__)                       \
+  DEFINE_var(varname__, dashes__, shortname__, false,			 \
+	     "false", helpstring__, NULL,				 \
+	     false, bool, bool, options::parse_bool, false)		 \
+  struct Struct_no_##varname__ : public options::Struct_var              \
+  {                                                                      \
+    Struct_no_##varname__() : option((dashes__ == options::DASH_Z	 \
+				      ? "no" #varname__			 \
+				      : "no-" #varname__),		 \
+				     dashes__, '\0',			 \
+				     "false",				 \
+				     no_helpstring__, NULL, false, this, \
+				     false)				 \
     { }                                                                  \
 									 \
     void                                                                 \
@@ -338,13 +376,14 @@ struct Struct_special : public Struct_var
 		      helpstring__, no_helpstring__)                     \
   DEFINE_var(enable_##varname__, dashes__, shortname__, default_value__, \
 	     default_value__ ? "true" : "false", helpstring__, NULL,     \
-	     false, bool, bool, options::parse_bool)			 \
+	     false, bool, bool, options::parse_bool, default_value__)	 \
   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) \
+				     no_helpstring__, NULL, false, this, \
+				     !default_value__)                   \
     { }                                                                  \
 									 \
     void                                                                 \
@@ -360,37 +399,37 @@ struct Struct_special : public Struct_var
 		   helpstring__, helparg__)                             \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,         \
 	     #default_value__, helpstring__, helparg__, false,		\
-	     int, int, options::parse_int)
+	     int, int, options::parse_int, false)
 
 #define DEFINE_uint(varname__, dashes__, shortname__, default_value__,  \
 		   helpstring__, helparg__)                             \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,         \
 	     #default_value__, helpstring__, helparg__, false,		\
-	     int, int, options::parse_uint)
+	     int, int, options::parse_uint, false)
 
 #define DEFINE_uint64(varname__, dashes__, shortname__, default_value__, \
 		      helpstring__, helparg__)                           \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,          \
 	     #default_value__, helpstring__, helparg__, false,		 \
-	     uint64_t, uint64_t, options::parse_uint64)
+	     uint64_t, uint64_t, options::parse_uint64, false)
 
 #define DEFINE_double(varname__, dashes__, shortname__, default_value__, \
 		      helpstring__, helparg__)				 \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,		 \
 	     #default_value__, helpstring__, helparg__, false,		 \
-	     double, double, options::parse_double)
+	     double, double, options::parse_double, false)
 
 #define DEFINE_percent(varname__, dashes__, shortname__, default_value__, \
 		       helpstring__, helparg__)				  \
   DEFINE_var(varname__, dashes__, shortname__, default_value__ / 100.0,	  \
 	     #default_value__, helpstring__, helparg__, false,		  \
-	     double, double, options::parse_percent)
+	     double, double, options::parse_percent, false)
 
 #define DEFINE_string(varname__, dashes__, shortname__, default_value__, \
 		      helpstring__, helparg__)                           \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,          \
 	     default_value__, helpstring__, helparg__, false,		 \
-	     const char*, const char*, options::parse_string)
+	     const char*, const char*, options::parse_string, false)
 
 // 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
@@ -399,7 +438,7 @@ struct Struct_special : public Struct_var
 			   helpstring__, helparg__)                       \
   DEFINE_var(varname__, dashes__, shortname__, ,                          \
 	     "", helpstring__, helparg__, false, options::Dir_list,	  \
-	     const options::Dir_list&, options::parse_dirlist)            \
+	     const options::Dir_list&, options::parse_dirlist, false)     \
   void                                                                    \
   add_to_##varname__(const char* new_value)                               \
   { options::parse_dirlist(NULL, new_value, &this->varname__##_.value); } \
@@ -412,7 +451,7 @@ struct Struct_special : public Struct_var
 		   helpstring__, helparg__)                               \
   DEFINE_var(varname__, dashes__, shortname__, ,                          \
 	     "", helpstring__, helparg__, false, options::String_set,     \
-	     const options::String_set&, options::parse_set)              \
+	     const options::String_set&, options::parse_set, false)       \
  public:                                                                  \
   bool                                                                    \
   any_##varname__() const                                                 \
@@ -441,7 +480,7 @@ struct Struct_special : public Struct_var
 		    helpstring__, helparg__, ...)                        \
   DEFINE_var(varname__, dashes__, shortname__, default_value__,          \
 	     default_value__, helpstring__, helparg__, false,		 \
-	     const char*, const char*, parse_choices_##varname__)        \
+	     const char*, const char*, parse_choices_##varname__, false) \
  private:                                                                \
   static void parse_choices_##varname__(const char* option_name,         \
 					const char* arg,                 \
@@ -461,7 +500,8 @@ struct Struct_special : public Struct_var
   {									\
     Struct_##option__()							\
       : option(#option__, dashes__, shortname__, "", helpstring__,	\
-	       NULL, false, this)					\
+	       NULL, false, this,					\
+	       General_options::varname__##is_default ^ invert__)	\
     { }									\
 									\
     void								\
@@ -483,7 +523,8 @@ struct Struct_special : public Struct_var
 		? "no" #option__					\
 		: "no-" #option__),					\
 	       dashes__, '\0', "", no_helpstring__,			\
-	       NULL, false, this)					\
+	       NULL, false, this,					\
+	       !General_options::varname__##is_default ^ invert__)	\
     { }									\
 									\
     void								\
@@ -507,7 +548,7 @@ struct Struct_special : public Struct_var
   {									\
     Struct_##option__()							\
       : option(#option__, dashes__, shortname__, "", helpstring__,	\
-	       helparg__, false, this)					\
+	       helparg__, false, this, false)				\
     { }									\
 									\
     void								\
@@ -552,7 +593,8 @@ struct Struct_special : public Struct_var
 			       helpstring__, helparg__)			\
   DEFINE_var(varname__, dashes__, shortname__, default_value__,		\
 	     default_value__, helpstring__, helparg__, true,		\
-	     const char*, const char*, options::parse_optional_string)
+	     const char*, const char*, options::parse_optional_string,  \
+	     false)
 
 // 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
@@ -632,12 +674,15 @@ class General_options
   // alphabetical order).  For both, lowercase sorts before uppercase.
   // The -z options come last.
 
+  // a
+
   DEFINE_bool(add_needed, options::TWO_DASHES, '\0', false,
 	      N_("Not supported"),
 	      N_("Do not copy DT_NEEDED tags from shared libraries"));
 
   DEFINE_bool_alias(allow_multiple_definition, muldefs, options::TWO_DASHES,
-		    '\0', N_("Allow multiple definitions of symbols"),
+		    '\0',
+		    N_("Allow multiple definitions of symbols"),
 		    N_("Do not allow multiple definitions"), false);
 
   DEFINE_bool(allow_shlib_undefined, options::TWO_DASHES, '\0', false,
@@ -645,18 +690,20 @@ class General_options
 	      N_("Do not allow unresolved references in shared libraries"));
 
   DEFINE_bool(apply_dynamic_relocs, options::TWO_DASHES, '\0', true,
-	      N_("Apply link-time values for dynamic relocations (default)"),
+	      N_("Apply link-time values for dynamic relocations"),
 	      N_("(aarch64 only) Do not apply link-time values "
 		 "for dynamic relocations"));
 
   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_("Use DT_NEEDED only for shared libraries that are used"),
+	      N_("Use DT_NEEDED for all shared libraries"));
 
   DEFINE_enum(assert, options::ONE_DASH, '\0', NULL,
 	      N_("Ignored"), N_("[ignored]"),
 	      {"definitions", "nodefinitions", "nosymbolic", "pure-text"});
 
+  // b
+
   // This should really be an "enum", but it's too easy for folks to
   // forget to update the list as they add new targets.  So we just
   // accept any string.  We'll fail later (when the string is parsed),
@@ -664,6 +711,22 @@ class General_options
   DEFINE_string(format, options::TWO_DASHES, 'b', "elf",
 		N_("Set input format"), ("[elf,binary]"));
 
+  DEFINE_bool(be8,options::TWO_DASHES, '\0', false,
+	      N_("Output BE8 format image"), NULL);
+
+  DEFINE_optional_string(build_id, options::TWO_DASHES, '\0', "tree",
+			 N_("Generate build ID note"),
+			 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"));
+
+  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"));
+
   DEFINE_bool(Bdynamic, options::ONE_DASH, '\0', true,
 	      N_("-l searches for shared libraries"), NULL);
   DEFINE_bool_alias(Bstatic, Bdynamic, options::ONE_DASH, '\0',
@@ -674,33 +737,22 @@ class General_options
   DEFINE_bool_alias(dn, Bdynamic, options::ONE_DASH, '\0',
 		    N_("alias for -Bstatic"), NULL, true);
 
-  DEFINE_bool(be8,options::TWO_DASHES, '\0', false,
-	      N_("Output BE8 format image"), NULL);
-
   DEFINE_bool(Bgroup, options::ONE_DASH, '\0', false,
 	      N_("Use group name lookup rules for shared library"), NULL);
 
+  DEFINE_bool(Bshareable, options::ONE_DASH, '\0', false,
+	      N_("Generate shared library (alias for -G/-shared)"), NULL);
+
   DEFINE_bool(Bsymbolic, options::ONE_DASH, '\0', false,
 	      N_("Bind defined symbols locally"), NULL);
 
   DEFINE_bool(Bsymbolic_functions, options::ONE_DASH, '\0', false,
 	      N_("Bind defined function symbols locally"), NULL);
 
-  DEFINE_optional_string(build_id, options::TWO_DASHES, '\0', "tree",
-			 N_("Generate build ID note"),
-			 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"));
-
-  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"));
+  // c
 
   DEFINE_bool(check_sections, options::TWO_DASHES, '\0', true,
-	      N_("Check segment addresses for overlaps (default)"),
+	      N_("Check segment addresses for overlaps"),
 	      N_("Do not check segment addresses for overlaps"));
 
   DEFINE_enum(compress_debug_sections, options::TWO_DASHES, '\0', "none",
@@ -717,12 +769,14 @@ class General_options
 	      N_("Do not output cross reference table"));
 
   DEFINE_bool(ctors_in_init_array, options::TWO_DASHES, '\0', true,
-	      N_("Use DT_INIT_ARRAY for all constructors (default)"),
+	      N_("Use DT_INIT_ARRAY for all constructors"),
 	      N_("Handle constructors as directed by compiler"));
 
+  // d
+
   DEFINE_bool(define_common, options::TWO_DASHES, 'd', false,
 	      N_("Define common symbols"),
-	      N_("Do not define common symbols"));
+	      N_("Do not define common symbols in relocatable output"));
   DEFINE_bool(dc, options::ONE_DASH, '\0', false,
 	      N_("Alias for -d"), NULL);
   DEFINE_bool(dp, options::ONE_DASH, '\0', false,
@@ -738,7 +792,6 @@ class General_options
   DEFINE_optional_string(demangle, options::TWO_DASHES, '\0', NULL,
 			 N_("Demangle C++ symbols in log messages"),
 			 N_("[=STYLE]"));
-
   DEFINE_bool(no_demangle, options::TWO_DASHES, '\0', false,
 	      N_("Do not demangle C++ symbols in log messages"),
 	      NULL);
@@ -747,13 +800,6 @@ class General_options
 	      N_("Look for violations of the C++ One Definition Rule"),
 	      N_("Do not look for violations of the C++ One Definition Rule"));
 
-  DEFINE_special(discard_all, options::TWO_DASHES, 'x',
-		 N_("Delete all local symbols"), NULL);
-  DEFINE_special(discard_locals, options::TWO_DASHES, 'X',
-		 N_("Delete all temporary local symbols"), NULL);
-  DEFINE_special(discard_none, options::TWO_DASHES, '\0',
-		 N_("Keep all local symbols"), NULL);
-
   DEFINE_bool(dynamic_list_data, options::TWO_DASHES, '\0', false,
 	      N_("Add data symbols to dynamic symbols"), NULL);
 
@@ -766,32 +812,41 @@ class General_options
   DEFINE_special(dynamic_list, options::TWO_DASHES, '\0',
 		 N_("Read a list of dynamic symbols"), N_("FILE"));
 
+  // e
+
   DEFINE_string(entry, options::TWO_DASHES, 'e', NULL,
 		N_("Set program start address"), N_("ADDRESS"));
 
+  DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false,
+	      N_("Create exception frame header"),
+	      N_("Do not create exception frame header"));
+
+  // Alphabetized under 'e' because the option is spelled --enable-new-dtags.
+  DEFINE_enable(new_dtags, options::EXACTLY_TWO_DASHES, '\0', true,
+		N_("Enable use of DT_RUNPATH"),
+		N_("Disable use of DT_RUNPATH"));
+
+  DEFINE_bool(enum_size_warning, options::TWO_DASHES, '\0', true, NULL,
+	      N_("(ARM only) Do not warn about objects with incompatible "
+		 "enum sizes"));
+
   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_("Do not export all dynamic symbols (default)"));
+	      N_("Do not export all dynamic symbols"));
 
   DEFINE_set(export_dynamic_symbol, options::TWO_DASHES, '\0',
 	     N_("Export SYMBOL to dynamic symbol table"), N_("SYMBOL"));
 
   DEFINE_special(EB, options::ONE_DASH, '\0',
 		 N_("Link big-endian objects."), NULL);
-
   DEFINE_special(EL, options::ONE_DASH, '\0',
 		 N_("Link little-endian objects."), NULL);
 
-  DEFINE_bool(eh_frame_hdr, options::TWO_DASHES, '\0', false,
-	      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 "
-		 "enum sizes"));
+  // f
 
   DEFINE_set(auxiliary, options::TWO_DASHES, 'f',
 	     N_("Auxiliary filter for shared object symbol table"),
@@ -808,25 +863,21 @@ class General_options
   DEFINE_string(fini, options::ONE_DASH, '\0', "_fini",
 		N_("Call SYMBOL at unload-time"), N_("SYMBOL"));
 
+  DEFINE_bool(fix_arm1176, options::TWO_DASHES, '\0', true,
+	      N_("(ARM only) Fix binaries for ARM1176 erratum"),
+	      N_("(ARM only) Do not fix binaries for ARM1176 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 fix binaries for Cortex-A8 erratum."));
+	      N_("(ARM only) Fix binaries for Cortex-A8 erratum"),
+	      N_("(ARM only) Do not fix binaries for Cortex-A8 erratum"));
 
   DEFINE_bool(fix_cortex_a53_843419, options::TWO_DASHES, '\0', false,
-	      N_("(AArch64 only) Fix Cortex-A53 erratum 843419."),
-	      N_("(AArch64 only) Do not fix Cortex-A53 erratum 843419."));
+	      N_("(AArch64 only) Fix Cortex-A53 erratum 843419"),
+	      N_("(AArch64 only) Do not fix Cortex-A53 erratum 843419"));
 
   DEFINE_bool(fix_cortex_a53_835769, options::TWO_DASHES, '\0', false,
-	      N_("(AArch64 only) Fix Cortex-A53 erratum 835769."),
-	      N_("(AArch64 only) Do not fix Cortex-A53 erratum 835769."));
-
-  DEFINE_bool(fix_arm1176, options::TWO_DASHES, '\0', true,
-	      N_("(ARM only) Fix binaries for ARM1176 erratum."),
-	      N_("(ARM only) Do not fix binaries for ARM1176 erratum."));
-
-  DEFINE_bool(merge_exidx_entries, options::TWO_DASHES, '\0', true,
-	      N_("(ARM only) Merge exidx entries in debuginfo."),
-	      N_("(ARM only) Do not merge exidx entries in debuginfo."));
+	      N_("(AArch64 only) Fix Cortex-A53 erratum 835769"),
+	      N_("(AArch64 only) Do not fix Cortex-A53 erratum 835769"));
 
   DEFINE_special(fix_v4bx, options::TWO_DASHES, '\0',
 		 N_("(ARM only) Rewrite BX rn as MOV pc, rn for ARMv4"),
@@ -837,21 +888,32 @@ class General_options
 		    "veneer"),
 		 NULL);
 
-  DEFINE_bool(long_plt, options::TWO_DASHES, '\0', false,
-	      N_("(ARM only) Generate long PLT entries"),
-	      N_("(ARM only) Do not generate long PLT entries"));
+  DEFINE_string(fuse_ld, options::ONE_DASH, '\0', "",
+		N_("Ignored for GCC linker option compatibility"),
+		"");
+
+  // g
 
   DEFINE_bool(g, options::EXACTLY_ONE_DASH, '\0', false,
 	      N_("Ignored"), NULL);
 
+  DEFINE_bool(gc_sections, options::TWO_DASHES, '\0', false,
+	      N_("Remove unused sections"),
+	      N_("Don't remove unused sections"));
+
   DEFINE_bool(gdb_index, options::TWO_DASHES, '\0', false,
 	      N_("Generate .gdb_index section"),
 	      N_("Do not generate .gdb_index section"));
 
   DEFINE_bool(gnu_unique, options::TWO_DASHES, '\0', true,
-	      N_("Enable STB_GNU_UNIQUE symbol binding (default)"),
+	      N_("Enable STB_GNU_UNIQUE symbol binding"),
 	      N_("Disable STB_GNU_UNIQUE symbol binding"));
 
+  DEFINE_bool(shared, options::ONE_DASH, 'G', false,
+	      N_("Generate shared library"), NULL);
+
+  // h
+
   DEFINE_string(soname, options::ONE_DASH, 'h', NULL,
 		N_("Set shared library name"), N_("FILENAME"));
 
@@ -863,8 +925,20 @@ class General_options
 	      N_("Dynamic hash style"), N_("[sysv,gnu,both]"),
 	      {"sysv", "gnu", "both"});
 
-  DEFINE_string(dynamic_linker, options::TWO_DASHES, 'I', NULL,
-		N_("Set dynamic linker path"), N_("PROGRAM"));
+  // i
+
+  DEFINE_bool_alias(i, relocatable, options::EXACTLY_ONE_DASH, '\0',
+		    N_("Alias for -r"), NULL, false);
+
+  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"});
+
+  DEFINE_uint(icf_iterations, options::TWO_DASHES , '\0', 0,
+	      N_("Number of iterations of ICF (default 2)"), N_("COUNT"));
 
   DEFINE_special(incremental, options::TWO_DASHES, '\0',
 		 N_("Do an incremental link if possible; "
@@ -900,91 +974,108 @@ class General_options
 		    "(files preceding this option)"), NULL);
 
   DEFINE_percent(incremental_patch, options::TWO_DASHES, '\0', 10,
-		 N_("Amount of extra space to allocate for patches"),
+		 N_("Amount of extra space to allocate for patches "
+		    "(default 10)"),
 		 N_("PERCENT"));
 
   DEFINE_string(init, options::ONE_DASH, '\0', "_init",
 		N_("Call SYMBOL at load-time"), N_("SYMBOL"));
 
+  DEFINE_string(dynamic_linker, options::TWO_DASHES, 'I', NULL,
+		N_("Set dynamic linker path"), N_("PROGRAM"));
+
+  // j
+
   DEFINE_special(just_symbols, options::TWO_DASHES, '\0',
 		 N_("Read only symbol values from FILE"), N_("FILE"));
 
-  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)"));
+  // k
+
   DEFINE_bool(keep_files_mapped, options::TWO_DASHES, '\0', true,
-	      N_("Keep files mapped across passes (default)"),
+	      N_("Keep files mapped across passes"),
 	      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_set(keep_unique, options::TWO_DASHES, '\0',
+	     N_("Do not fold this symbol during ICF"), N_("SYMBOL"));
+
+  // l
 
   DEFINE_special(library, options::TWO_DASHES, 'l',
 		 N_("Search for library LIBNAME"), N_("LIBNAME"));
 
+  DEFINE_bool(ld_generated_unwind_info, options::TWO_DASHES, '\0', true,
+	      N_("Generate unwind information for PLT"),
+	      N_("Do not generate unwind information for PLT"));
+
   DEFINE_dirlist(library_path, options::TWO_DASHES, 'L',
 		 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 "
-		 "(default)"),
-	      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);
-
-  DEFINE_bool(rosegment, options::TWO_DASHES, '\0', false,
-	      N_("Put read-only non-executable sections in their own segment"),
-	      NULL);
+  DEFINE_bool(long_plt, options::TWO_DASHES, '\0', false,
+	      N_("(ARM only) Generate long PLT entries"),
+	      N_("(ARM only) Do not generate long PLT entries"));
 
-  DEFINE_uint64(rosegment_gap, options::TWO_DASHES, '\0', -1U,
-		N_("Set offset between executable and read-only segments"),
-		N_("OFFSET"));
+  // m
 
   DEFINE_string(m, options::EXACTLY_ONE_DASH, 'm', "",
 		N_("Set GNU linker emulation; obsolete"), N_("EMULATION"));
 
+  DEFINE_bool(map_whole_files, options::TWO_DASHES, '\0',
+	      sizeof(void*) >= 8,
+	      N_("Map whole files to memory"),
+	      N_("Map relevant file parts to memory"));
+
+  DEFINE_bool(merge_exidx_entries, options::TWO_DASHES, '\0', true,
+	      N_("(ARM only) Merge exidx entries in debuginfo"),
+	      N_("(ARM only) Do not merge exidx entries in debuginfo"));
+
   DEFINE_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"),
+	      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_string(Map, options::ONE_DASH, '\0', NULL, N_("Write map file"),
 		N_("MAPFILENAME"));
 
+  // n
+
   DEFINE_bool(nmagic, options::TWO_DASHES, 'n', false,
 	      N_("Do not page align data"), NULL);
   DEFINE_bool(omagic, options::EXACTLY_TWO_DASHES, 'N', false,
 	      N_("Do not page align data, do not make text readonly"),
 	      N_("Page align data, make text readonly"));
 
-  DEFINE_enable(new_dtags, options::EXACTLY_TWO_DASHES, '\0', true,
-		N_("Enable use of DT_RUNPATH and DT_FLAGS"),
-		N_("Disable use of DT_RUNPATH and DT_FLAGS"));
-
-  DEFINE_bool(noinhibit_exec, options::TWO_DASHES, '\0', false,
-	      N_("Create an output file even if errors occur"), NULL);
+  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);
 
   DEFINE_bool_alias(no_undefined, defs, options::TWO_DASHES, '\0',
 		    N_("Report undefined symbols (even with --shared)"),
 		    NULL, false);
 
+  DEFINE_bool(noinhibit_exec, options::TWO_DASHES, '\0', false,
+	      N_("Create an output file even if errors occur"), NULL);
+
+  DEFINE_bool(nostdlib, options::ONE_DASH, '\0', false,
+	      N_("Only search directories specified on the command line"),
+	      NULL);
+
+  // o
+
   DEFINE_string(output, options::TWO_DASHES, 'o', "a.out",
 		N_("Set output file name"), N_("FILE"));
 
+  DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
+		N_("Set output format"), N_("[binary]"));
+
   DEFINE_uint(optimize, options::EXACTLY_ONE_DASH, 'O', 0,
 	      N_("Optimize output file size"), N_("LEVEL"));
 
-  DEFINE_string(oformat, options::EXACTLY_TWO_DASHES, '\0', "elf",
-		N_("Set output format"), N_("[binary]"));
+  // p
 
-  DEFINE_bool(p, options::ONE_DASH, '\0', false,
-	      N_("(ARM only) Ignore for backward compatibility"), NULL);
+  DEFINE_bool(p, options::ONE_DASH, 'p', false,
+	      N_("Ignored for ARM compatibility"), NULL);
 
   DEFINE_bool(pie, options::ONE_DASH, '\0', false,
 	      N_("Create a position independent executable"),
@@ -1003,7 +1094,7 @@ class General_options
 
   DEFINE_var(plt_align, options::TWO_DASHES, '\0', 0, "5",
 	     N_("(PowerPC64 only) Align PLT call stubs to fit cache lines"),
-	     N_("[=P2ALIGN]"), true, int, int, options::parse_uint);
+	     N_("[=P2ALIGN]"), true, int, int, options::parse_uint, false);
 
   DEFINE_bool(plt_static_chain, options::TWO_DASHES, '\0', false,
 	      N_("(PowerPC64 only) PLT call stubs should load r11"),
@@ -1021,13 +1112,20 @@ class General_options
 #endif
 
   DEFINE_bool(posix_fallocate, options::TWO_DASHES, '\0', true,
-	      N_("Use posix_fallocate to reserve space in the output file"
-		 " (default)."),
-	      N_("Use fallocate or ftruncate to reserve space."));
+	      N_("Use posix_fallocate to reserve space in the output file"),
+	      N_("Use fallocate or ftruncate to reserve space"));
 
   DEFINE_bool(preread_archive_symbols, options::TWO_DASHES, '\0', false,
 	      N_("Preread archive symbols when multi-threaded"), NULL);
 
+  DEFINE_bool(print_gc_sections, options::TWO_DASHES, '\0', false,
+	      N_("List removed unused sections on stderr"),
+	      N_("Do not list removed unused sections"));
+
+  DEFINE_bool(print_icf_sections, options::TWO_DASHES, '\0', false,
+	      N_("List folded identical sections on stderr"),
+	      N_("Do not list folded identical sections"));
+
   DEFINE_bool(print_output_format, options::TWO_DASHES, '\0', false,
 	      N_("Print default output format"), NULL);
 
@@ -1035,16 +1133,18 @@ class General_options
 		N_("Print symbols defined and used for each input"),
 		N_("FILENAME"));
 
-  DEFINE_bool(Qy, options::EXACTLY_ONE_DASH, '\0', false,
-	      N_("Ignored for SVR4 compatibility"), NULL);
+  // q
 
   DEFINE_bool(emit_relocs, options::TWO_DASHES, 'q', false,
 	      N_("Generate relocations in output"), NULL);
 
+  DEFINE_bool(Qy, options::EXACTLY_ONE_DASH, '\0', false,
+	      N_("Ignored for SVR4 compatibility"), NULL);
+
+  // r
+
   DEFINE_bool(relocatable, options::EXACTLY_ONE_DASH, 'r', false,
 	      N_("Generate relocatable output"), NULL);
-  DEFINE_bool_alias(i, relocatable, options::EXACTLY_ONE_DASH, '\0',
-		    N_("Synonym for -r"), NULL, false);
 
   DEFINE_bool(relax, options::TWO_DASHES, '\0', false,
 	      N_("Relax branches on certain targets"), NULL);
@@ -1052,6 +1152,14 @@ class General_options
   DEFINE_string(retain_symbols_file, options::TWO_DASHES, '\0', NULL,
 		N_("keep only symbols listed in this file"), N_("FILE"));
 
+  DEFINE_bool(rosegment, options::TWO_DASHES, '\0', false,
+	      N_("Put read-only non-executable sections in their own segment"),
+	      NULL);
+
+  DEFINE_uint64(rosegment_gap, options::TWO_DASHES, '\0', -1U,
+		N_("Set offset between executable and read-only segments"),
+		N_("OFFSET"));
+
   // -R really means -rpath, but can mean --just-symbols for
   // compatibility with GNU ld.  -rpath is always -rpath, so we list
   // it separately.
@@ -1065,8 +1173,22 @@ class General_options
 		 N_("Add DIR to link time shared library search path"),
 		 N_("DIR"));
 
+  // s
+
+  DEFINE_bool(strip_all, options::TWO_DASHES, 's', false,
+	      N_("Strip all symbols"), NULL);
+  DEFINE_bool(strip_debug, options::TWO_DASHES, 'S', false,
+	      N_("Strip debugging information"), NULL);
+  DEFINE_bool(strip_debug_non_line, options::TWO_DASHES, '\0', false,
+	      N_("Emit only debug line number information"), NULL);
+  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);
+  DEFINE_bool(strip_lto_sections, options::TWO_DASHES, '\0', true,
+	      N_("Strip LTO intermediate code sections"), 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"),
 		N_("FILENAME"));
 
   DEFINE_special(section_start, options::TWO_DASHES, '\0',
@@ -1086,35 +1208,13 @@ class General_options
 	      N_("Dynamic tag slots to reserve (default 5)"),
 	      N_("COUNT"));
 
-  DEFINE_bool(strip_all, options::TWO_DASHES, 's', false,
-	      N_("Strip all symbols"), NULL);
-  DEFINE_bool(strip_debug, options::TWO_DASHES, 'S', false,
-	      N_("Strip debugging information"), NULL);
-  DEFINE_bool(strip_debug_non_line, options::TWO_DASHES, '\0', false,
-	      N_("Emit only debug line number information"), NULL);
-  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);
-  DEFINE_bool(strip_lto_sections, options::TWO_DASHES, '\0', true,
-	      N_("Strip LTO intermediate code sections"), NULL);
-
   DEFINE_int(stub_group_size, options::TWO_DASHES , '\0', 1,
 	     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"),
+		"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_("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);
-
-  DEFINE_bool(shared, options::ONE_DASH, 'G', false,
-	      N_("Generate shared library"), NULL);
-
-  DEFINE_bool(Bshareable, options::ONE_DASH, '\0', false,
-	      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"),
 	      N_("SIZE"));
@@ -1124,30 +1224,10 @@ class General_options
   DEFINE_special(static, options::ONE_DASH, '\0',
 		 N_("Do not link against shared libraries"), NULL);
 
-  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"});
-
-  DEFINE_uint(icf_iterations, options::TWO_DASHES , '\0', 0,
-	      N_("Number of iterations of ICF (default 2)"), N_("COUNT"));
-
-  DEFINE_bool(print_icf_sections, options::TWO_DASHES, '\0', false,
-	      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,
-	      N_("Remove unused sections"),
-	      N_("Don't remove unused sections (default)"));
-
-  DEFINE_bool(print_gc_sections, options::TWO_DASHES, '\0', false,
-	      N_("List removed unused sections on stderr"),
-	      N_("Do not list removed unused sections"));
+  DEFINE_special(start_lib, options::TWO_DASHES, '\0',
+		 N_("Start a library"), NULL);
+  DEFINE_special(end_lib, options::TWO_DASHES, '\0',
+		 N_("End a library "), NULL);
 
   DEFINE_bool(stats, options::TWO_DASHES, '\0', false,
 	      N_("Print resource usage statistics"), NULL);
@@ -1155,22 +1235,25 @@ class General_options
   DEFINE_string(sysroot, options::TWO_DASHES, '\0', "",
 		N_("Set target system root directory"), N_("DIR"));
 
-  DEFINE_bool(target1_rel, options::TWO_DASHES, '\0', false,
-	      N_("(ARM only) Force R_ARM_TARGET1 type to R_ARM_REL32"),
-	      NULL);
+  // t
+
+  DEFINE_bool(trace, options::TWO_DASHES, 't', false,
+	      N_("Print the name of each input file"), NULL);
+
   DEFINE_bool(target1_abs, options::TWO_DASHES, '\0', false,
 	      N_("(ARM only) Force R_ARM_TARGET1 type to R_ARM_ABS32"),
 	      NULL);
+  DEFINE_bool(target1_rel, options::TWO_DASHES, '\0', false,
+	      N_("(ARM only) Force R_ARM_TARGET1 type to R_ARM_REL32"),
+	      NULL);
   DEFINE_enum(target2, options::TWO_DASHES, '\0', NULL,
 	      N_("(ARM only) Set R_ARM_TARGET2 relocation type"),
 	      N_("[rel, abs, got-rel"),
 	      {"rel", "abs", "got-rel"});
 
-  DEFINE_bool(trace, options::TWO_DASHES, 't', false,
-	      N_("Print the name of each input file"), NULL);
-
-  DEFINE_special(script, options::TWO_DASHES, 'T',
-		 N_("Read linker script"), N_("FILE"));
+  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(threads, options::TWO_DASHES, '\0', false,
 	      N_("Run the linker multi-threaded"),
@@ -1184,6 +1267,17 @@ class General_options
   DEFINE_uint(thread_count_final, options::TWO_DASHES, '\0', 0,
 	      N_("Number of threads to use in final pass"), N_("COUNT"));
 
+  DEFINE_bool(toc_optimize, options::TWO_DASHES, '\0', true,
+	      N_("(PowerPC64 only) Optimize TOC code sequences"),
+	      N_("(PowerPC64 only) Don't optimize TOC code sequences"));
+
+  DEFINE_bool(toc_sort, options::TWO_DASHES, '\0', true,
+	      N_("(PowerPC64 only) Sort TOC and GOT sections"),
+	      N_("(PowerPC64 only) Don't sort TOC and GOT sections"));
+
+  DEFINE_special(script, options::TWO_DASHES, 'T',
+		 N_("Read linker script"), N_("FILE"));
+
   DEFINE_uint64(Tbss, options::ONE_DASH, '\0', -1U,
 		N_("Set the address of the bss segment"), N_("ADDRESS"));
   DEFINE_uint64(Tdata, options::ONE_DASH, '\0', -1U,
@@ -1196,13 +1290,7 @@ class General_options
   DEFINE_uint64(Trodata_segment, options::ONE_DASH, '\0', -1U,
 		N_("Set the address of the rodata segment"), N_("ADDRESS"));
 
-  DEFINE_bool(toc_optimize, options::TWO_DASHES, '\0', true,
-	      N_("(PowerPC64 only) Optimize TOC code sequences"),
-	      N_("(PowerPC64 only) Don't optimize TOC code sequences"));
-
-  DEFINE_bool(toc_sort, options::TWO_DASHES, '\0', true,
-	      N_("(PowerPC64 only) Sort TOC and GOT sections"),
-	      N_("(PowerPC64 only) Don't sort TOC and GOT sections"));
+  // u
 
   DEFINE_set(undefined, options::TWO_DASHES, 'u',
 	     N_("Create undefined reference to SYMBOL"), N_("SYMBOL"));
@@ -1214,22 +1302,26 @@ class General_options
 	      {"ignore-all", "report-all", "ignore-in-object-files",
 		  "ignore-in-shared-libs"});
 
+  // v
+
   DEFINE_bool(verbose, options::TWO_DASHES, '\0', false,
-	      N_("Synonym for --debug=files"), NULL);
+	      N_("Alias for --debug=files"), NULL);
 
   DEFINE_special(version_script, options::TWO_DASHES, '\0',
 		 N_("Read version script"), N_("FILE"));
 
+  // w
+
   DEFINE_bool(warn_common, options::TWO_DASHES, '\0', false,
 	      N_("Warn about duplicate common symbols"),
-	      N_("Do not warn about duplicate common symbols (default)"));
+	      N_("Do not warn about duplicate common symbols"));
 
-  DEFINE_bool(warn_constructors, options::TWO_DASHES, '\0', false,
-	      N_("Ignored"), N_("Ignored"));
+  DEFINE_bool_ignore(warn_constructors, options::TWO_DASHES, '\0',
+		     N_("Ignored"), N_("Ignored"));
 
   DEFINE_bool(warn_execstack, options::TWO_DASHES, '\0', false,
 	      N_("Warn if the stack is executable"),
-	      N_("Do not warn if the stack is executable (default)"));
+	      N_("Do not warn if the stack is executable"));
 
   DEFINE_bool(warn_mismatch, options::TWO_DASHES, '\0', true,
 	      NULL, N_("Don't warn about mismatched input files"));
@@ -1243,7 +1335,7 @@ class General_options
 
   DEFINE_bool(warn_shared_textrel, options::TWO_DASHES, '\0', false,
 	      N_("Warn if text segment is not shareable"),
-	      N_("Do not warn if text segment is not shareable (default)"));
+	      N_("Do not warn if text segment is not shareable"));
 
   DEFINE_bool(warn_unresolved_symbols, options::TWO_DASHES, '\0', false,
 	      N_("Report unresolved symbols as warnings"),
@@ -1252,14 +1344,15 @@ class General_options
 		    options::TWO_DASHES, '\0',
 		    N_("Report unresolved symbols as errors"),
 		    NULL, true);
-  DEFINE_bool(weak_unresolved_symbols, options::TWO_DASHES, '\0', false,
-	      N_("Convert unresolved symbols to weak references"),
-	      NULL);
 
   DEFINE_bool(wchar_size_warning, options::TWO_DASHES, '\0', true, NULL,
 	      N_("(ARM only) Do not warn about objects with incompatible "
 		 "wchar_t sizes"));
 
+  DEFINE_bool(weak_unresolved_symbols, options::TWO_DASHES, '\0', false,
+	      N_("Convert unresolved symbols to weak references"),
+	      NULL);
+
   DEFINE_bool(whole_archive, options::TWO_DASHES, '\0', false,
 	      N_("Include all archive contents"),
 	      N_("Include only needed archive contents"));
@@ -1267,32 +1360,35 @@ class General_options
   DEFINE_set(wrap, options::TWO_DASHES, '\0',
 	     N_("Use wrapper functions for SYMBOL"), N_("SYMBOL"));
 
+  // x
+
+  DEFINE_special(discard_all, options::TWO_DASHES, 'x',
+		 N_("Delete all local symbols"), NULL);
+  DEFINE_special(discard_locals, options::TWO_DASHES, 'X',
+		 N_("Delete all temporary local symbols"), NULL);
+  DEFINE_special(discard_none, options::TWO_DASHES, '\0',
+		 N_("Keep all local symbols"), NULL);
+
+  // y
+
   DEFINE_set(trace_symbol, options::TWO_DASHES, 'y',
 	     N_("Trace references to symbol"), N_("SYMBOL"));
 
   DEFINE_bool(undefined_version, options::TWO_DASHES, '\0', true,
-	      N_("Allow unused version in script (default)"),
+	      N_("Allow unused version in script"),
 	      N_("Do not allow unused version in script"));
 
   DEFINE_string(Y, options::EXACTLY_ONE_DASH, 'Y', "",
 		N_("Default search path for Solaris compatibility"),
 		N_("PATH"));
 
+  // special characters
+
   DEFINE_special(start_group, options::TWO_DASHES, '(',
 		 N_("Start a library search group"), NULL);
   DEFINE_special(end_group, options::TWO_DASHES, ')',
 		 N_("End a library search group"), NULL);
 
-
-  DEFINE_special(start_lib, options::TWO_DASHES, '\0',
-		 N_("Start a library"), NULL);
-  DEFINE_special(end_lib, options::TWO_DASHES, '\0',
-		 N_("End a library "), NULL);
-
-  DEFINE_string(fuse_ld, options::ONE_DASH, '\0', "",
-		N_("Ignored for GCC linker option compatibility"),
-		"");
-
   // The -z options.
 
   DEFINE_bool(combreloc, options::DASH_Z, '\0', true,
@@ -1315,7 +1411,7 @@ class General_options
 	      N_("Mark object to interpose all DSOs but executable"),
 	      NULL);
   DEFINE_bool_alias(lazy, now, options::DASH_Z, '\0',
-		    N_("Mark object for lazy runtime binding (default)"),
+		    N_("Mark object for lazy runtime binding"),
 		    NULL, true);
   DEFINE_bool(loadfltr, options::DASH_Z, '\0', false,
 	      N_("Mark object requiring immediate process"),
@@ -1357,9 +1453,9 @@ class General_options
 		N_("Set PT_GNU_STACK segment p_memsz to SIZE"), N_("SIZE"));
   DEFINE_bool(text, options::DASH_Z, '\0', false,
 	      N_("Do not permit relocations in read-only segments"),
-	      N_("Permit relocations in read-only segments (default)"));
+	      N_("Permit relocations in read-only segments"));
   DEFINE_bool_alias(textoff, text, options::DASH_Z, '\0',
-		    N_("Permit relocations in read-only segments (default)"),
+		    N_("Permit relocations in read-only segments"),
 		    NULL, true);
 
  public: