[ms] [llvm-ml] Allow the /Zs parameter as a synonym for -filetype=null

[epastor]

Summary

For ml.exe, /Zs implies a syntax check with no output files.

[epastor]

Rebase on HEAD

[epastor]

Rebase on HEAD

[epastor]

Rebase on parent

[thakis]

The unrelated change looks a) unrelated b) incorrect.

No test?

Can we drop -filetype=nul now that we have this?

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

77

mention this change in cl description, add test for it

....but I don't think this change is correct?

C:\src>ml64 foo.asm /c /foasdf.obj /nologo
Microsoft (R) Macro Assembler (x64) Version 14.25.28614.0
Copyright (C) Microsoft Corporation.  All rights reserved.

 Assembling: foo.asm
MASM : warning A4018:invalid command-line option : /foasdf.obj

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

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

77

This is correcting us to match ml64; we previously considered /fo equivalent to /Fo, but this was a mistake. However, I'll push it up the stack to the change that introduced the problem instead.

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[thakis]

Still no test, as far as I can tell. I think the suggestion below turns this into a 3-line diff (+ test).

llvm/tools/llvm-ml/Opts.td

47

Instead of all the DerivedArgList changes below, doesn't just saying ..., Alias<filetype>, AliasArgs<"none"> here do the same thing?

[epastor]

Use AliasArgs to simplify

[epastor]

Fix errors in Alias/AliasArgs use, and add tests

[epastor]

In D90061#2431150, @thakis wrote:

Still no test, as far as I can tell. I think the suggestion below turns this into a 3-line diff (+ test).

Tests added, thanks.

llvm/tools/llvm-ml/Opts.td

47

... yes, and I didn't know that was an option. Fixed - though it did require me to move these below the LLVM-style args, so we could successfully alias it to one of them.

Thanks, this is much better!

[thakis]

v nice :)

llvm/tools/llvm-ml/Opts.td

 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">, MetaVarName<"<filename>">,
                     HelpText<"Assemble source file with name not ending with "
                              "the .asm extension">;
+def parse_only : MLFlag<"Zs">, HelpText<"Run a syntax-check only">;
 
 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">,
def codeview_info : UnsupportedFlag<"Zi">,
                     HelpText<"Include CodeView information in the object file">;
 def enable_m510_option : UnsupportedFlag<"Zm">,
                          HelpText<"Enable the M510 option for increased MASM "
                                   "5.1 compatibility. Only available for "
                                   "32-bit x86.">;
 def structure_packing : UnsupportedJoined<"Zp">, MetaVarName<"<alignment>">,
                         HelpText<"Pack structures with the specified "
                                  "alignment by default">;
-def parse_only : UnsupportedFlag<"Zs">, HelpText<"Run a syntax-check only">;

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

 
 namespace {
 
 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
 };
 
 #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
 };
 
 class MLOptTable : public opt::OptTable {
 public:
-  MLOptTable() : OptTable(InfoTable, true) {}
+  MLOptTable() : OptTable(InfoTable, /*IgnoreCase=*/false) {}
 };
 } // namespace
 
