[llvm] Add subcommand support for OptTable

clang-tools-extra/clangd/CompileCommands.cpp

@@ -465,7 +465,7 @@ llvm::ArrayRef<ArgStripper::Rule> ArgStripper::rulesFor(llvm::StringRef Arg) {
     } AliasTable[] = {
 #define OPTION(PREFIX, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS,       \
                FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS,       \
-               METAVAR, VALUES)                                                \
+               METAVAR, VALUES, SUBCOMMANDIDS_OFFSET)                          \
   {DriverID::OPT_##ID, DriverID::OPT_##ALIAS, ALIASARGS},
 #include "clang/Driver/Options.inc"
 #undef OPTION

clang/lib/Frontend/CompilerInvocation.cpp

@@ -533,9 +533,9 @@ static T extractMaskValue(T KeyPath) {
 #define PARSE_OPTION_WITH_MARSHALLING(                                         \
     ARGS, DIAGS, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS,         \
     ALIASARGS, FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS,       \
-    METAVAR, VALUES, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,        \
-    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
-    TABLE_INDEX)                                                               \
+    METAVAR, VALUES, SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \
+    DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER,     \
+    MERGER, EXTRACTOR, TABLE_INDEX)                                            \
   if ((VISIBILITY) & options::CC1Option) {                                     \
     KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE);                                  \
     if (IMPLIED_CHECK)                                                         \
@@ -551,8 +551,9 @@ static T extractMaskValue(T KeyPath) {
 #define GENERATE_OPTION_WITH_MARSHALLING(                                      \
     CONSUMER, PREFIX_TYPE, SPELLING_OFFSET, ID, KIND, GROUP, ALIAS, ALIASARGS, \
     FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
-    SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK,          \
-    IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)   \
+    SUBCOMMANDIDS_OFFSET, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE,   \
+    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, \
+    TABLE_INDEX)                                                               \
   if ((VISIBILITY) & options::CC1Option) {                                     \
     [&](const auto &Extracted) {                                               \
       if (ALWAYS_EMIT ||                                                       \

clang/tools/clang-installapi/Options.h

@@ -208,7 +208,7 @@ enum ID {
   OPT_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,         \
                VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR,     \
-               VALUES)                                                         \
+               VALUES, SUBCOMMANDIDS_OFFSET)                                   \
   OPT_##ID,
 #include "InstallAPIOpts.inc"
   LastOption

lld/MachO/DriverUtils.cpp

@@ -45,7 +45,7 @@ using namespace lld::macho;
 static constexpr OptTable::Info optInfo[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,         \
                VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR,     \
-               VALUES)                                                         \
+               VALUES, SUBCOMMANDIDS_OFFSET)                                   \
   {PREFIX,                                                                     \
    NAME,                                                                       \
    HELPTEXT,                                                                   \
@@ -59,7 +59,8 @@ static constexpr OptTable::Info optInfo[] = {
    OPT_##GROUP,                                                                \
    OPT_##ALIAS,                                                                \
    ALIASARGS,                                                                  \
-   VALUES},
+   VALUES,                                                                     \
+   SUBCOMMANDIDS_OFFSET},
 #include "Options.inc"
 #undef OPTION
 };

lld/MinGW/Driver.cpp

@@ -69,7 +69,7 @@ enum {
 static constexpr opt::OptTable::Info infoTable[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,         \
                VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR,     \
-               VALUES)                                                         \
+               VALUES, SUBCOMMANDIDS_OFFSET)                                   \
   {PREFIX,                                                                     \
    NAME,                                                                       \
    HELPTEXT,                                                                   \
@@ -83,7 +83,8 @@ static constexpr opt::OptTable::Info infoTable[] = {
    OPT_##GROUP,                                                                \
    OPT_##ALIAS,                                                                \
    ALIASARGS,                                                                  \
-   VALUES},
+   VALUES,                                                                     \
+   SUBCOMMANDIDS_OFFSET},
 #include "Options.inc"
 #undef OPTION
 };

lld/wasm/Driver.cpp

@@ -157,7 +157,7 @@ bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
 static constexpr opt::OptTable::Info optInfo[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,         \
                VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR,     \
-               VALUES)                                                         \
+               VALUES, SUBCOMMANDIDS_OFFSET)                                   \
   {PREFIX,                                                                     \
    NAME,                                                                       \
    HELPTEXT,                                                                   \
@@ -171,7 +171,8 @@ static constexpr opt::OptTable::Info optInfo[] = {
    OPT_##GROUP,                                                                \
    OPT_##ALIAS,                                                                \
    ALIASARGS,                                                                  \
-   VALUES},
+   VALUES,                                                                     \
+   SUBCOMMANDIDS_OFFSET},
 #include "Options.inc"
 #undef OPTION
 };

llvm/examples/CMakeLists.txt

@@ -8,6 +8,7 @@ add_subdirectory(ModuleMaker)
 add_subdirectory(OrcV2Examples)
 add_subdirectory(SpeculativeJIT)
 add_subdirectory(Bye)
