[ELF] - Introduce multiclass Eq helper for Options.td

[grimar]

Summary

Eq helper allows to define XXX and XXX= options forms easily.
Patch adds testcases for ferw aliases.

[ruiu]

ELF/Driver.cpp

809

Rebase and remove this line.

ELF/Options.td

10

Is JSEq short for Joined-Separate-EQual? That doesn't make much sense. I'd name this just Eq.

11

Remove space before :.

Use the extended version as we don't need to save characters here.

def "": Separate<["--", "-"], name>;
def _eq: Joined<["--", "-"], name # "=">, Alias<!cast<Separate>(name)>;

12

NAME -> name

31

I think it is better to remove help from JSEq and keep HelpText for each option.

[grimar]

• Addressed review comments.

ELF/Driver.cpp

809

Done.

ELF/Options.td

10

Done.

11

Done.

12

'name' will not work here.
Because name is a variable passed, which is option name used
for rendering, for example library-path.
But NAME would be library_path, because NAME is the special entry,
it is a name of def record itself.

See:
"Each def record has a special entry called “NAME”. This is the name of the record (“ADD32rr” above). In the general case def names can be formed from various kinds of string processing expressions and NAME resolves to the final value obtained after resolving all of those expressions. The user may refer to NAME anywhere she desires to use the ultimate name of the def. NAME should not be defined anywhere else in user code to avoid conflicts."
http://llvm.org/docs/TableGen/index.html

31

I would not do that because of next reasons:

• It breaks our help output. Because libOption implementation renders all options which has help text. If I do that change, we will end up with duplicated options with the same help text.
• It is inconsistent - we do not apply help text for other aliases. So we will have situations where we have option with text and alias with text vs option with help text and alias without.
• It does not make sence to have help text set for alias. I mean practical sence, this information will be always probably be unused.

[ruiu]

ELF/Options.td

31

I think showing both non-alias and alias options in the --help message is fine, and that's actually we want. I want everything to show up in the --help message as long as the linker accepts it.

[grimar]

ELF/Options.td

31

What I mean that we probably may want:
-library-path <value>, -library-path=<value> Some help text here
Single line with list of options and one help text. That requires D35476 change.

But if we assign HelpText for both option and its alias, like you suggest,
our output currently will be multilined and duplicated:
-library-path <value> Some help text here
-library-path=<value> Some help text here

That does not look as desired result, no ?

[ruiu]

ELF/Options.td

31

I think that is fine.

[grimar]

ELF/Options.td

31

What about options that have other aliases ? For example if I would do this change
for entry option, its declaration should be:

defm entry: Eq<"entry">, HelpText<"Name of entry point symbol">, MetaVarName<"<entry>">;
def alias_entry_e: JoinedOrSeparate<["-"], "e">, HelpText<"Name of entry point symbol">, Alias<entry>;

To produce output that you want:

--entry  <entry>   Name of entry point symbol
--entry= <entry>  Name of entry point symbol
-e <entry>            Name of entry point symbol

Do you want to define HelpText for aliases like alias_entry_e too ?

[ruiu]

ELF/Options.td

31

I don't care about that that much. It at least doesn't look bad to me, it is easy to understand and easy to parse. Even if we want something else, I don't like to do everything at once.

[grimar]

• Addressed review comments (move HelpText out of multiclass helper).

[ruiu]

Please keep Options.td in 80 columns.

[grimar]

• Reformated to 80 characters per line

(where possible, for lines changed by patch only).

[ruiu]

ELF/Options.td

207

I don't think this is correct. If you pass --output=foo, it should be interpreted as -o utput=foo.

[grimar]

ELF/Options.td

207

Both bfd and gold disagree with that:

umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.bfd -v
GNU ld (GNU Binutils for Ubuntu) 2.26.1
umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.gold -v
GNU gold (GNU Binutils for Ubuntu 2.26.1) 1.11
umb@umb-virtual-machine:~/tests/502_optionsalias$ ls
test.o
umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.gold -shared test.o --output=foo1
umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.bfd -shared test.o --output=foo2
umb@umb-virtual-machine:~/tests/502_optionsalias$ ls
foo1 foo2 test.o

[ruiu]

ELF/Options.td

207

Sorry, I meant -output=foo.

[grimar]

ELF/Options.td

