[llvm-libtool-darwin] Add support for -V option

[smeenai]

Summary

The -V option in cctools' libtool prints out the version number and
performs any specified operation. Add this option to LLVM's version.
cctools is more forgiving of invalid command lines when -V is specified,
but I think it's better to give errors instead of silently producing no
output.

Unfortunately, when -V is present, options that would otherwise be
required aren't anymore, so we need to perform some manual argument
validation.

[alexander-shaposhnikov]

LG

[jhenderson]

It looks like no documentation was added for the new option. Please add it!

llvm/test/tools/llvm-libtool-darwin/version.test

8

Nit: here and each other comment in the test - missing full stop.

[smeenai]

In D86359#2235358, @jhenderson wrote:

It looks like no documentation was added for the new option. Please add it!

Thanks for the reminder! Addressed that and the other comment in rG22cd6bee4a7d.

[jhenderson]

In D86359#2237381, @smeenai wrote:

In D86359#2235358, @jhenderson wrote:

It looks like no documentation was added for the new option. Please add it!

Thanks for the reminder! Addressed that and the other comment in rG22cd6bee4a7d.

Thanks!

llvm/test/tools/llvm-libtool-darwin/invalid-input-output-args.test

 ## This test checks that an error is thrown in case of invalid input/output args.
 
 ## Missing input file:
 # RUN: not llvm-libtool-darwin -static -o %t.lib 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-INPUT
 
 # NO-INPUT: error: no input files specified
 
 ## Missing output file:
 # RUN: not llvm-libtool-darwin -static %t.input 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-OUTPUT
 
-# NO-OUTPUT: for the -o option: must be specified at least once!
+# NO-OUTPUT: for the -o option: must be specified
 
 ## Missing argument to -o:
 # RUN: not llvm-libtool-darwin -static %t.input -o 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=MISSING
 
 # MISSING: for the -o option: requires a value!
 
 ## Passing in two output files:
 # RUN: not llvm-libtool-darwin -static %t.input -o %t.lib1 -o %t.lib2 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=DOUBLE-OUTPUT
 
-# DOUBLE-OUTPUT: for the -o option: must occur exactly one time!
+# DOUBLE-OUTPUT: for the -o option: may only occur zero or one times!
 
 ## Input file not found:
 # RUN: not llvm-libtool-darwin -static -o %t.lib %t.missing 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-FILE -DFILE=%t.missing
 
 # NO-FILE: error: '[[FILE]]': {{[nN]}}o such file or directory
 
 ## Input file is not an object file:

llvm/test/tools/llvm-libtool-darwin/missing-library-type.test

 ## Missing library type option:
 # RUN: not llvm-libtool-darwin -o %t.lib %t.input 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=MISSING-OPERATION
 
-# MISSING-OPERATION: Library Type: option: must be specified at least once!
+# MISSING-OPERATION: Library Type: option: must be specified

llvm/test/tools/llvm-libtool-darwin/version.test

+## Test the -V flag, which prints the version number to stdout. It also allows
+## for no operation to be specified, but if an operation is specified, it should
+## still occur and regular argument parsing errors should be surfaced (unlike
+## cctools libtool, which silences all argument parsing errors when -V is
+## specified).
+
+## Test -V by itself
+# RUN: llvm-libtool-darwin -V | FileCheck %s
+## The specific version number, vendor string, etc. will differ across
+## environments, so this is the most specific we can get.
+# CHECK: LLVM version
+
+## Parsing errors should not be surfaced when no operation is specified
+# RUN: llvm-libtool-darwin -V -D -U | FileCheck %s
+
+## Regular errors should occur when an operation is specified
+# RUN: not llvm-libtool-darwin -V -static 2>&1 | FileCheck --check-prefix=ERROR %s
+# ERROR: for the -o option: must be specified
+
+## A valid command line should print the version and perform the operation
+# RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
+# RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
+# RUN: llvm-libtool-darwin -static -o %t.lib %t-input1.o %t-input2.o -V | FileCheck %s
+# RUN: llvm-libtool-darwin -static -o %t2.lib %t-input1.o %t-input2.o
+# RUN: cmp %t.lib %t2.lib