+add_subdirectory(OptSubcommand)
 
 if(LLVM_ENABLE_EH AND (NOT WIN32) AND (NOT "${LLVM_NATIVE_ARCH}" STREQUAL "ARM"))
     add_subdirectory(ExceptionDemo)

llvm/examples/OptSubcommand/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Set the .td file to be processed for this target.
+set(LLVM_TARGET_DEFINITIONS Opts.td)
+
+tablegen(LLVM Opts.inc -gen-opt-parser-defs)
+add_public_tablegen_target(HelloSubTableGen)
+
+set(LLVM_LINK_COMPONENTS  
+  Support
+  Option  
+  )
+
+add_llvm_example(OptSubcommand
+  llvm-hello-sub.cpp  
+  )
+
+target_include_directories(OptSubcommand
+  PRIVATE
+  ${CMAKE_CURRENT_BINARY_DIR}
+  )

llvm/examples/OptSubcommand/Opts.td

@@ -0,0 +1,18 @@
+include "llvm/Option/OptParser.td"
+
+def sc_foo : SubCommand<"foo", "HelpText for SubCommand foo.">;
+
+def sc_bar : SubCommand<"bar", "HelpText for SubCommand bar.",
+                        "OptSubcommand bar <options>">;
+
+def help : Flag<["--"], "help">,
+           HelpText<"OptSubcommand <subcommand> <options>">;
+
+def version : Flag<["-"], "version">,
+              HelpText<"Toplevel Display the version number">;
+
+def uppercase : Flag<["-"], "uppercase", [sc_foo, sc_bar]>,
+                HelpText<"Print in uppercase">;
+
+def lowercase : Flag<["-"], "lowercase", [sc_foo]>,
+                HelpText<"Print in lowercase">;

llvm/examples/OptSubcommand/llvm-hello-sub.cpp

@@ -0,0 +1,124 @@
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Option/OptTable.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::opt;
+
+namespace {
+enum ID {
+  OPT_INVALID = 0,
+#define OPTION(PREFIXES, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,       \
+               VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR,     \
+               VALUES, SUBCOMMANDIDS_OFFSET)                                   \
+  OPT_##ID,
+#include "Opts.inc"
+#undef OPTION
+};
+#define OPTTABLE_STR_TABLE_CODE
+#include "Opts.inc"
+#undef OPTTABLE_STR_TABLE_CODE
+
+#define OPTTABLE_PREFIXES_TABLE_CODE
+#include "Opts.inc"
+#undef OPTTABLE_PREFIXES_TABLE_CODE
+
+#define OPTTABLE_SUBCOMMAND_IDS_TABLE_CODE
+#include "Opts.inc"
+#undef OPTTABLE_SUBCOMMAND_IDS_TABLE_CODE
+
+#define OPTTABLE_SUBCOMMANDS_CODE
+#include "Opts.inc"
+#undef OPTTABLE_SUBCOMMANDS_CODE
+
+static constexpr OptTable::Info InfoTable[] = {
+#define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),
+#include "Opts.inc"
+#undef OPTION
+};
+
+class HelloSubOptTable : public GenericOptTable {
+public:
+  HelloSubOptTable()
+      : GenericOptTable(OptionStrTable, OptionPrefixesTable, InfoTable,
+                        /*IgnoreCase=*/false, OptionSubCommands,
+                        OptionSubCommandIDsTable) {}
+};
+} // namespace
+
+int main(int argc, char **argv) {
+  InitLLVM X(argc, argv);
+  HelloSubOptTable T;
+  unsigned MissingArgIndex, MissingArgCount;
+
+  auto HandleMultipleSubcommands = [](ArrayRef<StringRef> SubCommands) {
+    assert(SubCommands.size() > 1);
+    llvm::errs() << "error: more than one subcommand passed [\n";
+    for (auto SC : SubCommands)
+      llvm::errs() << " `" << SC << "`\n";
+    llvm::errs() << "]\n";
+    llvm::errs() << "See --help.\n";
+    exit(1);
+  };
+
+  auto HandleOtherPositionals = [](ArrayRef<StringRef> Positionals) {
+    assert(!Positionals.empty());
+    llvm::errs() << "error: unknown positional argument(s) [\n";
+    for (auto SC : Positionals)
+      llvm::errs() << " `" << SC << "`\n";
+    llvm::errs() << "]\n";
+    llvm::errs() << "See --help.\n";
+    exit(1);
+  };
+
+  InputArgList Args = T.ParseArgs(ArrayRef(argv + 1, argc - 1), MissingArgIndex,
+                                  MissingArgCount);
+
+  StringRef Subcommand = Args.getSubcommand(
+      T.getSubCommands(), HandleMultipleSubcommands, HandleOtherPositionals);
+  // Handle help. When help options is found, ignore all other options and exit
+  // after printing help.
+
+  if (Args.hasArg(OPT_help)) {
+    T.printHelp(llvm::outs(), "llvm-hello-sub [subcommand] [options]",
+                "LLVM Hello Subcommand Example", false, false, Visibility(),
+                Subcommand);
+    return 0;
+  }
+  bool HasUnknownOptions = false;
+  for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
+    HasUnknownOptions = true;
+    llvm::errs() << "Unknown option `" << A->getAsString(Args) << "'\n";
+  }
+  if (HasUnknownOptions) {
+    llvm::errs() << "See `OptSubcommand --help`.\n";
+    return 1;
+  }
+  if (Subcommand.empty()) {
+    if (Args.hasArg(OPT_version))
+      llvm::outs() << "LLVM Hello Subcommand Example 1.0\n";
+  } else if (Subcommand == "foo") {
+    if (Args.hasArg(OPT_uppercase))
+      llvm::outs() << "FOO\n";
+    else if (Args.hasArg(OPT_lowercase))
+      llvm::outs() << "foo\n";
+
+    if (Args.hasArg(OPT_version))
+      llvm::outs() << "LLVM Hello Subcommand foo Example 1.0\n";
+
+  } else if (Subcommand == "bar") {
+    if (Args.hasArg(OPT_lowercase))
+      llvm::outs() << "bar\n";
+    else if (Args.hasArg(OPT_uppercase))
+      llvm::outs() << "BAR\n";
+
+    if (Args.hasArg(OPT_version))
+      llvm::outs() << "LLVM Hello Subcommand bar Example 1.0\n";
+  }
+
+  return 0;
+}