207

ld.gold and ld.bfd disagree for -output=foo:

umb@umb-virtual-machine:~/tests/502_optionsalias$ ls
test.o
umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.gold -shared test.o -output=foo1
umb@umb-virtual-machine:~/tests/502_optionsalias$ ld.bfd -shared test.o -output=foo2
umb@umb-virtual-machine:~/tests/502_optionsalias$ ls
foo1 test.o utput=foo2
umb@umb-virtual-machine:~/tests/502_optionsalias$

I think we can choose any behavior. As I mentioned in description, I changed that for
--output because it makes declaration simpler and consistent with gold at the same time.

Do you prefer with bfd behavior ? gold one allows be a bit more consistent in this patch.

[ruiu]

ELF/Options.td

310–311

Sort

[ruiu]

If that's the case, that's a bug in gold, if they aim compatibility with ld.bfd. The manual page for ld.bfd clearly states that -o<something> should be interpreted as -o <something>

[grimar]

• Addressed comments, restored -o behavior, cosmetic changes.

[ruiu]

LGTM

[grimar]

In D35619#817302, @ruiu wrote:

LGTM

Thanks !

Looks now we want to add HelpText for all others aliases we have so
they show up in help among regular options and _eq aliases ?

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->OptRemarksWithHotness = Args.hasArg(OPT_opt_remarks_with_hotness);
   Config->Optimize = getInteger(Args, OPT_O, 1);
   Config->OutputFile = Args.getLastArgValue(OPT_o);
   Config->Pie = getArg(Args, OPT_pie, OPT_nopie, false);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Rpath = getRpath(Args);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
-  Config->SearchPaths = getArgs(Args, OPT_L);
+  Config->SearchPaths = getArgs(Args, OPT_library_path);
   Config->SectionStartMap = getSectionStartMap(Args);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->SingleRoRx = Args.hasArg(OPT_no_rosegment);
   Config->SoName = Args.getLastArgValue(OPT_soname);
   Config->SortSection = getSortSection(Args);
   Config->Strip = getStrip(Args);
   Config->Sysroot = Args.getLastArgValue(OPT_sysroot);
   Config->Target1Rel = getArg(Args, OPT_target1_rel, OPT_target1_abs, false);
