[ms] [llvm-ml] Introduce command-line compatibility for ml.exe and ml64.exe

[epastor]

Summary

Switch to OptParser for command-line handling

[thakis]

Nice!

Do tests still run after the test file renaming to .asm? llvm/test/lit.cfg.py has config.suffixes = ['.ll', '.c', '.test', '.txt', '.s', '.mir', '.yaml'] which includes .test but not .asm. I would expect that you need to edit llvm/test/tools/llvm-ml/lit.local.cfg to have config.suffixes.add('.asm,') for the tests to keep running.

llvm/tools/llvm-ml/Opts.td

7

Do we need the non-ml-compat options for anything? If so, why support '/' prefixes for this? Why not the more usual '--' here? (see also lld/ELF/Options.td for some color on this.)

What's with the '.' syntax?

[thakis]

(marking this as "request changes" to get it off my dashboard until the questions above are answered. doesn't necessarily need changes, more "request replies" :) )

[epastor]

Fix prefixes for LLVM-specific options, and add the .asm tests to the lit config

[epastor]

Rebase on HEAD

[epastor]

After rebasing on parent, fix new test files for invocation style

[epastor]

Fix lit.local.cfg (add vs. append)

[epastor]

In D90058#2371375, @thakis wrote:

Nice!

Do tests still run after the test file renaming to .asm? llvm/test/lit.cfg.py has config.suffixes = ['.ll', '.c', '.test', '.txt', '.s', '.mir', '.yaml'] which includes .test but not .asm. I would expect that you need to edit llvm/test/tools/llvm-ml/lit.local.cfg to have config.suffixes.add('.asm,') for the tests to keep running.

... they do now. Thanks for catching this! (They still pass.)

llvm/tools/llvm-ml/Opts.td

7

We do need it for now - it lets users select things like output filetype. (We might be able to replace that with the listing options once those are implemented, and generally I plan on working to converge towards ML.EXE's interface.) I've switched to supporting only "-" and "--" here; I'm keeping "-" available for partial compatibility with llvm-mc.

(And the "." was a typo.)

[epastor]

Rebase on parent

[epastor]

Accept /c as a flag without warning; it's our current default behavior anyway

[epastor]

Disable IgnoreCase; ml.exe and ml64.exe use case-sensitive flags

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Update for new test files

[thakis]

(Just to be sure: This is ready to go and not waiting on me, right?)

[epastor]

In D90058#2426388, @thakis wrote:

(Just to be sure: This is ready to go and not waiting on me, right?)

Yep - working on getting it in, at a not-quite-top priority at the moment. It was blocked the other day behind an intermediate change.

llvm/test/tools/llvm-ml/alias.asm

-; RUN: llvm-ml -filetype=obj %s | llvm-readobj --syms - | FileCheck %s
+; RUN: llvm-ml %s /Fo - | llvm-readobj --syms - | FileCheck %s
 
 .code
 
 proc1 PROC
   ret
 proc1 ENDP
 
 proc2 PROC

llvm/test/tools/llvm-ml/alias_errors.asm

-; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s
+; RUN: not llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s
 
 .code
 
 foo PROC
   ret
 foo ENDP
 
 bar PROC

 t3:
 alias <foo = bar>
 alias <foo = bar
 
 ; CHECK: error: unexpected token in alias directive
 ; CHECK: error: expected <aliasName>
 
 END
 No newline at end of file

llvm/test/tools/llvm-ml/basic.test

-# RUN: not llvm-ml %t.blah -o /dev/null 2>&1 | FileCheck --check-prefix=ENOENT %s
+# RUN: not llvm-ml %t.blah.asm /Fo /dev/null 2>&1 | FileCheck --check-prefix=ENOENT %s
 
-# ENOENT: {{.*}}.blah: {{[Nn]}}o such file or directory
+# ENOENT: {{.*}}.blah.asm: {{[Nn]}}o such file or directory

llvm/test/tools/llvm-ml/basic_data.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 BYTE 2, 4, 6, 8
 ; CHECK: .data
 ; CHECK-NEXT: .byte 2
 ; CHECK-NEXT: .byte 4
 ; CHECK-NEXT: .byte 6
 ; CHECK-NEXT: .byte 8

llvm/test/tools/llvm-ml/builtin_types.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 t1_long BYTE 1
 t1_short DB 1
 t1_signed SBYTE -1
 
 ; CHECK-LABEL: t1_long:

llvm/test/tools/llvm-ml/dot_operator.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 FOO STRUCT
   a BYTE ?
   b BYTE ?
   c BYTE ?
   d BYTE ?

llvm/test/tools/llvm-ml/expansion.asm

-; RUN: llvm-ml -filetype=asm %s 2>&1 | FileCheck %s
+; RUN: llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s
 
 .code
 
 num EQU 276
 var TEXTEQU %num
 
 ECHO t1
 ECHO var

llvm/test/tools/llvm-ml/feat00.asm

-; RUN: llvm-ml -m32 -filetype=obj %s | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-NOSAFESEH
-; RUN: llvm-ml -m64 -filetype=obj %s | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-NOSAFESEH
+; RUN: llvm-ml -m32 %s /Fo - | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-NOSAFESEH
+; RUN: llvm-ml -m64 %s /Fo - | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-NOSAFESEH
 
-; RUN: llvm-ml -m32 -safeseh -filetype=obj %s | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-SAFESEH
-; RUN: llvm-ml -m64 -safeseh -filetype=obj %s -o %t.obj 2>&1 | FileCheck %s --check-prefix=CHECK-SAFESEH64
+; RUN: llvm-ml -m32 -safeseh %s /Fo - | llvm-readobj --syms - | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-SAFESEH
+; RUN: llvm-ml -m64 -safeseh %s /Fo %t.obj 2>&1 | FileCheck %s --check-prefix=CHECK-SAFESEH64
 ; RUN: llvm-readobj --syms %t.obj | FileCheck %s --check-prefix=CHECK-OBJ --check-prefix=CHECK-OBJ-NOSAFESEH
 
 ; CHECK-SAFESEH64: warning: /safeseh applies only to 32-bit X86 platforms; ignoring.
 
 .code
 noop:
   ret
 end

llvm/test/tools/llvm-ml/feat00_override.asm

-; RUN: llvm-ml -m32 -filetype=obj %s | llvm-readobj --syms - | FileCheck %s
-; RUN: llvm-ml -m64 -filetype=obj %s | llvm-readobj --syms - | FileCheck %s
-; RUN: llvm-ml -m32 -safeseh -filetype=obj %s | llvm-readobj --syms - | FileCheck %s
+; RUN: llvm-ml -m32 %s /Fo - | llvm-readobj --syms - | FileCheck %s
+; RUN: llvm-ml -m64 %s /Fo - | llvm-readobj --syms - | FileCheck %s
+; RUN: llvm-ml -m32 -safeseh %s /Fo - | llvm-readobj --syms - | FileCheck %s
 
 .code
 
 @feat.00 = 99
 
 noop:
   ret
 end

llvm/test/tools/llvm-ml/line_continuations.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .code
 
 t1:
 mov eax, \
     ebx
 # CHECK: t1:
 # CHECK-NEXT: mov eax, ebx
 
 t2:
 mov eax, [ebx + \
           1]
 # CHECK: t2:
 # CHECK-NEXT: mov eax, dword ptr [ebx + 1]
 
 END

llvm/test/tools/llvm-ml/lit.local.cfg

 if not ('X86' in config.root.targets):
     # We need support for X86.
     config.unsupported = True
+
+config.suffixes.append('.asm')

llvm/test/tools/llvm-ml/macro.asm

-; RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
+; RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 x1 DWORD ?
 x2 DWORD ?
 xa1 DWORD ?
 
 .code

llvm/test/tools/llvm-ml/macro_function.asm

-; RUN: llvm-ml -filetype=asm %s | FileCheck %s
+; RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .code
 
 identity MACRO arg
   exitm <arg>
 endm
 
 argument_test PROC

llvm/test/tools/llvm-ml/named_operators.asm

-; RUN: llvm-ml -filetype=asm %s | FileCheck %s
+; RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 t1 BYTE NOT 1
 ; CHECK-LABEL: t1:
 ; CHECK-NEXT: .byte -2
 ; CHECK-NOT: .byte
 

llvm/test/tools/llvm-ml/proc.asm

+# RUN: llvm-ml -m32 -filetype=s %s /Fo - | FileCheck %s
+# RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
+
+.code
+
+t1 PROC
+  ret
+t1 ENDP
+
+; CHECK: t1:
+; CHECK: ret
+
+END

llvm/test/tools/llvm-ml/proc.test

-# RUN: llvm-ml -m32 -filetype=asm %s | FileCheck %s
-# RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
-
-.code
-
-t1 PROC
-  ret
-t1 ENDP
-
-; CHECK: t1:
-; CHECK: ret
-
-END

llvm/test/tools/llvm-ml/proc_frame.asm

-# RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
 
 .code
 
 t1 PROC FRAME
   push rbp
   .pushreg rbp
   mov rbp, rsp
   .setframe rbp, 0

llvm/test/tools/llvm-ml/radix.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .code
 
 t1:
 mov eax, 100b
 mov eax, 100y
 
 ; CHECK-LABEL: t1:

llvm/test/tools/llvm-ml/radix_errors.asm

-; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s --implicit-check-not=error:
+; RUN: not llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s --implicit-check-not=error:
 
 .code
 
 t1:
 ; CHECK: :[[# @LINE + 1]]:10: error: invalid decimal number
 mov eax, 120b
 ; CHECK: :[[# @LINE + 1]]:10: error: invalid binary number
 mov eax, 120y

llvm/test/tools/llvm-ml/repeat_directives.asm

-; RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s
+; RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 a BYTE ?
 
 .code
 
 repeat_test PROC

llvm/test/tools/llvm-ml/rip-relative-addressing.asm

+# RUN: llvm-ml -m32 -filetype=s %s /Fo - | FileCheck %s --check-prefix=CHECK-32
+# RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s --check-prefix=CHECK-64
+
+.code
+mov eax, [4]
+; CHECK-32: mov eax, dword ptr [4]
+; CHECK-64: mov eax, dword ptr [rip + 4]
+END
 No newline at end of file

llvm/test/tools/llvm-ml/rip-relative-addressing.test

-# RUN: llvm-ml -m32 -filetype=asm %s | FileCheck %s --check-prefix=CHECK-32
-# RUN: llvm-ml -m64 -filetype=asm %s | FileCheck %s --check-prefix=CHECK-64
-
-.code
-mov eax, [4]
-; CHECK-32: mov eax, dword ptr [4]
-; CHECK-64: mov eax, dword ptr [rip + 4]
-END
 

llvm/test/tools/llvm-ml/run.asm

 # RUN: llvm-ml --help | FileCheck %s
 
 # CHECK: USAGE: llvm-ml

llvm/test/tools/llvm-ml/size_inference.asm

-; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s --dump-input=always
+; RUN: not llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s --dump-input=always
 
 .data
 
 FOO STRUCT
   dword_field DWORD 3
   byte_field BYTE 4 DUP (1)
 FOO ENDS
 

llvm/test/tools/llvm-ml/struct.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -m64 -filetype=s %s /Fo - | FileCheck %s
 
 .data
 BAZ STRUCT
   a BYTE 1
   b BYTE 2
 BAZ ENDS
 
 FOOBAR struct 2

llvm/test/tools/llvm-ml/struct_alignment.asm

-; RUN: llvm-ml -filetype=asm %s | FileCheck %s
+; RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 FOO STRUCT 8
   f FWORD -1
 FOO ENDS
 
 t1 FOO <>

llvm/test/tools/llvm-ml/struct_errors.asm

-# RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s --dump-input=always
+# RUN: not llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s --dump-input=always
 
 .data
 int_test STRUCT
   int_arr DWORD ?, ?
   int_scalar DWORD ?
 int_test ENDS
 
 t1 int_test <<1,2,3>>

llvm/test/tools/llvm-ml/type_operators.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 
 FOO STRUCT 2
   x BYTE ?
   y WORD 5 DUP (?)
 FOO ENDS
 

llvm/test/tools/llvm-ml/variable.asm

-# RUN: llvm-ml -filetype=asm %s | FileCheck %s
+# RUN: llvm-ml -filetype=s %s /Fo - | FileCheck %s
 
 .data
 t1_value equ 1 or 2
 
 t1 BYTE t1_value DUP (0)
 ; CHECK: t1:
 ; CHECK-NEXT: .byte 0
 ; CHECK-NEXT: .byte 0
 ; CHECK-NEXT: .byte 0
 ; CHECK-NOT: .byte 0
 
 END

llvm/tools/llvm-ml/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   AllTargetsAsmParsers
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   MC
   MCParser
+  Option
   Support
   )
 
+set(LLVM_TARGET_DEFINITIONS Opts.td)
+
+tablegen(LLVM Opts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(MLTableGen)
+
 add_llvm_tool(llvm-ml
   llvm-ml.cpp
   Disassembler.cpp
   )

llvm/tools/llvm-ml/Opts.td

+include "llvm/Option/OptParser.td"
+
+// For LLVM-specific options, we prefer a two-dash prefix, but accept one for
+// compatibility with llvm-mc. For clear separation from ML.EXE compatible
+// options, slash is not accepted.
+class LLVMFlag<string name> : Flag<["--", "-"], name>;
+class LLVMJoined<string name> : Joined<["--", "-"], name>;
+class LLVMJoinedOrSeparate<string name> : JoinedOrSeparate<["--", "-"], name>;
+class LLVMSeparate<string name> : Separate<["--", "-"], name>;
+
+def ml_Group : OptionGroup<"<ml options>">,
+               HelpText<"ML.EXE COMPATIBILITY OPTIONS">;
+class MLFlag<string name> : Flag<["/", "-"], name>, Group<ml_Group>;
+class MLJoined<string name> : Joined<["/", "-"], name>, Group<ml_Group>;
+class MLJoinedOrSeparate<string name> : JoinedOrSeparate<["/", "-"], name>,
+                                        Group<ml_Group>;
+class MLSeparate<string name> : Separate<["/", "-"], name>, Group<ml_Group>;
+
+def unsupported_Group : OptionGroup<"unsupported">, Flags<[HelpHidden]>,
+                        HelpText<"UNSUPPORTED ML.EXE COMPATIBILITY OPTIONS">;
+class UnsupportedFlag<string name> : Flag<["/", "-"], name>,
+                                     Group<unsupported_Group>;
+class UnsupportedJoined<string name> : Joined<["/", "-"], name>,
+                                       Group<unsupported_Group>;
+class UnsupportedJoinedOrSeparate<string name> :
+        JoinedOrSeparate<["/", "-"], name>, Group<unsupported_Group>;
+class UnsupportedSeparate<string name> : Separate<["/", "-"], name>,
+                                         Group<unsupported_Group>;
+
+def help : MLFlag<"?">,
+           HelpText<"Display available options">;
+def help_long : MLFlag<"help">, Alias<help>;
+def output_file : MLJoinedOrSeparate<"Fo">, HelpText<"Names the output file">;
+def include_path : MLJoinedOrSeparate<"I">,
+                   HelpText<"Sets path for include files">;
+def safeseh : MLFlag<"safeseh">,
+              HelpText<"Mark resulting object files as either containing no "
+                       "exception handlers or containing exception handlers "
+                       "that are all declared with .SAFESEH. Only available in "
+                       "32-bit.">;
+def assembly_file : MLJoinedOrSeparate<"Ta">,
+                    HelpText<"Assemble source file with name not ending with "
+                             "the .asm extension">;
+
+def bitness : LLVMJoined<"m">, Values<"32,64">,
+              HelpText<"Target platform (x86 or x86-64)">;
+def as_lex : LLVMFlag<"as-lex">,
+             HelpText<"Lex tokens from a .asm file without assembling">;
+def filetype : LLVMJoined<"filetype=">, Values<"obj,s,null">,
+               HelpText<"Emit a file with the given type">;
+def output_att_asm : LLVMFlag<"output-att-asm">,
+                     HelpText<"Use ATT syntax for output assembly">;
+def show_encoding : LLVMFlag<"show-encoding">,
+                    HelpText<"Show instruction encodings in output assembly">;
+def show_inst : LLVMFlag<"show-inst">,
+                HelpText<"Show internal instruction representation in output "
+                         "assembly">;
+def show_inst_operands : LLVMFlag<"show-inst-operands">,
+                         HelpText<"Show instructions operands as parsed">;
+def print_imm_hex : LLVMFlag<"print-imm-hex">,
+                    HelpText<"Prefer hex format for immediate values in output "
+                             "assembly">;
+def preserve_comments : LLVMFlag<"preserve-comments">,
+                        HelpText<"Preserve comments in output assembly">;
+def save_temp_labels : LLVMFlag<"save-temp-labels">,
+                       HelpText<"Don't discard temporary labels">;
+
+def tiny_model_support : UnsupportedFlag<"AT">, HelpText<"">;
+def alternate_linker : UnsupportedJoined<"Bl">, HelpText<"">;
+def assemble_only : UnsupportedFlag<"c">, HelpText<"">;
+def coff_object_file : UnsupportedFlag<"coff">, HelpText<"">;
+def preserve_identifier_case : UnsupportedFlag<"Cp">, HelpText<"">;
+def uppercase_identifiers : UnsupportedFlag<"Cu">, HelpText<"">;
+def preserve_extern_case : UnsupportedFlag<"Cx">, HelpText<"">;
+def define : UnsupportedJoinedOrSeparate<"D">, HelpText<"">;
+def output_preprocessed : UnsupportedFlag<"EP">, HelpText<"">;
+def errorreport : UnsupportedJoined<"ERRORREPORT">, HelpText<"">;
+def stacksize : UnsupportedSeparate<"F">, HelpText<"">;
+def executable_file : UnsupportedSeparate<"Fe">, HelpText<"">;
+def code_listing_file : UnsupportedJoined<"FI">, HelpText<"">;
+def linker_map_file : UnsupportedJoined<"Fm">, HelpText<"">;
+def fp_emulator_fixups : UnsupportedFlag<"FPi">, HelpText<"">;
+def source_browser_file : UnsupportedJoined<"Fr">, HelpText<"">;
+def extended_source_browser_file : UnsupportedJoined<"FR">, HelpText<"">;
+def pascal_conventions : UnsupportedFlag<"Gc">, HelpText<"">;
+def c_conventions : UnsupportedFlag<"Gd">, HelpText<"">;
+def stdcall_conventions : UnsupportedFlag<"GZ">, HelpText<"">;
+def extern_name_limit : UnsupportedSeparate<"H">, HelpText<"">;
+def nologo : UnsupportedFlag<"nologo">, HelpText<"">;
+def omf_object_file : UnsupportedFlag<"omf">, HelpText<"">;
+def full_listing : UnsupportedFlag<"Sa">, HelpText<"">;
+def first_pass_listing : UnsupportedFlag<"Sf">, HelpText<"">;
+def listing_width : UnsupportedSeparate<"SI">, HelpText<"">;
+def listing_without_symbols : UnsupportedFlag<"Sn">, HelpText<"">;
+def listing_page_length : UnsupportedSeparate<"Sp">, HelpText<"">;
+def listing_subtitle : UnsupportedSeparate<"Ss">, HelpText<"">;
+def listing_title : UnsupportedSeparate<"St">, HelpText<"">;
+def listing_false_conditionals : UnsupportedFlag<"Sx">, HelpText<"">;
+def extra_warnings : UnsupportedFlag<"w">, HelpText<"">;
+def warning_level : UnsupportedJoined<"W">, HelpText<"">;
+def error_on_warning : UnsupportedFlag<"WX">, HelpText<"">;
+def ignore_include_envvar : UnsupportedFlag<"X">, HelpText<"">;
+def line_number_info : UnsupportedFlag<"Zd">, HelpText<"">;
+def export_all_symbols : UnsupportedFlag<"Zf">, HelpText<"">;
+def codeview_info : UnsupportedFlag<"Zi">, HelpText<"">;
+def enable_m510_option : UnsupportedFlag<"Zm">, HelpText<"">;
+def structure_packing : UnsupportedJoined<"Zp">, HelpText<"">;
+def parse_only : UnsupportedFlag<"Zs">, HelpText<"">;

llvm/tools/llvm-ml/llvm-ml.cpp

 //===-- llvm-ml.cpp - masm-compatible assembler -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // A simple driver around MasmParser; based on llvm-mc.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Disassembler.h"
-
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCParser/AsmLexer.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
-#include "llvm/Support/CommandLine.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/Option.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace llvm;
+using namespace llvm::opt;
 
-static mc::RegisterMCTargetOptionsFlags MOF;
-
-static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
-
-static cl::opt<std::string>
-OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"),
-               cl::init("-"));
-
-static cl::opt<bool>
-ShowEncoding("show-encoding", cl::desc("Show instruction encodings"));
-
-static cl::opt<bool>
-ShowInst("show-inst", cl::desc("Show internal instruction representation"));
-
-static cl::opt<bool>
-ShowInstOperands("show-inst-operands",
-                 cl::desc("Show instructions operands as parsed"));
+namespace {
 
-static cl::opt<bool>
-OutputATTAsm("output-att-asm", cl::desc("Use ATT syntax for output printing"));
-
-static cl::opt<bool>
-PrintImmHex("print-imm-hex", cl::init(false),
-            cl::desc("Prefer hex format for immediate values"));
-
-static cl::opt<bool>
-PreserveComments("preserve-comments",
-                 cl::desc("Preserve Comments in outputted assembly"));
-
-enum OutputFileType {
-  OFT_Null,
-  OFT_AssemblyFile,
-  OFT_ObjectFile
+enum ID {
+  OPT_INVALID = 0, // This is not an option ID.
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  OPT_##ID,
+#include "Opts.inc"
+#undef OPTION
 };
-static cl::opt<OutputFileType>
-FileType("filetype", cl::init(OFT_ObjectFile),
-  cl::desc("Choose an output file type:"),
-  cl::values(
-       clEnumValN(OFT_AssemblyFile, "asm",
-                  "Emit an assembly ('.s') file"),
-       clEnumValN(OFT_Null, "null",
-                  "Don't emit anything (for timing purposes)"),
-       clEnumValN(OFT_ObjectFile, "obj",
-                  "Emit a native object ('.o') file")));
-
-static cl::list<std::string>
-IncludeDirs("I", cl::desc("Directory of include files"),
-            cl::value_desc("directory"), cl::Prefix);
-
-enum BitnessType {
-  m32,
-  m64,
-};
-cl::opt<BitnessType> Bitness(cl::desc("Choose bitness:"), cl::init(m64),
-                             cl::values(clEnumVal(m32, "32-bit"),
-                                        clEnumVal(m64, "64-bit (default)")));
-
-static cl::opt<bool> SafeSEH(
-    "safeseh",
-    cl::desc("Mark resulting object files as either containing no "
-             "exception handlers or containing exception handlers that "
-             "are all declared with .SAFESEH. Only available in 32-bit."));
-
-static cl::opt<std::string>
-TripleName("triple", cl::desc("Target triple to assemble for, "
-                              "see -version for available targets"));
-
-static cl::opt<std::string>
-DebugCompilationDir("fdebug-compilation-dir",
-                    cl::desc("Specifies the debug info's compilation dir"));
-
-static cl::list<std::string>
-DebugPrefixMap("fdebug-prefix-map",
-               cl::desc("Map file source paths in debug info"),
-               cl::value_desc("= separated key-value pairs"));
-
-static cl::opt<std::string>
-MainFileName("main-file-name",
-             cl::desc("Specifies the name we should consider the input file"));
-
-static cl::opt<bool> SaveTempLabels("save-temp-labels",
-                                    cl::desc("Don't discard temporary labels"));
-
-enum ActionType {
-  AC_AsLex,
-  AC_Assemble,
-  AC_Disassemble,
-  AC_MDisassemble,
+
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Opts.inc"
+#undef PREFIX
+
+static const opt::OptTable::Info InfoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR, VALUES)                                      \
+  {                                                                            \
+      PREFIX,      NAME,      HELPTEXT,                                        \
+      METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
+      PARAM,       FLAGS,     OPT_##GROUP,                                     \
+      OPT_##ALIAS, ALIASARGS, VALUES},
+#include "Opts.inc"
+#undef OPTION
 };
 
-static cl::opt<ActionType>
-Action(cl::desc("Action to perform:"),
-       cl::init(AC_Assemble),
-       cl::values(clEnumValN(AC_AsLex, "as-lex",
-                             "Lex tokens from a .asm file"),
-                  clEnumValN(AC_Assemble, "assemble",
-                             "Assemble a .asm file (default)"),
-                  clEnumValN(AC_Disassemble, "disassemble",
-                             "Disassemble strings of hex bytes"),
-                  clEnumValN(AC_MDisassemble, "mdis",
-                             "Marked up disassembly of strings of hex bytes")));
+class MLOptTable : public opt::OptTable {
+public:
+  MLOptTable() : OptTable(InfoTable, true) {}
+};
+} // namespace
 
-static const Target *GetTarget(const char *ProgName) {
+static Triple GetTriple(StringRef ProgName, opt::InputArgList &Args) {
   // Figure out the target triple.
-  if (TripleName.empty()) {
-    if (Bitness == m32)
-      TripleName = "i386-pc-windows";
-    else if (Bitness == m64)
-      TripleName = "x86_64-pc-windows";
-  }
-  Triple TheTriple(Triple::normalize(TripleName));
-
-  // Get the target specific parser.
-  std::string Error;
-  const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error);
-  if (!TheTarget) {
-    WithColor::error(errs(), ProgName) << Error;
-    return nullptr;
-  }
-
-  // Update the triple name and return the found target.
-  TripleName = TheTriple.getTriple();
-  return TheTarget;
+  StringRef DefaultBitness = "32";
+  SmallString<255> Program = ProgName;
+  sys::path::replace_extension(Program, "");
+  if (Program.endswith("ml64"))
+    DefaultBitness = "64";
+
+  StringRef TripleName =
+      StringSwitch<StringRef>(Args.getLastArgValue(OPT_bitness, DefaultBitness))
+          .Case("32", "i386-pc-windows")
+          .Case("64", "x86_64-pc-windows")
+          .Default("");
+  return Triple(Triple::normalize(TripleName));
 }
 
 static std::unique_ptr<ToolOutputFile> GetOutputStream(StringRef Path) {
   std::error_code EC;
   auto Out = std::make_unique<ToolOutputFile>(Path, EC, sys::fs::F_None);
   if (EC) {
     WithColor::error() << EC.message() << '\n';
     return nullptr;
while (Lexer.Lex().isNot(AsmToken::Eof)) {
     OS << "\n";
     if (Lexer.getTok().getKind() == AsmToken::Error)
       Error = true;
   }
 
   return Error;
 }
 
-static int AssembleInput(const char *ProgName, const Target *TheTarget,
+static int AssembleInput(StringRef ProgName, const Target *TheTarget,
                          SourceMgr &SrcMgr, MCContext &Ctx, MCStreamer &Str,
                          MCAsmInfo &MAI, MCSubtargetInfo &STI,
-                         MCInstrInfo &MCII, MCTargetOptions &MCOptions) {
+                         MCInstrInfo &MCII, MCTargetOptions &MCOptions,
+                         const opt::ArgList &InputArgs) {
   std::unique_ptr<MCAsmParser> Parser(
       createMCMasmParser(SrcMgr, Ctx, Str, MAI, 0));
   std::unique_ptr<MCTargetAsmParser> TAP(
       TheTarget->createMCAsmParser(STI, *Parser, MCII, MCOptions));
 
   if (!TAP) {
     WithColor::error(errs(), ProgName)
         << "this target does not support assembly parsing.\n";
     return 1;
   }
 
-  Parser->setShowParsedOperands(ShowInstOperands);
+  Parser->setShowParsedOperands(InputArgs.hasArg(OPT_show_inst_operands));
   Parser->setTargetParser(*TAP);
   Parser->getLexer().setLexMasmIntegers(true);
   Parser->getLexer().useMasmDefaultRadix(true);
   Parser->getLexer().setLexMasmHexFloats(true);
   Parser->getLexer().setLexMasmStrings(true);
 
   int Res = Parser->Run(/*NoInitialTextSection=*/true);
 
   return Res;
 }
 
-int main(int argc, char **argv) {
-  InitLLVM X(argc, argv);
+int main(int Argc, char **Argv) {
+  InitLLVM X(Argc, Argv);
+  StringRef ProgName = sys::path::filename(Argv[0]);
 
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllDisassemblers();
 
-  // Register the target printer for --version.
-  cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
+  MLOptTable T;
+  unsigned MissingArgIndex, MissingArgCount;
+  ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
+  opt::InputArgList InputArgs =
+      T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount);
+
+  std::string InputFilename;
+  for (auto *Arg : InputArgs.filtered(OPT_INPUT)) {
+    std::string ArgString = Arg->getAsString(InputArgs);
+    if (ArgString == "-" || StringRef(ArgString).endswith(".asm")) {
+      if (!InputFilename.empty()) {
+        WithColor::warning(errs(), ProgName)
+            << "does not support multiple assembly files in one command; "
+            << "ignoring '" << InputFilename << "'\n";
+      }
+      InputFilename = ArgString;
+    } else {
+      std::string Diag;
+      raw_string_ostream OS(Diag);
+      OS << "invalid option '" << ArgString << "'";
+
+      std::string Nearest;
+      if (T.findNearest(ArgString, Nearest) < 2)
+        OS << ", did you mean '" << Nearest << "'?";
 
-  cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n");
-  MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
+      WithColor::error(errs(), ProgName) << OS.str() << '\n';
+      exit(1);
+    }
+  }
+  for (auto *Arg : InputArgs.filtered(OPT_assembly_file)) {
+    if (!InputFilename.empty()) {
+      WithColor::warning(errs(), ProgName)
+          << "does not support multiple assembly files in one command; "
+          << "ignoring '" << InputFilename << "'\n";
+    }
+    InputFilename = Arg->getAsString(InputArgs);
+  }
+
+  for (auto &Arg : InputArgs.filtered(OPT_unsupported_Group)) {
+    WithColor::warning(errs(), ProgName)
+        << "ignoring unsupported '" << Arg->getOption().getName()
+        << "' option\n";
+  }
+
+  if (InputArgs.hasArg(OPT_help)) {
+    std::string Usage = llvm::formatv("{0} [ /options ] file", ProgName).str();
+    T.PrintHelp(outs(), Usage.c_str(), "LLVM MASM Assembler",
+                /*ShowHidden=*/false);
+    return 0;
+  } else if (InputFilename.empty()) {
+    outs() << "USAGE: " << ProgName << " [ /options ] file\n"
+           << "Run \"" << ProgName << " /?\" or \"" << ProgName
+           << " /help\" for more info.\n";
+    return 0;
+  }
+
+  MCTargetOptions MCOptions;
   MCOptions.AssemblyLanguage = "masm";
 
-  const char *ProgName = argv[0];
-  const Target *TheTarget = GetTarget(ProgName);
-  if (!TheTarget)
+  Triple TheTriple = GetTriple(ProgName, InputArgs);
+  std::string Error;
+  const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error);
+  if (!TheTarget) {
+    WithColor::error(errs(), ProgName) << Error;
     return 1;
-  // Now that GetTarget() has (potentially) replaced TripleName, it's safe to
-  // construct the Triple object.
-  Triple TheTriple(TripleName);
+  }
+  const std::string &TripleName = TheTriple.getTriple();
 
+  bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
   if (SafeSEH && !(TheTriple.isArch32Bit() && TheTriple.isX86())) {
     WithColor::warning()
         << "/safeseh applies only to 32-bit X86 platforms; ignoring.\n";
     SafeSEH = false;
   }
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
       MemoryBuffer::getFileOrSTDIN(InputFilename);
   if (std::error_code EC = BufferPtr.getError()) {
     WithColor::error(errs(), ProgName)
         << InputFilename << ": " << EC.message() << '\n';
     return 1;
   }
-  MemoryBuffer *Buffer = BufferPtr->get();
 
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
 
   // Record the location of the include directories so that the lexer can find
   // it later.
-  SrcMgr.setIncludeDirs(IncludeDirs);
+  SrcMgr.setIncludeDirs(InputArgs.getAllArgValues(OPT_include_path));
 
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
   assert(MRI && "Unable to create target register info!");
 
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
-  MAI->setPreserveAsmComments(PreserveComments);
+  MAI->setPreserveAsmComments(InputArgs.hasArg(OPT_preserve_comments));
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
   MCObjectFileInfo MOFI;
   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr);
   MOFI.InitMCObjectFileInfo(TheTriple, /*PIC=*/false, Ctx,
                             /*LargeCodeModel=*/true);
 
-  if (SaveTempLabels)
+  if (InputArgs.hasArg(OPT_save_temp_labels))
     Ctx.setAllowTemporaryLabels(false);
 
-  if (!DebugCompilationDir.empty()) {
-    Ctx.setCompilationDir(DebugCompilationDir);
-  } else {
-    // If no compilation dir is set, try to use the current directory.
-    SmallString<128> CWD;
-    if (!sys::fs::current_path(CWD))
-      Ctx.setCompilationDir(CWD);
-  }
-  for (const auto &Arg : DebugPrefixMap) {
-    const auto &KV = StringRef(Arg).split('=');
-    Ctx.addDebugPrefixMapEntry(std::string(KV.first), std::string(KV.second));
-  }
-  if (!MainFileName.empty())
-    Ctx.setMainFileName(MainFileName);
+  // Set compilation information.
+  Ctx.setMainFileName(InputFilename);
 
+  StringRef FileType = InputArgs.getLastArgValue(OPT_filetype, "obj");
+  SmallString<255> DefaultOutputFilename;
+  if (InputArgs.hasArg(OPT_as_lex)) {
+    DefaultOutputFilename = "-";
+  } else {
+    DefaultOutputFilename = InputFilename;
+    sys::path::replace_extension(DefaultOutputFilename, FileType);
+  }
+  const StringRef OutputFilename =
+      InputArgs.getLastArgValue(OPT_output_file, DefaultOutputFilename);
   std::unique_ptr<ToolOutputFile> Out = GetOutputStream(OutputFilename);
   if (!Out)
     return 1;
 
   std::unique_ptr<buffer_ostream> BOS;
   raw_pwrite_stream *OS = &Out->os();
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   std::unique_ptr<MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(
       TripleName, /*CPU=*/"", /*Features=*/""));
 
   MCInstPrinter *IP = nullptr;
-  if (FileType == OFT_AssemblyFile) {
+  if (FileType == "s") {
+    const bool OutputATTAsm = InputArgs.hasArg(OPT_output_att_asm);
     const unsigned OutputAsmVariant = OutputATTAsm ? 0U   // ATT dialect
                                                    : 1U;  // Intel dialect
-    IP = TheTarget->createMCInstPrinter(Triple(TripleName), OutputAsmVariant,
-                                        *MAI, *MCII, *MRI);
+    IP = TheTarget->createMCInstPrinter(TheTriple, OutputAsmVariant, *MAI,
+                                        *MCII, *MRI);
 
     if (!IP) {
       WithColor::error()
           << "unable to create instruction printer for target triple '"
           << TheTriple.normalize() << "' with "
           << (OutputATTAsm ? "ATT" : "Intel") << " assembly variant.\n";
       return 1;
     }
 
     // Set the display preference for hex vs. decimal immediates.
-    IP->setPrintImmHex(PrintImmHex);
+    IP->setPrintImmHex(InputArgs.hasArg(OPT_print_imm_hex));
 
     // Set up the AsmStreamer.
     std::unique_ptr<MCCodeEmitter> CE;
-    if (ShowEncoding)
+    if (InputArgs.hasArg(OPT_show_encoding))
       CE.reset(TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
 
     std::unique_ptr<MCAsmBackend> MAB(
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
     auto FOut = std::make_unique<formatted_raw_ostream>(*OS);
-    Str.reset(
-        TheTarget->createAsmStreamer(Ctx, std::move(FOut), /*asmverbose*/ true,
-                                     /*useDwarfDirectory*/ true, IP,
-                                     std::move(CE), std::move(MAB), ShowInst));
+    Str.reset(TheTarget->createAsmStreamer(
+        Ctx, std::move(FOut), /*asmverbose*/ true,
+        /*useDwarfDirectory*/ true, IP, std::move(CE), std::move(MAB),
+        InputArgs.hasArg(OPT_show_inst)));
 
-  } else if (FileType == OFT_Null) {
+  } else if (FileType == "null") {
     Str.reset(TheTarget->createNullStreamer(Ctx));
-  } else {
-    assert(FileType == OFT_ObjectFile && "Invalid file type!");
-
+  } else if (FileType == "obj") {
     if (!Out->os().supportsSeeking()) {
       BOS = std::make_unique<buffer_ostream>(Out->os());
       OS = BOS.get();
     }
 
     MCCodeEmitter *CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx);
     MCAsmBackend *MAB = TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions);
     Str.reset(TheTarget->createMCObjectStreamer(
         TheTriple, Ctx, std::unique_ptr<MCAsmBackend>(MAB),
         MAB->createObjectWriter(*OS), std::unique_ptr<MCCodeEmitter>(CE), *STI,
         MCOptions.MCRelaxAll, MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ false));
+  } else {
+    llvm_unreachable("Invalid file type!");
   }
 
   if (TheTriple.isOSBinFormatCOFF()) {
     // Emit an absolute @feat.00 symbol. This is a features bitfield read by
     // link.exe.
     int64_t Feat00Flags = 0x2;
     if (SafeSEH) {
       // According to the PE-COFF spec, the LSB of this value marks the object
       // for "registered SEH".  This means that all SEH handler entry points
       // must be registered in .sxdata.  Use of any unregistered handlers will
       // cause the process to terminate immediately.
       Feat00Flags |= 0x1;
     }
     MCSymbol *Feat00Sym = Ctx.getOrCreateSymbol("@feat.00");
     Feat00Sym->setRedefinable(true);
     Str->emitSymbolAttribute(Feat00Sym, MCSA_Global);
     Str->emitAssignment(Feat00Sym, MCConstantExpr::create(Feat00Flags, Ctx));
   }
 
   // Use Assembler information for parsing.
   Str->setUseAssemblerInfoForParsing(true);
 
   int Res = 1;
-  bool disassemble = false;
-  switch (Action) {
-  case AC_AsLex:
+  if (InputArgs.hasArg(OPT_as_lex)) {
+    // -as-lex; Lex only, and output a stream of tokens
     Res = AsLexInput(SrcMgr, *MAI, Out->os());
-    break;
-  case AC_Assemble:
+  } else {
     Res = AssembleInput(ProgName, TheTarget, SrcMgr, Ctx, *Str, *MAI, *STI,
-                        *MCII, MCOptions);
-    break;
-  case AC_MDisassemble:
-    assert(IP && "Expected assembly output");
-    IP->setUseMarkup(1);
-    disassemble = true;
-    break;
-  case AC_Disassemble:
-    disassemble = true;
-    break;
-  }
-  if (disassemble)
-    Res = Disassembler::disassemble(*TheTarget, TripleName, *STI, *Str, *Buffer,
-                                    SrcMgr, Out->os());
+                        *MCII, MCOptions, InputArgs);
+  }
 
   // Keep output if no errors.
   if (Res == 0)
     Out->keep();
   return Res;
 }