-static Triple GetTriple(StringRef ProgName, opt::InputArgList &Args) {
+static Triple GetTriple(StringRef ProgName, opt::ArgList &Args) {
   // Figure out the target triple.
   StringRef DefaultBitness = "32";
   SmallString<255> Program = ProgName;
   sys::path::replace_extension(Program, "");
   if (Program.endswith("ml64"))
     DefaultBitness = "64";
 
   StringRef TripleName =
static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, raw_ostream &OS) {
 
   return Error;
 }
 
 static int AssembleInput(StringRef ProgName, const Target *TheTarget,
                          SourceMgr &SrcMgr, MCContext &Ctx, MCStreamer &Str,
                          MCAsmInfo &MAI, MCSubtargetInfo &STI,
                          MCInstrInfo &MCII, MCTargetOptions &MCOptions,
-                         const opt::ArgList &InputArgs) {
+                         const opt::ArgList &Args) {
   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(InputArgs.hasArg(OPT_show_inst_operands));
+  Parser->setShowParsedOperands(Args.hasArg(OPT_show_inst_operands));
   Parser->setTargetParser(*TAP);
   Parser->getLexer().setLexMasmIntegers(true);
   Parser->getLexer().useMasmDefaultRadix(true);
   Parser->getLexer().setLexMasmHexFloats(true);
   Parser->getLexer().setLexMasmStrings(true);
 
-  auto Defines = InputArgs.getAllArgValues(OPT_define);
+  auto Defines = Args.getAllArgValues(OPT_define);
   for (StringRef Define : Defines) {
     const auto NameValue = Define.split('=');
     StringRef Name = NameValue.first, Value = NameValue.second;
     if (Parser->defineMacro(Name, Value)) {
       WithColor::error(errs(), ProgName)
           << "can't define macro '" << Name << "' = '" << Value << "'\n";
       return 1;
     }
int main(int Argc, char **Argv) {
   llvm::InitializeAllDisassemblers();
 
   MLOptTable T;
   unsigned MissingArgIndex, MissingArgCount;
   ArrayRef<const char *> ArgsArr = makeArrayRef(Argv + 1, Argc - 1);
   opt::InputArgList InputArgs =
       T.ParseArgs(ArgsArr, MissingArgIndex, MissingArgCount);
 
+  opt::DerivedArgList Args(InputArgs);
+  for (auto *Arg : InputArgs) {
+    Args.append(Arg);
+  }
+
   std::string InputFilename;
-  for (auto *Arg : InputArgs.filtered(OPT_INPUT)) {
-    std::string ArgString = Arg->getAsString(InputArgs);
+  for (auto *Arg : Args.filtered(OPT_INPUT)) {
+    std::string ArgString = Arg->getAsString(Args);
     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 << "'?";
 
       WithColor::error(errs(), ProgName) << OS.str() << '\n';
       exit(1);
     }
   }
-  for (auto *Arg : InputArgs.filtered(OPT_assembly_file)) {
+  for (auto *Arg : Args.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);
+    InputFilename = Arg->getAsString(Args);
   }
 
-  for (auto &Arg : InputArgs.filtered(OPT_unsupported_Group)) {
+  for (auto &Arg : Args.filtered(OPT_unsupported_Group)) {
     WithColor::warning(errs(), ProgName)
         << "ignoring unsupported '" << Arg->getOption().getName()
         << "' option\n";
   }
 
-  if (InputArgs.hasArg(OPT_help)) {
+  if (Args.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;
   }
 
+  if (Args.hasArg(OPT_parse_only))
+    Args.AddJoinedArg(nullptr, T.getOption(OPT_filetype), "null");
+
   MCTargetOptions MCOptions;
   MCOptions.AssemblyLanguage = "masm";
 
-  Triple TheTriple = GetTriple(ProgName, InputArgs);
+  Triple TheTriple = GetTriple(ProgName, Args);
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget("", TheTriple, Error);
   if (!TheTarget) {
     WithColor::error(errs(), ProgName) << Error;
     return 1;
   }
   const std::string &TripleName = TheTriple.getTriple();
 
-  bool SafeSEH = InputArgs.hasArg(OPT_safeseh);
+  bool SafeSEH = Args.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;
   }
 
   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(InputArgs.getAllArgValues(OPT_include_path));
+  SrcMgr.setIncludeDirs(Args.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(InputArgs.hasArg(OPT_preserve_comments));
+  MAI->setPreserveAsmComments(Args.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 (InputArgs.hasArg(OPT_save_temp_labels))
+  if (Args.hasArg(OPT_save_temp_labels))
     Ctx.setAllowTemporaryLabels(false);
 
   // Set compilation information.
   SmallString<128> CWD;
   if (!sys::fs::current_path(CWD))
     Ctx.setCompilationDir(CWD);
   Ctx.setMainFileName(InputFilename);
 
-  StringRef FileType = InputArgs.getLastArgValue(OPT_filetype, "obj");
+  StringRef FileType = Args.getLastArgValue(OPT_filetype, "obj");
   SmallString<255> DefaultOutputFilename;
-  if (InputArgs.hasArg(OPT_as_lex)) {
+  if (Args.hasArg(OPT_as_lex)) {
     DefaultOutputFilename = "-";
   } else {
     DefaultOutputFilename = InputFilename;
     sys::path::replace_extension(DefaultOutputFilename, FileType);
   }
   const StringRef OutputFilename =
-      InputArgs.getLastArgValue(OPT_output_file, DefaultOutputFilename);
+      Args.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 == "s") {
-    const bool OutputATTAsm = InputArgs.hasArg(OPT_output_att_asm);
+    const bool OutputATTAsm = Args.hasArg(OPT_output_att_asm);
     const unsigned OutputAsmVariant = OutputATTAsm ? 0U   // ATT dialect
                                                    : 1U;  // Intel dialect
     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(InputArgs.hasArg(OPT_print_imm_hex));
+    IP->setPrintImmHex(Args.hasArg(OPT_print_imm_hex));
 
     // Set up the AsmStreamer.
     std::unique_ptr<MCCodeEmitter> CE;
-    if (InputArgs.hasArg(OPT_show_encoding))
+    if (Args.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),
-        InputArgs.hasArg(OPT_show_inst)));
+        Args.hasArg(OPT_show_inst)));
 
   } else if (FileType == "null") {
     Str.reset(TheTarget->createNullStreamer(Ctx));
   } else if (FileType == "obj") {
     if (!Out->os().supportsSeeking()) {
       BOS = std::make_unique<buffer_ostream>(Out->os());
       OS = BOS.get();
     }
if (TheTriple.isOSBinFormatCOFF()) {
     Str->emitSymbolAttribute(Feat00Sym, MCSA_Global);
     Str->emitAssignment(Feat00Sym, MCConstantExpr::create(Feat00Flags, Ctx));
   }
 
   // Use Assembler information for parsing.
   Str->setUseAssemblerInfoForParsing(true);
 
   int Res = 1;
-  if (InputArgs.hasArg(OPT_as_lex)) {
+  if (Args.hasArg(OPT_as_lex)) {
     // -as-lex; Lex only, and output a stream of tokens
     Res = AsLexInput(SrcMgr, *MAI, Out->os());
   } else {
     Res = AssembleInput(ProgName, TheTarget, SrcMgr, Ctx, *Str, *MAI, *STI,
-                        *MCII, MCOptions, InputArgs);
+                        *MCII, MCOptions, Args);
   }
 
   // Keep output if no errors.
   if (Res == 0)
     Out->keep();
   return Res;
 }