llvm/tools/llvm-libtool-darwin/llvm-libtool-darwin.cpp

 using namespace llvm::object;
 
 typedef std::map<uint64_t, std::vector<NewArchiveMember>>
     MembersPerArchitectureMap;
 
 cl::OptionCategory LibtoolCategory("llvm-libtool-darwin Options");
 
 static cl::opt<std::string> OutputFile("o", cl::desc("Specify output filename"),
-                                       cl::value_desc("filename"), cl::Required,
+                                       cl::value_desc("filename"),
                                        cl::cat(LibtoolCategory));
 
 static cl::list<std::string> InputFiles(cl::Positional,
                                         cl::desc("<input files>"),
                                         cl::ZeroOrMore,
                                         cl::cat(LibtoolCategory));
 
 static cl::opt<std::string> ArchType(
     "arch_only", cl::desc("Specify architecture type for output library"),
     cl::value_desc("arch_type"), cl::ZeroOrMore, cl::cat(LibtoolCategory));
 
-enum class Operation { Static };
+enum class Operation { None, Static };
 
 static cl::opt<Operation> LibraryOperation(
     cl::desc("Library Type: "),
     cl::values(
         clEnumValN(Operation::Static, "static",
                    "Produce a statically linked library from the input files")),
-    cl::Required, cl::cat(LibtoolCategory));
+    cl::init(Operation::None), cl::cat(LibtoolCategory));
 
 static cl::opt<bool> DeterministicOption(
     "D", cl::desc("Use zero for timestamps and UIDs/GIDs (Default)"),
     cl::init(false), cl::cat(LibtoolCategory));
 
 static cl::opt<bool>
     NonDeterministicOption("U", cl::desc("Use actual timestamps and UIDs/GIDs"),
                            cl::init(false), cl::cat(LibtoolCategory));

 
 static cl::list<std::string> LibrarySearchDirs(
     "L",
     cl::desc(
         "L<dir> adds <dir> to the list of directories in which to search for"
         " libraries"),
     cl::ZeroOrMore, cl::Prefix, cl::cat(LibtoolCategory));
 
+static cl::opt<bool>
+    VersionOption("V", cl::desc("Print the version number and exit"),
+                  cl::cat(LibtoolCategory));
+
 static const std::array<std::string, 3> StandardSearchDirs{
     "/lib",
     "/usr/lib",
     "/usr/local/lib",
 };
 
 struct Config {
   bool Deterministic = true; // Updated by 'D' and 'U' modifiers.
static Error createStaticLibrary(const Config &C) {
   }
   return Error::success();
 }
 
 static Expected<Config> parseCommandLine(int Argc, char **Argv) {
   Config C;
   cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n");
 
+  if (LibraryOperation == Operation::None) {
+    if (!VersionOption) {
+      std::string Error;
+      raw_string_ostream Stream(Error);
+      LibraryOperation.error("must be specified", "", Stream);
+      return createStringError(std::errc::invalid_argument, Error.c_str());
+    }
+    return C;
+  }
+
+  if (OutputFile.empty()) {
+    std::string Error;
+    raw_string_ostream Stream(Error);
+    OutputFile.error("must be specified", "o", Stream);
+    return createStringError(std::errc::invalid_argument, Error.c_str());
+  }
+
   if (DeterministicOption && NonDeterministicOption)
     return createStringError(std::errc::invalid_argument,
                              "cannot specify both -D and -U flags");
   else if (NonDeterministicOption)
     C.Deterministic = false;
 
   if (!Libraries.empty())
     if (Error E = processCommandLineLibraries())
int main(int Argc, char **Argv) {
   InitLLVM X(Argc, Argv);
   cl::HideUnrelatedOptions({&LibtoolCategory, &ColorCategory});
   Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv);
   if (!ConfigOrErr) {
     WithColor::defaultErrorHandler(ConfigOrErr.takeError());
     return EXIT_FAILURE;
   }
 
+  if (VersionOption)
+    cl::PrintVersionMessage();
+
   Config C = *ConfigOrErr;
   switch (LibraryOperation) {
+  case Operation::None:
+    break;
   case Operation::Static:
     if (Error E = createStaticLibrary(C)) {
       WithColor::defaultErrorHandler(std::move(E));
       return EXIT_FAILURE;
     }
     break;
   }
 }