static bool getBinaryOption(StringRef S) {
   error("unknown -format value: " + S +
         " (supported formats: elf, default, binary)");
   return false;
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getUnaliasedOption().getID()) {
-    case OPT_l:
+    case OPT_library:
       addLibrary(Arg->getValue());
       break;
     case OPT_INPUT:
       addFile(Arg->getValue(), /*WithLOption=*/false);
       break;
     case OPT_script:
       if (Optional<MemoryBufferRef> MB = readFile(Arg->getValue()))
         readLinkerScript(*MB);

ELF/DriverUtils.cpp

case OPT_INPUT:
       break;
     case OPT_o:
       // If -o path contains directories, "lld @response.txt" will likely
       // fail because the archive we are creating doesn't contain empty
       // directories for the output path (-o doesn't create directories).
       // Strip directories to prevent the issue.
       OS << "-o " << quote(sys::path::filename(Arg->getValue())) << "\n";
       break;
-    case OPT_L:
     case OPT_dynamic_list:
+    case OPT_library_path:
     case OPT_rpath:
     case OPT_script:
     case OPT_version_script:
       OS << Arg->getSpelling() << " " << quote(rewritePath(Arg->getValue()))
          << "\n";
       break;
     default:
       OS << toString(Arg) << "\n";

ELF/Options.td

 include "llvm/Option/OptParser.td"
 
 // For options whose names are multiple letters, either one dash or
 // two can precede the option name except those that start with 'o'.
 class F<string name>: Flag<["--", "-"], name>;
 class J<string name>: Joined<["--", "-"], name>;
 class S<string name>: Separate<["--", "-"], name>;
 class JS<string name>: JoinedOrSeparate<["--", "-"], name>;
 
+multiclass Eq<string name> {
+  def "": Separate<["--", "-"], name>;
+  def _eq: Joined<["--", "-"], name # "=">, Alias<!cast<Separate>(NAME)>;
+}
+
 def auxiliary: S<"auxiliary">, HelpText<"Set DT_AUXILIARY field to the specified name">;
 
 def Bsymbolic: F<"Bsymbolic">, HelpText<"Bind defined symbols locally">;
 
 def Bsymbolic_functions: F<"Bsymbolic-functions">,
   HelpText<"Bind defined function symbols locally">;
 
 def Bdynamic: F<"Bdynamic">, HelpText<"Link against shared libraries">;
 
 def Bstatic: F<"Bstatic">, HelpText<"Do not link against shared libraries">;
 
 def build_id: F<"build-id">, HelpText<"Generate build ID note">;
 
 def build_id_eq: J<"build-id=">, HelpText<"Generate build ID note">;
 
-def compress_debug_sections : J<"compress-debug-sections=">,
+defm compress_debug_sections : Eq<"compress-debug-sections">,
   HelpText<"Compress DWARF debug sections">;
 
-def defsym: J<"defsym=">, HelpText<"Define a symbol alias">;
+defm defsym: Eq<"defsym">, HelpText<"Define a symbol alias">;
 
-def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
-  HelpText<"Add a directory to the library search path">;
+defm library_path: Eq<"library-path">,
+  HelpText<"Add a directory to the library search path">, MetaVarName<"<dir>">;
 
 def O: Joined<["-"], "O">, HelpText<"Optimize output file size">;
 
-def Tbss: S<"Tbss">, HelpText<"Same as --section-start with .bss as the sectionname">;
+defm Tbss: Eq<"Tbss">,
+  HelpText<"Same as --section-start with .bss as the sectionname">;
 
-def Tdata: S<"Tdata">, HelpText<"Same as --section-start with .data as the sectionname">;
+defm Tdata: Eq<"Tdata">,
+  HelpText<"Same as --section-start with .data as the sectionname">;
 
-def Ttext: S<"Ttext">, HelpText<"Same as --section-start with .text as the sectionname">;
+defm Ttext: Eq<"Ttext">,
+  HelpText<"Same as --section-start with .text as the sectionname">;
 
 def allow_multiple_definition: F<"allow-multiple-definition">,
   HelpText<"Allow multiple definitions">;
 
 def as_needed: F<"as-needed">,
   HelpText<"Only set DT_NEEDED for shared libraries if used">;
 
 // -chroot doesn't have a help text because it is an internal option.
def discard_locals: F<"discard-locals">,
   HelpText<"Delete temporary local symbols">;
 
 def discard_none: F<"discard-none">,
   HelpText<"Keep all symbols in the symbol table">;
 
 def dynamic_linker: S<"dynamic-linker">,
   HelpText<"Which dynamic linker to use">;
 
-def dynamic_list: S<"dynamic-list">,
+defm dynamic_list: Eq<"dynamic-list">,
   HelpText<"Read a list of dynamic symbols">;
 
 def eh_frame_hdr: F<"eh-frame-hdr">,
   HelpText<"Request creation of .eh_frame_hdr section and PT_GNU_EH_FRAME segment header">;
 
 def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
 
 def enable_new_dtags: F<"enable-new-dtags">,
   HelpText<"Enable new dynamic tags">;
 
 def end_lib: F<"end-lib">,
   HelpText<"End a grouping of objects that should be treated as if they were together in an archive">;
 
-def entry: S<"entry">, MetaVarName<"<entry>">,
-  HelpText<"Name of entry point symbol">;
+defm entry: Eq<"entry">, HelpText<"Name of entry point symbol">,
+  MetaVarName<"<entry>">;
 
-def error_limit: S<"error-limit">,
+defm error_limit: Eq<"error-limit">,
   HelpText<"Maximum number of errors to emit before stopping (0 = no limit)">;
 
 def error_unresolved_symbols: F<"error-unresolved-symbols">,
   HelpText<"Report unresolved symbols as errors">;
 
-def exclude_libs: S<"exclude-libs">,
+defm exclude_libs: Eq<"exclude-libs">,
   HelpText<"Exclude static libraries from automatic export">;
 
 def export_dynamic: F<"export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
-def export_dynamic_symbol: S<"export-dynamic-symbol">,
+defm export_dynamic_symbol: Eq<"export-dynamic-symbol">,
   HelpText<"Put a symbol in the dynamic symbol table">;
 
 def fatal_warnings: F<"fatal-warnings">,
   HelpText<"Treat warnings as errors">;
 
-def filter: J<"filter=">, HelpText<"Set DT_FILTER field to the specified name">;
+defm filter: Eq<"filter">,
+  HelpText<"Set DT_FILTER field to the specified name">;
 
-def fini: S<"fini">, MetaVarName<"<symbol>">,
-  HelpText<"Specify a finalizer function">;
+defm fini: Eq<"fini">,
+  HelpText<"Specify a finalizer function">, MetaVarName<"<symbol>">;
 
 def full_shutdown : F<"full-shutdown">,
   HelpText<"Perform a full shutdown instead of calling _exit">;
 
-def format: J<"format=">, MetaVarName<"<input-format>">,
-  HelpText<"Change the input format of the inputs following this option">;
+defm format: Eq<"format">,
+  HelpText<"Change the input format of the inputs following this option">,
+  MetaVarName<"<input-format>">;
 
 def gc_sections: F<"gc-sections">,
   HelpText<"Enable garbage collection of unused sections">;
 
 def gdb_index: F<"gdb-index">,
   HelpText<"Generate .gdb_index section">;
 
-def hash_style: S<"hash-style">,
+defm hash_style: Eq<"hash-style">,
   HelpText<"Specify hash style (sysv, gnu or both)">;
 
 def help: F<"help">, HelpText<"Print option help">;
 
 def icf: F<"icf=all">, HelpText<"Enable identical code folding">;
 
-def image_base : J<"image-base=">, HelpText<"Set the base address">;
+defm image_base : Eq<"image-base">, HelpText<"Set the base address">;
 
-def init: S<"init">, MetaVarName<"<symbol>">,
-  HelpText<"Specify an initializer function">;
+defm init: Eq<"init">, HelpText<"Specify an initializer function">,
+  MetaVarName<"<symbol>">;
 
-def l: JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
-  HelpText<"Root name of library to use">;
+defm library: Eq<"library">, HelpText<"Root name of library to use">,
+  MetaVarName<"<libName>">;
 
 def lto_O: J<"lto-O">, MetaVarName<"<opt-level>">,
   HelpText<"Optimization level for LTO">;
 
 def m: JoinedOrSeparate<["-"], "m">, HelpText<"Set target emulation">;
 
-def Map: JS<"Map">, HelpText<"Print a link map to the specified file">;
+defm Map: Eq<"Map">, HelpText<"Print a link map to the specified file">;
 
 def nostdlib: F<"nostdlib">,
   HelpText<"Only search directories specified on the command line">;
 
 def no_as_needed: F<"no-as-needed">,
   HelpText<"Always DT_NEEDED for shared libraries">;
 
 def no_color_diagnostics: F<"no-color-diagnostics">,

 def no_whole_archive: F<"no-whole-archive">,
   HelpText<"Restores the default behavior of loading archive members">;
 
 def noinhibit_exec: F<"noinhibit-exec">,
   HelpText<"Retain the executable output file whenever it is still usable">;
 
 def nopie: F<"nopie">, HelpText<"Do not create a position independent executable">;
 
-def no_rosegment: F<"no-rosegment">, HelpText<"Do not put read-only non-executable sections in their own segment">;
+def no_rosegment: F<"no-rosegment">,
+  HelpText<"Do not put read-only non-executable sections in their own segment">;
 
 def no_undefined: F<"no-undefined">,
   HelpText<"Report unresolved symbols even if the linker is creating a shared library">;
 
 def no_undefined_version: F<"no-undefined-version">,
   HelpText<"Report version scripts that refer undefined symbols">;
 
 def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
   HelpText<"Path to file to write output">;
 
 def oformat: Separate<["--"], "oformat">, MetaVarName<"<format>">,
   HelpText<"Specify the binary format for the output object file">;
 
 def omagic: Flag<["--"], "omagic">, MetaVarName<"<magic>">,
   HelpText<"Set the text and data sections to be readable and writable">;
 
 def pie: F<"pie">, HelpText<"Create a position independent executable">;
 
 def print_gc_sections: F<"print-gc-sections">,
   HelpText<"List removed unused sections">;
 
 def print_map: F<"print-map">,
   HelpText<"Print a link map to the standard output">;
 
-def reproduce: S<"reproduce">,
+defm reproduce: Eq<"reproduce">,
   HelpText<"Dump linker invocation and input files for debugging">;
 
-def rpath: S<"rpath">, HelpText<"Add a DT_RUNPATH to the output">;
+defm rpath: Eq<"rpath">, HelpText<"Add a DT_RUNPATH to the output">;
 
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
-def retain_symbols_file: J<"retain-symbols-file=">, MetaVarName<"<file>">,
-  HelpText<"Retain only the symbols listed in the file">;
+defm retain_symbols_file: Eq<"retain-symbols-file">,
+  HelpText<"Retain only the symbols listed in the file">,
+  MetaVarName<"<file>">;
 
-def script: S<"script">, HelpText<"Read linker script">;
+defm script: Eq<"script">, HelpText<"Read linker script">;
 
 def section_start: S<"section-start">, MetaVarName<"<address>">,
   HelpText<"Set address of section">;
 
 def shared: F<"shared">, HelpText<"Build a shared object">;
 
-def soname: J<"soname=">, HelpText<"Set DT_SONAME">;
+defm soname: Eq<"soname">, HelpText<"Set DT_SONAME">;
 
-def sort_section: S<"sort-section">, HelpText<"Specifies sections sorting rule when linkerscript is used">;
+defm sort_section: Eq<"sort-section">,
+  HelpText<"Specifies sections sorting rule when linkerscript is used">;
 
 def start_lib: F<"start-lib">,
   HelpText<"Start a grouping of objects that should be treated as if they were together in an archive">;
 
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
 def symbol_ordering_file: S<"symbol-ordering-file">,
   HelpText<"Layout sections in the order specified by symbol file">;
 
-def sysroot: J<"sysroot=">, HelpText<"Set the system root">;
+defm sysroot: Eq<"sysroot">, HelpText<"Set the system root">;
 
 def target1_rel: F<"target1-rel">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_REL32">;
 
 def target1_abs: F<"target1-abs">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_ABS32">;
 
-def target2: J<"target2=">, MetaVarName<"<type>">, HelpText<"Interpret R_ARM_TARGET2 as <type>, where <type> is one of rel, abs, or got-rel">;
+defm target2: Eq<"target2">,
+  HelpText<"Interpret R_ARM_TARGET2 as <type>, where <type> is one of rel, abs, or got-rel">,
+  MetaVarName<"<type>">;
 
 def threads: F<"threads">, HelpText<"Run the linker multi-threaded">;
 
 def trace: F<"trace">, HelpText<"Print the names of the input files">;
 
-def trace_symbol : S<"trace-symbol">, HelpText<"Trace references to symbols">;
+defm trace_symbol : Eq<"trace-symbol">, HelpText<"Trace references to symbols">;
 
-def undefined: S<"undefined">,
+defm undefined: Eq<"undefined">,
   HelpText<"Force undefined symbol during linking">;
 
-def unresolved_symbols: J<"unresolved-symbols=">,
+defm unresolved_symbols: Eq<"unresolved-symbols">,
   HelpText<"Determine how to handle unresolved symbols">;
 
-def rsp_quoting: J<"rsp-quoting=">,
+defm rsp_quoting: Eq<"rsp-quoting">,
   HelpText<"Quoting style for response files. Values supported: windows|posix">;
 
 def v: Flag<["-"], "v">, HelpText<"Display the version number">;
 
 def verbose: F<"verbose">, HelpText<"Verbose mode">;
 
 def version: F<"version">, HelpText<"Display the version number and exit">;
 
-def version_script: S<"version-script">,
-  HelpText<"Read a version script">;
+defm version_script: Eq<"version-script">, HelpText<"Read a version script">;
 
 def warn_common: F<"warn-common">,
   HelpText<"Warn about duplicate common symbols">;
 
 def warn_unresolved_symbols: F<"warn-unresolved-symbols">,
   HelpText<"Report unresolved symbols as warnings">;
 
 def whole_archive: F<"whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
-def wrap: S<"wrap">, MetaVarName<"<symbol>">,
-  HelpText<"Use wrapper functions for symbol">;
+defm wrap: Eq<"wrap">, HelpText<"Use wrapper functions for symbol">,
+  MetaVarName<"<symbol>">;
 
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
 // Aliases
 def alias_auxiliary: Separate<["-"], "f">, Alias<auxiliary>;
 def alias_Bdynamic_call_shared: F<"call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: F<"dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: F<"dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: F<"non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: F<"static">, Alias<Bstatic>;
-def alias_L__library_path: J<"library-path=">, Alias<L>;
 def alias_define_common_d: Flag<["-"], "d">, Alias<define_common>;
 def alias_define_common_dc: F<"dc">, Alias<define_common>;
 def alias_define_common_dp: F<"dp">, Alias<define_common>;
-def alias_defsym: S<"defsym">, Alias<defsym>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
-def alias_dynamic_list: J<"dynamic-list=">, Alias<dynamic_list>;
 def alias_emit_relocs: Flag<["-"], "q">, Alias<emit_relocs>;
 def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
-def alias_entry_entry: J<"entry=">, Alias<entry>;
-def alias_error_limit: J<"error-limit=">, Alias<error_limit>;
-def alias_exclude_libs: J<"exclude-libs=">, Alias<exclude_libs>;
 def alias_export_dynamic_E: Flag<["-"], "E">, Alias<export_dynamic>;
-def alias_export_dynamic_symbol: J<"export-dynamic-symbol=">,
-  Alias<export_dynamic_symbol>;
 def alias_filter: Separate<["-"], "F">, Alias<filter>;
-def alias_fini_fini: J<"fini=">, Alias<fini>;
 def alias_format_b: S<"b">, Alias<format>;
-def alias_hash_style_hash_style: J<"hash-style=">, Alias<hash_style>;
-def alias_init_init: J<"init=">, Alias<init>;
-def alias_l__library: J<"library=">, Alias<l>;
-def alias_Map_eq: J<"Map=">, Alias<Map>;
+def alias_library: JoinedOrSeparate<["-"], "l">, Alias<library>;
+def alias_library_path: JoinedOrSeparate<["-"], "L">, Alias<library_path>;
 def alias_omagic: Flag<["-"], "N">, Alias<omagic>;
 def alias_o_output: Joined<["--"], "output=">, Alias<o>;
 def alias_o_output2 : Separate<["--"], "output">, Alias<o>;
 def alias_pie_pic_executable: F<"pic-executable">, Alias<pie>;
 def alias_print_map_M: Flag<["-"], "M">, Alias<print_map>;
 def alias_relocatable_r: Flag<["-"], "r">, Alias<relocatable>;
-def alias_reproduce_eq: J<"reproduce=">, Alias<reproduce>;
-def alias_retain_symbols_file: S<"retain-symbols-file">, Alias<retain_symbols_file>;
 def alias_rpath_R: JoinedOrSeparate<["-"], "R">, Alias<rpath>;
-def alias_rpath_rpath: J<"rpath=">, Alias<rpath>;
 def alias_script_T: JoinedOrSeparate<["-"], "T">, Alias<script>;
 def alias_shared_Bshareable: F<"Bshareable">, Alias<shared>;
 def alias_soname_h: JoinedOrSeparate<["-"], "h">, Alias<soname>;
-def alias_soname_soname: S<"soname">, Alias<soname>;
-def alias_sort_section: J<"sort-section=">, Alias<sort_section>;
-def alias_script: J<"script=">, Alias<script>;
 def alias_strip_all: Flag<["-"], "s">, Alias<strip_all>;
 def alias_strip_debug_S: Flag<["-"], "S">, Alias<strip_debug>;
-def alias_Tbss: J<"Tbss=">, Alias<Tbss>;
-def alias_Tdata: J<"Tdata=">, Alias<Tdata>;
 def alias_trace: Flag<["-"], "t">, Alias<trace>;
-def trace_trace_symbol_eq : J<"trace-symbol=">, Alias<trace_symbol>;
 def alias_trace_symbol_y : JoinedOrSeparate<["-"], "y">, Alias<trace_symbol>;
-def alias_Ttext: J<"Ttext=">, Alias<Ttext>;
 def alias_Ttext_segment: S<"Ttext-segment">, Alias<Ttext>;
 def alias_Ttext_segment_eq: J<"Ttext-segment=">, Alias<Ttext>;
-def alias_undefined_eq: J<"undefined=">, Alias<undefined>;
 def alias_undefined_u: JoinedOrSeparate<["-"], "u">, Alias<undefined>;
-def alias_version_script_eq: J<"version-script=">, Alias<version_script>;
 def alias_version_V: Flag<["-"], "V">, Alias<version>;
-def alias_wrap_wrap: J<"wrap=">, Alias<wrap>;
 
 // Our symbol resolution algorithm handles symbols in archive files differently
 // than traditional linkers, so we don't need --start-group and --end-group.
 // These options are recongized for compatibility but ignored.
 def end_group: F<"end-group">;
 def end_group_paren: Flag<["-"], ")">;
 def start_group: F<"start-group">;
 def start_group_paren: Flag<["-"], "(">;

test/ELF/compress-debug-sections.s

 # ZLIBFLAGS-NEXT:      SHF_COMPRESSED
 
 # RUN: llvm-dwarfdump %t1 -debug-dump=str | \
 # RUN:   FileCheck %s --check-prefix=DEBUGSTR
 # DEBUGSTR:     .debug_str contents:
 # DEBUGSTR-NEXT:  AAAAAAAAAAAAAAAAAAAAAAAAAAA
 # DEBUGSTR-NEXT:  BBBBBBBBBBBBBBBBBBBBBBBBBBB
 
+## Test alias.
+# RUN: ld.lld %t.o -o %t2 --compress-debug-sections zlib
+# RUN: llvm-objdump -s %t2 | FileCheck %s --check-prefix=ZLIBCONTENT
+# RUN: llvm-readobj -s %t2 | FileCheck %s --check-prefix=ZLIBFLAGS
+
 # RUN: not ld.lld %t.o -o %t1 --compress-debug-sections=zlib-gabi 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR %s
 # ERR: unknown --compress-debug-sections value: zlib-gabi
 
 .section .debug_str,"MS",@progbits,1
 .Linfo_string0:
   .asciz "AAAAAAAAAAAAAAAAAAAAAAAAAAA"
 .Linfo_string1:
   .asciz "BBBBBBBBBBBBBBBBBBBBBBBBBBB"

test/ELF/driver.test

 ## Attempt to use -shared and -pie together
 # RUN: not ld.lld -shared -pie %t -o %tfail 2>&1 | FileCheck -check-prefix=ERR6 %s
 # ERR6: -shared and -pie may not be used together
 
 ## "--output=foo" is equivalent to "-o foo".
 # RUN: not ld.lld %t --output=/no/such/file 2>&1 | FileCheck -check-prefix=ERR7 %s
 # ERR7: cannot open output file /no/such/file
 
-## "-output=foo" is equivalent to "-o utput=foo".
-# RUN: not ld.lld %t -output=/no/such/file 2>&1 | FileCheck -check-prefix=ERR8 %s
-# ERR8: cannot open output file utput=/no/such/file
-
 .globl _start
 _start:
   nop

test/ELF/duplicated-synthetic-sym.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: cd %S
 // RUN: not ld.lld %t.o --format=binary duplicated-synthetic-sym.s -o %t.elf 2>&1 | FileCheck %s
+// RUN: not ld.lld %t.o --format binary duplicated-synthetic-sym.s -o %t.elf 2>&1 | FileCheck %s
 
 // CHECK: duplicate symbol: _binary_duplicated_synthetic_sym_s_start
 // CHECK: defined at (internal):(.data+0x0)
 
     .globl  _binary_duplicated_synthetic_sym_s_start
 _binary_duplicated_synthetic_sym_s_start:
     .long   0

test/ELF/filter.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -F foo.so -F boo.so -o %t1
 # RUN: llvm-readobj --dynamic-table %t1 | FileCheck %s
 
-# Test alias.
+# Test alias #1.
 # RUN: ld.lld %t.o -shared --filter=foo.so --filter=boo.so -o %t2
 # RUN: llvm-readobj --dynamic-table %t2 | FileCheck %s
 
+# Test alias #2.
+# RUN: ld.lld %t.o -shared --filter foo.so --filter boo.so -o %t3
+# RUN: llvm-readobj --dynamic-table %t3 | FileCheck %s
+
 # CHECK:      DynamicSection [
 # CHECK-NEXT: Tag                Type          Name/Value
 # CHECK-NEXT: 0x000000007FFFFFFF FILTER        Filter library: [foo.so]
 # CHECK-NEXT: 0x000000007FFFFFFF FILTER        Filter library: [boo.so]
 
 # RUN: not ld.lld %t.o -F x -o %t 2>&1 | FileCheck -check-prefix=ERR %s
 # ERR: -F may not be used without -shared

test/ELF/image-base.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld -image-base=0x1000000 %t -o %t1
 # RUN: llvm-readobj -program-headers %t1 | FileCheck %s
 
 # RUN: ld.lld -image-base=0x1000 -z max-page-size=0x2000 %t -o %t1 2>&1 | FileCheck --check-prefix=WARN %s
 # WARN: warning: -image-base: address isn't multiple of page size: 0x1000
 
+# Check alias.
+# RUN: ld.lld -image-base 0x1000000 %t -o %t1
+# RUN: llvm-readobj -program-headers %t1 | FileCheck %s
 
 .global _start
 _start:
   nop
 
 # CHECK:      ProgramHeaders [
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_PHDR (0x6)

test/ELF/libsearch.s

 // RUN: ld.lld -o %t3 %t.o -L%t.dir2 -L%t.dir -lls
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=STATIC %s
 
 // -L can be placed after -l
 // RUN: ld.lld -o %t3 %t.o -lls -L%t.dir
 
 // Check long forms as well
 // RUN: ld.lld -o %t3 %t.o --library-path=%t.dir --library=ls
+// RUN: ld.lld -o %t3 %t.o --library-path %t.dir --library ls
 
 // Should not search for dynamic libraries if -Bstatic is specified
 // RUN: ld.lld -o %t3 %t.o -L%t.dir -Bstatic -lls
 // RUN: llvm-readobj --symbols %t3 | FileCheck --check-prefix=STATIC %s
 // RUN: not ld.lld -o %t3 %t.o -L%t.dir -Bstatic -lls2 2>&1 \
 // RUN:   | FileCheck --check-prefix=NOLIB2 %s
 // NOLIB2: unable to find library -lls2
 

test/ELF/sysroot.s

 // Case 2: absolute path
 // RUN: cd %p && ld.lld -o %t/r %t/m.o -L=%t/lib -l:libls.a
 
 // RUN: cd %p
 
 // Should substitute SysRoot if specified
 // RUN: ld.lld -o %t/r %t/m.o --sysroot=%t -L=lib -l:libls.a
 // RUN: ld.lld -o %t/r %t/m.o --sysroot=%t -L=/lib -l:libls.a
+// Check alias.
+// RUN: ld.lld -o %t/r %t/m.o --sysroot %t -L=lib -l:libls.a
 
 // Should not substitute SysRoot if the directory name does not start with '='
 // RUN: not ld.lld -o %t/r %r/m.o --sysroot=%t -Llib -l:libls.a
 // RUN: not ld.lld -o %t/r %r/m.o --sysroot=%t -L/lib -l:libls.a
 
 .globl _start,_bar
 _start:
   call _bar

test/ELF/unresolved-symbols.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/unresolved-symbols.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -o %t.so
 
 ## Check that %t2.o contains undefined symbol undef.
 # RUN: not ld.lld %t1.o %t2.o -o %t 2>&1 | \
 # RUN:   FileCheck -check-prefix=UNDCHECK %s
 # UNDCHECK: error: undefined symbol: undef
 # UNDCHECK: >>> referenced by {{.*}}2.o:(.text+0x1)
 
 ## Error out if unknown option value was set.
 # RUN: not ld.lld %t1.o %t2.o -o %t --unresolved-symbols=xxx 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERR1 %s
 # ERR1: unknown --unresolved-symbols value: xxx
+## Check alias.
+# RUN: not ld.lld %t1.o %t2.o -o %t --unresolved-symbols xxx 2>&1 | \
+# RUN:   FileCheck -check-prefix=ERR1 %s
 
 ## Ignore all should not produce error for symbols from object except
 ## case when --no-undefined specified.
 # RUN: ld.lld %t2.o -o %t1_1 --unresolved-symbols=ignore-all
 # RUN: llvm-readobj %t1_1 > /dev/null 2>&1
 # RUN: not ld.lld %t2.o -o %t1_2 --unresolved-symbols=ignore-all --no-undefined 2>&1 | \
 # RUN:   FileCheck -check-prefix=ERRUND %s
 # ERRUND: error: undefined symbol: undef