llvm/include/llvm/Option/ArgList.h

@@ -20,6 +20,7 @@
 #include "llvm/Option/OptSpecifier.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cstddef>
 #include <initializer_list>
@@ -280,6 +281,22 @@ class ArgList {
   /// list.
   virtual unsigned getNumInputArgStrings() const = 0;
 
+  /// getSubcommand - Find subcommand from the arguments if the usage is valid.
+  ///
+  /// \param AllSubCommands - A list of all valid subcommands.
+  /// \param HandleMultipleSubcommands - A callback for the case where multiple
+  /// subcommands are present in the arguments. It gets a list of all found
+  /// subcommands.
+  /// \param HandleOtherPositionals - A callback for the case where positional
+  /// arguments that are not subcommands are present.
+  /// \return The name of the subcommand found. If no subcommand is found,
+  /// this returns an empty StringRef. If multiple subcommands are found, the
+  /// first one is returned.
+  StringRef getSubcommand(
+      ArrayRef<OptTable::SubCommand> AllSubCommands,
+      std::function<void(ArrayRef<StringRef>)> HandleMultipleSubcommands,
+      std::function<void(ArrayRef<StringRef>)> HandleOtherPositionals) const;
+
   /// @}
   /// @name Argument Lookup Utilities
   /// @{

llvm/include/llvm/Option/OptParser.td

@@ -98,7 +98,15 @@ class HelpTextVariant<list<OptionVisibility> visibilities, string text> {
   string Text = text;
 }
 
-class Option<list<string> prefixes, string name, OptionKind kind> {
+// Class definition for positional subcommands.
+class SubCommand<string name, string helpText, string usage = ""> {
+  string Name = name;
+  string HelpText = helpText;
+  string Usage = usage;
+}
+
+class Option<list<string> prefixes, string name, OptionKind kind,
+             list<SubCommand> subcommands = []> {
   string EnumName = ?; // Uses the def name if undefined.
   list<string> Prefixes = prefixes;
   string Name = name;
@@ -129,26 +137,34 @@ class Option<list<string> prefixes, string name, OptionKind kind> {
   code ValueMerger = "mergeForwardValue";
   code ValueExtractor = "extractForwardValue";
   list<code> NormalizedValues = ?;
+  list<SubCommand> SubCommands = subcommands;
 }
 
 // Helpers for defining options.
 
-class Flag<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_FLAG>;
-class Joined<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_JOINED>;
-class Separate<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_SEPARATE>;
-class CommaJoined<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_COMMAJOINED>;
-class MultiArg<list<string> prefixes, string name, int numargs>
-  : Option<prefixes, name, KIND_MULTIARG> {
+class Flag<list<string> prefixes, string name,
+           list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_FLAG, subcommands>;
+class Joined<list<string> prefixes, string name,
+             list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_JOINED, subcommands>;
+class Separate<list<string> prefixes, string name,
+               list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_SEPARATE, subcommands>;
+class CommaJoined<list<string> prefixes, string name,
+                  list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_COMMAJOINED, subcommands>;
+class MultiArg<list<string> prefixes, string name, int numargs,
+               list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_MULTIARG, subcommands> {
   int NumArgs = numargs;
 }
-class JoinedOrSeparate<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_JOINED_OR_SEPARATE>;
-class JoinedAndSeparate<list<string> prefixes, string name>
-  : Option<prefixes, name, KIND_JOINED_AND_SEPARATE>;
+class JoinedOrSeparate<list<string> prefixes, string name,
+                       list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_JOINED_OR_SEPARATE, subcommands>;
+class JoinedAndSeparate<list<string> prefixes, string name,
+                        list<SubCommand> subcommands = []>
+    : Option<prefixes, name, KIND_JOINED_AND_SEPARATE, subcommands>;
 
 // Mix-ins for adding optional attributes.