[OptTable] Precompute OptTable prefixes union table through tablegen

[serge-sans-paille]

Summary

This avoid rediscovering this table when reading each options, providing
a sensible 2% speedup when processing and empty file, and a measurable
speedup on typical workloads, see:

https://llvm-compile-time-tracker.com/compare.php?from=4da6cb3202817ee2897d6b690e4af950459caea4&to=dffbe8638a92bfc73dff5494144d5ef9a73c0acc&stat=instructions:u

[thakis]

Could we make this an optional opt-in maybe? I imagine for the majority of the tools, this has no measurable effect, but it currently makes the Opt library harder to use for every client.

[serge-sans-paille]

In D140800#4021228, @thakis wrote:

Could we make this an optional opt-in maybe? I imagine for the majority of the tools, this has no measurable effect, but it currently makes the Opt library harder to use for every client.

Sure, let's have two constructors, one that uses a precomputed table and one that does the precomputation.
Would you prefer having only clang use the faster-but-less efficient method, or can I keep the changes as is?

[thakis]

I'd only use it in clang tbh. Clang uses many orders of magnitudes more opts than all other tools, and even there it's not a _huge_ win. (2% on empty file is very nice! But most of the time, people don't compile empty files, and I'm guessing on non-empty files this is a negligible win even in clang.) What do you think?

[serge-sans-paille]

Added to versions of OptTable, one that uses a precomputed Table, generated by TableGen, and one that relies on the old, generic approach. Both are tested using the same test bench.

Updated benchmark: https://llvm-compile-time-tracker.com/compare.php?from=4da6cb3202817ee2897d6b690e4af950459caea4&to=19a492b704e8f5c1dea120b9c0d3859bd78796be&stat=instructions:u

[serge-sans-paille]

In D140800#4021282, @thakis wrote:

I'm guessing on non-empty files this is a negligible win even in clang.

As showcased by https://llvm-compile-time-tracker.com/compare.php?from=4da6cb3202817ee2897d6b690e4af950459caea4&to=19a492b704e8f5c1dea120b9c0d3859bd78796be&stat=instructions:u, it's not neglectible in -O0 (and obviously even less neglictible for the preprocessing-only step)

[serge-sans-paille]

(rebased on main. Note that this patch is applied on top of https://reviews.llvm.org/D140699)

[serge-sans-paille]

@nikic : gentle ping :-)

[nikic]

Just to check, this isn't going to cause some warning spew about all those OptTable implementations being non-final?

llvm/include/llvm/Option/OptTable.h

256

Comment looks a bit unfinished :)

llvm/unittests/Option/OptionParsingTest.cpp

87

What's this about?

[serge-sans-paille]

Nits + rebase on main branch

[serge-sans-paille]

In D140800#4043723, @nikic wrote:

Just to check, this isn't going to cause some warning spew about all those OptTable implementations being non-final?

nope. Why would there be?

llvm/unittests/Option/OptionParsingTest.cpp

327

@nikic: the DISABLED_ prefix seems to be a gtest convention, see https://github.com/google/googletest/blob/main/docs/advanced.md#temporarily-disabling-tests

[nikic]

LGTM

In D140800#4044983, @serge-sans-paille wrote:

In D140800#4043723, @nikic wrote:

Just to check, this isn't going to cause some warning spew about all those OptTable implementations being non-final?

nope. Why would there be?

Something about missing virtual destructors on a non-final class? Not sure when exactly that warning applies.

llvm/unittests/Option/OptionParsingTest.cpp

327

Huh, TIL.

[thakis]

Thanks for this change :)

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

140

C

140

…not sure what this was, please ignore :)

llvm/include/llvm/Option/OptTable.h

257

(nit, kind of too late now: I would've renamed the base class to BaseOptTable or what and kept OptTable for this one, so that all the tools wouldn't have to be touched at all.)

clang/lib/Driver/DriverOptions.cpp

 
 #define PREFIX(NAME, VALUE)                                                    \
   static constexpr llvm::StringLiteral NAME##_init[] = VALUE;                  \
   static constexpr llvm::ArrayRef<llvm::StringLiteral> NAME(                   \
       NAME##_init, std::size(NAME##_init) - 1);
 #include "clang/Driver/Options.inc"
 #undef PREFIX
 
+static constexpr const llvm::StringLiteral PrefixTable_init[] =
+#define PREFIX_UNION(VALUES) VALUES
+#include "clang/Driver/Options.inc"
+#undef PREFIX_UNION
+    ;
+static constexpr const llvm::ArrayRef<llvm::StringLiteral>
+    PrefixTable(PrefixTable_init, std::size(PrefixTable_init) - 1);
+
 static constexpr OptTable::Info InfoTable[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   {PREFIX, NAME,  HELPTEXT,    METAVAR,     OPT_##ID,  Option::KIND##Class,    \
    PARAM,  FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS, VALUES},
 #include "clang/Driver/Options.inc"
 #undef OPTION
 };
 
 namespace {
 
-class DriverOptTable : public OptTable {
+class DriverOptTable : public PrecomputedOptTable {
 public:
-  DriverOptTable()
-    : OptTable(InfoTable) {}
+  DriverOptTable() : PrecomputedOptTable(InfoTable, PrefixTable) {}
 };
-
 }
 
 const llvm::opt::OptTable &clang::driver::getDriverOptTable() {
   static DriverOptTable Table;
   return Table;
 }

clang/lib/Driver/ToolChains/Gnu.cpp

 #include "Linux.h"
 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include <system_error>
 

clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp

 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   {PREFIX, NAME,  HELPTEXT,    METAVAR,     OPT_##ID,  Option::KIND##Class,    \
    PARAM,  FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS, VALUES},
 #include "LinkerWrapperOpts.inc"
 #undef OPTION
 };
 
-class WrapperOptTable : public opt::OptTable {
+class WrapperOptTable : public opt::GenericOptTable {
 public:
-  WrapperOptTable() : OptTable(InfoTable) {}
+  WrapperOptTable() : opt::GenericOptTable(InfoTable) {}
 };
 
 const OptTable &getOptTable() {
   static const WrapperOptTable *Table = []() {
     auto Result = std::make_unique<WrapperOptTable>();
     return Result.release();
   }();
   return *Table;

lld/COFF/Driver.h

 namespace lld::coff {
 
 extern std::unique_ptr<class LinkerDriver> driver;
 
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using std::optional;
 
-class COFFOptTable : public llvm::opt::OptTable {
+class COFFOptTable : public llvm::opt::GenericOptTable {
 public:
   COFFOptTable();
 };
 
 // Constructing the option table is expensive. Use a global table to avoid doing
 // it more than once.
 extern COFFOptTable optTable;
 

lld/COFF/DriverUtils.cpp

 static constexpr llvm::opt::OptTable::Info infoTable[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, llvm::opt::Option::KIND##Class, \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
-COFFOptTable::COFFOptTable() : OptTable(infoTable, true) {}
+COFFOptTable::COFFOptTable() : GenericOptTable(infoTable, true) {}
 
 COFFOptTable optTable;
 
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);

lld/ELF/Driver.h

 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/ArgList.h"
 #include <optional>
 
 namespace lld::elf {
 // Parses command line options.
-class ELFOptTable : public llvm::opt::OptTable {
+class ELFOptTable : public llvm::opt::GenericOptTable {
 public:
   ELFOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
 };
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,

lld/ELF/DriverUtils.cpp

 static constexpr opt::OptTable::Info optInfo[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
-ELFOptTable::ELFOptTable() : OptTable(optInfo) {}
+ELFOptTable::ELFOptTable() : GenericOptTable(optInfo) {}
 
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics);
   if (!arg)
     return;
   StringRef s = arg->getValue();

lld/MachO/Driver.h

 #include <set>
 #include <type_traits>
 
 namespace lld::macho {
 
 class DylibFile;
 class InputFile;
 
-class MachOOptTable : public llvm::opt::OptTable {
+class MachOOptTable : public llvm::opt::GenericOptTable {
 public:
   MachOOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
   void printHelp(const char *argv0, bool showHidden) const;
 };
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {

lld/MachO/DriverUtils.cpp

 static constexpr OptTable::Info optInfo[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, Option::KIND##Class,            \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
-MachOOptTable::MachOOptTable() : OptTable(optInfo) {}
+MachOOptTable::MachOOptTable() : GenericOptTable(optInfo) {}
 
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(InputArgList &args) {
   const Arg *arg =
       args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                       OPT_no_color_diagnostics);
   if (!arg)

lld/MinGW/Driver.cpp

 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
 namespace {
-class MinGWOptTable : public opt::OptTable {
+class MinGWOptTable : public opt::GenericOptTable {
 public:
-  MinGWOptTable() : OptTable(infoTable, false) {}
+  MinGWOptTable() : opt::GenericOptTable(infoTable, false) {}
   opt::InputArgList parse(ArrayRef<const char *> argv);
 };
 } // namespace
 
 static void printHelp(const char *argv0) {
   MinGWOptTable().printHelp(
       lld::outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
       false /*ShowHidden*/, true /*ShowAllAliases*/);

lld/wasm/Driver.cpp

 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
 namespace {
-class WasmOptTable : public llvm::opt::OptTable {
+class WasmOptTable : public opt::GenericOptTable {
 public:
-  WasmOptTable() : OptTable(optInfo) {}
+  WasmOptTable() : opt::GenericOptTable(optInfo) {}
   opt::InputArgList parse(ArrayRef<const char *> argv);
 };
 } // namespace
 
 // Set color diagnostics according to -color-diagnostics={auto,always,never}
 // or -no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,

lldb/tools/driver/Driver.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Options.inc"
 #undef OPTION
 };
 
-class LLDBOptTable : public opt::OptTable {
+class LLDBOptTable : public opt::GenericOptTable {
 public:
-  LLDBOptTable() : OptTable(InfoTable) {}
+  LLDBOptTable() : opt::GenericOptTable(InfoTable) {}
 };
 } // namespace
 
 static void reset_stdin_termios();
 static bool g_old_stdin_termios_is_valid = false;
 static struct termios g_old_stdin_termios;
 
 static bool disable_color(const raw_ostream &OS) { return false; }

lldb/tools/lldb-server/lldb-gdbserver.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "LLGSOptions.inc"
 #undef OPTION
 };
 
-class LLGSOptTable : public opt::OptTable {
+class LLGSOptTable : public opt::GenericOptTable {
 public:
-  LLGSOptTable() : OptTable(InfoTable) {}
+  LLGSOptTable() : opt::GenericOptTable(InfoTable) {}
 
   void PrintHelp(llvm::StringRef Name) {
     std::string Usage =
         (Name + " [options] [[host]:port] [[--] program args...]").str();
     OptTable::printHelp(llvm::outs(), Usage.c_str(), "lldb-server");
     llvm::outs() << R"(
 DESCRIPTION
   lldb-server connects to the LLDB client, which drives the debugging session.

lldb/tools/lldb-vscode/lldb-vscode.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   {PREFIX,      NAME,      HELPTEXT,                                           \
    METAVAR,     OPT_##ID,  llvm::opt::Option::KIND##Class,                     \
    PARAM,       FLAGS,     OPT_##GROUP,                                        \
    OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Options.inc"
 #undef OPTION
 };
-class LLDBVSCodeOptTable : public llvm::opt::OptTable {
+class LLDBVSCodeOptTable : public llvm::opt::GenericOptTable {
 public:
-  LLDBVSCodeOptTable() : OptTable(InfoTable, true) {}
+  LLDBVSCodeOptTable() : llvm::opt::GenericOptTable(InfoTable, true) {}
 };
 
 typedef void (*RequestCallback)(const llvm::json::Object &command);
 
 enum LaunchMethod { Launch, Attach, AttachForSuspendedLaunch };
 
 lldb::SBValueList *GetTopLevelScope(int64_t variablesReference) {
   switch (variablesReference) {

llvm/include/llvm/Option/OptTable.h

 //===- OptTable.h - Option Table --------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OPTION_OPTTABLE_H
 #define LLVM_OPTION_OPTTABLE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/Option/OptSpecifier.h"
 #include "llvm/Support/StringSaver.h"
 #include <cassert>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
private:
   ArrayRef<Info> OptionInfos;
   bool IgnoreCase;
   bool GroupedShortOptions = false;
   const char *EnvVar = nullptr;
 
   unsigned InputOptionID = 0;
   unsigned UnknownOptionID = 0;
 
+protected:
   /// The index of the first option which can be parsed (i.e., is not a
   /// special option like 'input' or 'unknown', and is not an option group).
   unsigned FirstSearchableIndex = 0;
 
+  /// The union of the first element of all option prefixes.
+  SmallString<8> PrefixChars;
+
   /// The union of all option prefixes. If an argument does not begin with
   /// one of these, it is an input.
-  StringSet<> PrefixesUnion;
-  SmallString<8> PrefixChars;
+  virtual ArrayRef<StringLiteral> getPrefixesUnion() const = 0;
 
 private:
   const Info &getInfo(OptSpecifier Opt) const {
     unsigned id = Opt.getID();
     assert(id > 0 && id - 1 < getNumOptions() && "Invalid Option ID.");
     return OptionInfos[id - 1];
   }
 
   std::unique_ptr<Arg> parseOneArgGrouped(InputArgList &Args,
                                           unsigned &Index) const;
 
 protected:
+  /// Initialize OptTable using Tablegen'ed OptionInfos. Child class must
+  /// manually call \c buildPrefixChars once they are fully constructed.
   OptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase = false);
 
+  /// Build (or rebuild) the PrefixChars member.
+  void buildPrefixChars();
+
 public:
-  ~OptTable();
+  virtual ~OptTable();
 
   /// Return the total number of option classes.
   unsigned getNumOptions() const { return OptionInfos.size(); }
 
   /// Get the given Opt's Option instance, lazily creating it
   /// if necessary.
   ///
   /// \return The option, or null for the INVALID option id.
public:
   void printHelp(raw_ostream &OS, const char *Usage, const char *Title,
                  unsigned FlagsToInclude, unsigned FlagsToExclude,
                  bool ShowAllAliases) const;
 
   void printHelp(raw_ostream &OS, const char *Usage, const char *Title,
                  bool ShowHidden = false, bool ShowAllAliases = false) const;
 };
 
+/// Specialization of
+class GenericOptTable : public OptTable {
+  SmallVector<StringLiteral> PrefixesUnionBuffer;
+
+protected:
+  GenericOptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase = false);
+  ArrayRef<StringLiteral> getPrefixesUnion() const final {
+    return PrefixesUnionBuffer;
+  }
+};
+
+class PrecomputedOptTable : public OptTable {
+  ArrayRef<StringLiteral> PrefixesUnion;
+
+protected:
+  PrecomputedOptTable(ArrayRef<Info> OptionInfos,
+                      ArrayRef<StringLiteral> PrefixesTable,
+                      bool IgnoreCase = false)
+      : OptTable(OptionInfos, IgnoreCase), PrefixesUnion(PrefixesTable) {
+    buildPrefixChars();
+  }
+  ArrayRef<StringLiteral> getPrefixesUnion() const final {
+    return PrefixesUnion;
+  }
+};
+
 } // end namespace opt
 
 } // end namespace llvm
 
 #endif // LLVM_OPTION_OPTTABLE_H

llvm/lib/ExecutionEngine/JITLink/COFFDirectiveParser.cpp

 // Create prefix string literals used in Options.td
 #define PREFIX(NAME, VALUE)                                                    \
   static constexpr StringLiteral NAME##_init[] = VALUE;                        \
   static constexpr ArrayRef<StringLiteral> NAME(NAME##_init,                   \
                                                 std::size(NAME##_init) - 1);
 #include "COFFOptions.inc"
 #undef PREFIX
 
+static constexpr const StringLiteral PrefixTable_init[] =
+#define PREFIX_UNION(VALUES) VALUES
+#include "COFFOptions.inc"
+#undef PREFIX_UNION
+    ;
+static constexpr const ArrayRef<StringLiteral>
+    PrefixTable(PrefixTable_init, std::size(PrefixTable_init) - 1);
+
 // Create table mapping all options defined in COFFOptions.td
 static constexpr opt::OptTable::Info infoTable[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1,                                                                         \
    X2,                                                                         \
    X10,                                                                        \
    X11,                                                                        \
    COFF_OPT_##ID,                                                              \
    opt::Option::KIND##Class,                                                   \
    X9,                                                                         \
    X8,                                                                         \
    COFF_OPT_##GROUP,                                                           \
    COFF_OPT_##ALIAS,                                                           \
    X7,                                                                         \
    X12},
 #include "COFFOptions.inc"
 #undef OPTION
 };
 
-class COFFOptTable : public opt::OptTable {
+class COFFOptTable : public opt::PrecomputedOptTable {
 public:
-  COFFOptTable() : OptTable(infoTable, true) {}
+  COFFOptTable() : PrecomputedOptTable(infoTable, PrefixTable, true) {}
 };
 
 static COFFOptTable optTable;
 
 Expected<opt::InputArgList> COFFDirectiveParser::parse(StringRef Str) {
   SmallVector<StringRef, 16> Tokens;
   SmallVector<const char *, 16> Buffer;
   cl::TokenizeWindowsCommandLineNoCopy(Str, saver, Tokens);

llvm/lib/Option/OptTable.cpp

 //===- OptTable.cpp - Option Table Implementation -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Option/OptTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSet.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptSpecifier.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h" // for expandResponseFiles
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <cstring>
 #include <map>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::opt;
 
 namespace llvm {
#ifndef NDEBUG
   for (unsigned i = FirstSearchableIndex + 1, e = getNumOptions(); i != e; ++i){
     if (!(getInfo(i) < getInfo(i + 1))) {
       getOption(i).dump();
       getOption(i + 1).dump();
       llvm_unreachable("Options are not in order!");
     }
   }
 #endif
-
-  // Build prefixes.
-  for (unsigned i = FirstSearchableIndex + 1, e = getNumOptions() + 1;
-                i != e; ++i) {
-    const auto &P = getInfo(i).Prefixes;
-    PrefixesUnion.insert(P.begin(), P.end());
-  }
 
+void OptTable::buildPrefixChars() {
+  assert(PrefixChars.empty() && "rebuilding a non-empty prefix char");
+
   // Build prefix chars.
-  for (const StringRef &Prefix : PrefixesUnion.keys()) {
+  for (const StringLiteral &Prefix : getPrefixesUnion()) {
     for (char C : Prefix)
       if (!is_contained(PrefixChars, C))
         PrefixChars.push_back(C);
   }
 }
 
 OptTable::~OptTable() = default;
 
 const Option OptTable::getOption(OptSpecifier Opt) const {
   unsigned id = Opt.getID();
   if (id == 0)
     return Option(nullptr, nullptr);
   assert((unsigned) (id - 1) < getNumOptions() && "Invalid ID.");
   return Option(&getInfo(id), this);
 }
 
-static bool isInput(const StringSet<> &Prefixes, StringRef Arg) {
+static bool isInput(const ArrayRef<StringLiteral> &Prefixes, StringRef Arg) {
   if (Arg == "-")
     return true;
-  for (const StringRef &Prefix : Prefixes.keys())
+  for (const StringRef &Prefix : Prefixes)
     if (Arg.startswith(Prefix))
       return false;
   return true;
 }
 
 /// \returns Matched size. 0 means no match.
 static unsigned matchOption(const OptTable::Info *I, StringRef Str,
                             bool IgnoreCase) {

 unsigned OptTable::findNearest(StringRef Option, std::string &NearestString,
                                unsigned FlagsToInclude, unsigned FlagsToExclude,
                                unsigned MinimumLength) const {
   assert(!Option.empty());
 
   // Consider each [option prefix + option name] pair as a candidate, finding
   // the closest match.
   unsigned BestDistance = UINT_MAX;
+  SmallString<16> Candidate;
+  SmallString<16> NormalizedName;
+
   for (const Info &CandidateInfo :
        ArrayRef<Info>(OptionInfos).drop_front(FirstSearchableIndex)) {
     StringRef CandidateName = CandidateInfo.Name;
 
     // We can eliminate some option prefix/name pairs as candidates right away:
     // * Ignore option candidates with empty names, such as "--", or names
     //   that do not meet the minimum length.
-    if (CandidateName.empty() || CandidateName.size() < MinimumLength)
+    if (CandidateName.size() < MinimumLength)
       continue;
 
     // * If FlagsToInclude were specified, ignore options that don't include
     //   those flags.
     if (FlagsToInclude && !(CandidateInfo.Flags & FlagsToInclude))
       continue;
     // * Ignore options that contain the FlagsToExclude.
     if (CandidateInfo.Flags & FlagsToExclude)
       continue;
 
     // * Ignore positional argument option candidates (which do not
     //   have prefixes).
     if (CandidateInfo.Prefixes.empty())
       continue;
 
     // Now check if the candidate ends with a character commonly used when
     // delimiting an option from its value, such as '=' or ':'. If it does,
     // attempt to split the given option based on that delimiter.
-    StringRef LHS, RHS;
     char Last = CandidateName.back();
     bool CandidateHasDelimiter = Last == '=' || Last == ':';
-    std::string NormalizedName = std::string(Option);
+    StringRef RHS;
     if (CandidateHasDelimiter) {
-      std::tie(LHS, RHS) = Option.split(Last);
-      NormalizedName = std::string(LHS);
-      if (Option.find(Last) == LHS.size())
+      std::tie(NormalizedName, RHS) = Option.split(Last);
+      if (Option.find(Last) == NormalizedName.size())
         NormalizedName += Last;
-    }
+    } else
+      NormalizedName = Option;
 
     // Consider each possible prefix for each candidate to find the most
     // appropriate one. For example, if a user asks for "--helm", suggest
     // "--help" over "-help".
     for (auto CandidatePrefix : CandidateInfo.Prefixes) {
-      std::string Candidate = (CandidatePrefix + CandidateName).str();
-      StringRef CandidateRef = Candidate;
-      unsigned Distance =
-          CandidateRef.edit_distance(NormalizedName, /*AllowReplacements=*/true,
-                                     /*MaxEditDistance=*/BestDistance);
+      Candidate = CandidatePrefix;
+      Candidate += CandidateName;
+      unsigned Distance = StringRef(Candidate).edit_distance(
+          NormalizedName, /*AllowReplacements=*/true,
       if (RHS.empty() && CandidateHasDelimiter) {
         // The Candidate ends with a = or : delimiter, but the option passed in
         // didn't contain the delimiter (or doesn't have anything after it).
         // In that case, penalize the correction: `-nodefaultlibs` is more
         // likely to be a spello for `-nodefaultlib` than `-nodefaultlib:` even
         // though both have an unmodified editing distance of 1, since the
         // latter would need an argument.
         ++Distance;

 // be updated to "-bc". This overload does not support
 // FlagsToInclude/FlagsToExclude or case insensitive options.
 std::unique_ptr<Arg> OptTable::parseOneArgGrouped(InputArgList &Args,
                                                   unsigned &Index) const {
   // Anything that doesn't start with PrefixesUnion is an input, as is '-'
   // itself.
   const char *CStr = Args.getArgString(Index);
   StringRef Str(CStr);
-  if (isInput(PrefixesUnion, Str))
+  if (isInput(getPrefixesUnion(), Str))
     return std::make_unique<Arg>(getOption(InputOptionID), Str, Index++, CStr);
 
   const Info *End = OptionInfos.data() + OptionInfos.size();
   StringRef Name = Str.ltrim(PrefixChars);
   const Info *Start =
       std::lower_bound(OptionInfos.data() + FirstSearchableIndex, End, Name);
   const Info *Fallback = nullptr;
   unsigned Prev = Index;

 std::unique_ptr<Arg> OptTable::ParseOneArg(const ArgList &Args, unsigned &Index,
                                            unsigned FlagsToInclude,
                                            unsigned FlagsToExclude) const {
   unsigned Prev = Index;
   StringRef Str = Args.getArgString(Index);
 
   // Anything that doesn't start with PrefixesUnion is an input, as is '-'
   // itself.
-  if (isInput(PrefixesUnion, Str))
+  if (isInput(getPrefixesUnion(), Str))
     return std::make_unique<Arg>(getOption(InputOptionID), Str, Index++,
                                  Str.data());
 
   const Info *Start = OptionInfos.data() + FirstSearchableIndex;
   const Info *End = OptionInfos.data() + OptionInfos.size();
   StringRef Name = Str.ltrim(PrefixChars);
 
   // Search for the first next option which could be a prefix.
void OptTable::printHelp(raw_ostream &OS, const char *Usage, const char *Title,
   for (auto& OptionGroup : GroupedOptionHelp) {
     if (OptionGroup.first != GroupedOptionHelp.begin()->first)
       OS << "\n";
     PrintHelpOptionList(OS, OptionGroup.first, OptionGroup.second);
   }
 
   OS.flush();
 }
+
+GenericOptTable::GenericOptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase)
+    : OptTable(OptionInfos, IgnoreCase) {
+
+  std::set<StringLiteral> TmpPrefixesUnion;
+  for (auto const &Info : OptionInfos.drop_front(FirstSearchableIndex))
+    TmpPrefixesUnion.insert(Info.Prefixes.begin(), Info.Prefixes.end());
+  PrefixesUnionBuffer.append(TmpPrefixesUnion.begin(), TmpPrefixesUnion.end());
+  buildPrefixChars();
+}

llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

 static constexpr opt::OptTable::Info InfoTable[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, llvm::opt::Option::KIND##Class, \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
-class DllOptTable : public llvm::opt::OptTable {
+class DllOptTable : public opt::GenericOptTable {
 public:
-  DllOptTable() : OptTable(InfoTable, false) {}
+  DllOptTable() : opt::GenericOptTable(InfoTable, false) {}
 };
 
 // Opens a file. Path has to be resolved already.
 std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
   ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = MemoryBuffer::getFile(Path);
 
   if (std::error_code EC = MB.getError()) {
     llvm::errs() << "cannot open file " << Path << ": " << EC.message() << "\n";

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

 static constexpr opt::OptTable::Info InfoTable[] = {
 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
-class LibOptTable : public opt::OptTable {
+class LibOptTable : public opt::GenericOptTable {
 public:
-  LibOptTable() : OptTable(InfoTable, true) {}
+  LibOptTable() : opt::GenericOptTable(InfoTable, true) {}
 };
-
 }
 
 static std::string getDefaultOutputPath(const NewArchiveMember &FirstMember) {
   SmallString<128> Val = StringRef(FirstMember.Buf->getBufferIdentifier());
   sys::path::replace_extension(Val, ".lib");
   return std::string(Val.str());
 }
 

llvm/tools/dsymutil/dsymutil.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Options.inc"
 #undef OPTION
 };
 
-class DsymutilOptTable : public opt::OptTable {
+class DsymutilOptTable : public opt::GenericOptTable {
 public:
-  DsymutilOptTable() : OptTable(InfoTable) {}
+  DsymutilOptTable() : opt::GenericOptTable(InfoTable) {}
 };
 } // namespace
 
 enum class DWARFVerify : uint8_t {
   None = 0,
   Input = 1 << 0,
   Output = 1 << 1,
   All = Input | Output,

llvm/tools/llvm-cvtres/llvm-cvtres.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class CvtResOptTable : public opt::OptTable {
+class CvtResOptTable : public opt::GenericOptTable {
 public:
-  CvtResOptTable() : OptTable(InfoTable, true) {}
+  CvtResOptTable() : opt::GenericOptTable(InfoTable, true) {}
 };
 }
 
 [[noreturn]] static void reportError(Twine Msg) {
   errs() << Msg;
   exit(1);
 }
 

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class CxxfiltOptTable : public opt::OptTable {
+class CxxfiltOptTable : public opt::GenericOptTable {
 public:
-  CxxfiltOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  CxxfiltOptTable() : opt::GenericOptTable(InfoTable) {
+    setGroupedShortOptions(true);
+  }
 };
 } // namespace
 
 static bool StripUnderscore;
 static bool Types;
 
 static StringRef ToolName;
 

llvm/tools/llvm-dwarfutil/llvm-dwarfutil.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Options.inc"
 #undef OPTION
 };
 
-class DwarfutilOptTable : public opt::OptTable {
+class DwarfutilOptTable : public opt::GenericOptTable {
 public:
-  DwarfutilOptTable() : OptTable(InfoTable) {}
+  DwarfutilOptTable() : opt::GenericOptTable(InfoTable) {}
 };
 } // namespace
 
 namespace llvm {
 namespace dwarfutil {
 
 std::string ToolName;
 

llvm/tools/llvm-ifs/llvm-ifs.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class IFSOptTable : public opt::OptTable {
+class IFSOptTable : public opt::GenericOptTable {
 public:
-  IFSOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  IFSOptTable() : opt::GenericOptTable(InfoTable) {
+    setGroupedShortOptions(true);
+  }
 };
 
 struct DriverConfig {
   std::vector<std::string> InputFilePaths;
 
   std::optional<FileFormat> InputFormat;
   std::optional<FileFormat> OutputFormat;
 

llvm/tools/llvm-lipo/llvm-lipo.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    METAVAR,      LIPO_##ID, opt::Option::KIND##Class,                          \
    PARAM,        FLAGS,     LIPO_##GROUP,                                      \
    LIPO_##ALIAS, ALIASARGS, VALUES},
 #include "LipoOpts.inc"
 #undef OPTION
 };
 } // namespace lipo
 
-class LipoOptTable : public opt::OptTable {
+class LipoOptTable : public opt::GenericOptTable {
 public:
-  LipoOptTable() : OptTable(lipo::LipoInfoTable) {}
+  LipoOptTable() : opt::GenericOptTable(lipo::LipoInfoTable) {}
 };
 
 enum class LipoAction {
   PrintArchs,
   PrintInfo,
   VerifyArch,
   ThinArch,
   ExtractArch,

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

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       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 {
+class MLOptTable : public opt::GenericOptTable {
 public:
-  MLOptTable() : OptTable(InfoTable, /*IgnoreCase=*/false) {}
+  MLOptTable() : opt::GenericOptTable(InfoTable, /*IgnoreCase=*/false) {}
 };
 } // namespace
 
 static Triple GetTriple(StringRef ProgName, opt::InputArgList &Args) {
   // Figure out the target triple.
   StringRef DefaultBitness = "32";
   SmallString<255> Program = ProgName;
   sys::path::replace_extension(Program, "");

llvm/tools/llvm-mt/llvm-mt.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class CvtResOptTable : public opt::OptTable {
+class CvtResOptTable : public opt::GenericOptTable {
 public:
-  CvtResOptTable() : OptTable(InfoTable, true) {}
+  CvtResOptTable() : opt::GenericOptTable(InfoTable, true) {}
 };
 } // namespace
 
 [[noreturn]] static void reportError(Twine Msg) {
   WithColor::error(errs(), "llvm-mt") << Msg << '\n';
   exit(1);
 }
 

llvm/tools/llvm-nm/llvm-nm.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class NmOptTable : public opt::OptTable {
+class NmOptTable : public opt::GenericOptTable {
 public:
-  NmOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  NmOptTable() : opt::GenericOptTable(InfoTable) {
+    setGroupedShortOptions(true);
+  }
 };
 
 enum OutputFormatTy { bsd, sysv, posix, darwin, just_symbols };
 enum class BitModeTy { Bit32, Bit64, Bit32_64, Any };
 } // namespace
 
 static bool ArchiveMap;
 static BitModeTy BitMode;

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    METAVAR,         OBJCOPY_##ID, opt::Option::KIND##Class,                    \
    PARAM,           FLAGS,        OBJCOPY_##GROUP,                             \
    OBJCOPY_##ALIAS, ALIASARGS,    VALUES},
 #include "ObjcopyOpts.inc"
 #undef OPTION
 };
 } // namespace objcopy_opt
 
-class ObjcopyOptTable : public opt::OptTable {
+class ObjcopyOptTable : public opt::GenericOptTable {
 public:
-  ObjcopyOptTable() : OptTable(objcopy_opt::ObjcopyInfoTable) {
+  ObjcopyOptTable() : opt::GenericOptTable(objcopy_opt::ObjcopyInfoTable) {
     setGroupedShortOptions(true);
   }
 };
 
 enum InstallNameToolID {
   INSTALL_NAME_TOOL_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    INSTALL_NAME_TOOL_##ALIAS,                                                  \
    ALIASARGS,                                                                  \
    VALUES},
 #include "InstallNameToolOpts.inc"
 #undef OPTION
 };
 } // namespace install_name_tool
 
-class InstallNameToolOptTable : public opt::OptTable {
+class InstallNameToolOptTable : public opt::GenericOptTable {
 public:
   InstallNameToolOptTable()
-      : OptTable(install_name_tool::InstallNameToolInfoTable) {}
+      : GenericOptTable(install_name_tool::InstallNameToolInfoTable) {}
 };
 
 enum BitcodeStripID {
   BITCODE_STRIP_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   BITCODE_STRIP_##ID,
 #include "BitcodeStripOpts.inc"
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    BITCODE_STRIP_##ALIAS,                                                      \
    ALIASARGS,                                                                  \
    VALUES},
 #include "BitcodeStripOpts.inc"
 #undef OPTION
 };
 } // namespace bitcode_strip
 
-class BitcodeStripOptTable : public opt::OptTable {
+class BitcodeStripOptTable : public opt::GenericOptTable {
 public:
-  BitcodeStripOptTable() : OptTable(bitcode_strip::BitcodeStripInfoTable) {}
+  BitcodeStripOptTable()
+      : opt::GenericOptTable(bitcode_strip::BitcodeStripInfoTable) {}
 };
 
 enum StripID {
   STRIP_INVALID = 0, // This is not an option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   STRIP_##ID,
 #include "StripOpts.inc"
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    METAVAR,       STRIP_##ID, opt::Option::KIND##Class,                        \
    PARAM,         FLAGS,      STRIP_##GROUP,                                   \
    STRIP_##ALIAS, ALIASARGS,  VALUES},
 #include "StripOpts.inc"
 #undef OPTION
 };
 } // namespace strip
 
-class StripOptTable : public opt::OptTable {
+class StripOptTable : public opt::GenericOptTable {
 public:
-  StripOptTable() : OptTable(strip::StripInfoTable) {
+  StripOptTable() : GenericOptTable(strip::StripInfoTable) {
     setGroupedShortOptions(true);
   }
 };
 
 } // namespace
 
 static SectionFlag parseSectionRenameFlag(StringRef SectionName) {
   return llvm::StringSwitch<SectionFlag>(SectionName)

llvm/tools/llvm-objdump/llvm-objdump.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::objdump;
 using namespace llvm::opt;
 
 namespace {
 
-class CommonOptTable : public opt::OptTable {
+class CommonOptTable : public opt::GenericOptTable {
 public:
   CommonOptTable(ArrayRef<Info> OptionInfos, const char *Usage,
                  const char *Description)
-      : OptTable(OptionInfos), Usage(Usage), Description(Description) {
+      : opt::GenericOptTable(OptionInfos), Usage(Usage),
+        Description(Description) {
     setGroupedShortOptions(true);
   }
 
   void printHelp(StringRef Argv0, bool ShowHidden = false) const {
     Argv0 = sys::path::filename(Argv0);
-    opt::OptTable::printHelp(outs(), (Argv0 + Usage).str().c_str(), Description,
-                             ShowHidden, ShowHidden);
+    opt::GenericOptTable::printHelp(outs(), (Argv0 + Usage).str().c_str(),
+                                    Description, ShowHidden, ShowHidden);
     // TODO Replace this with OptTable API once it adds extrahelp support.
     outs() << "\nPass @FILE as argument to read options from FILE.\n";
   }
 
 private:
   const char *Usage;
   const char *Description;
 };

llvm/tools/llvm-rc/llvm-rc.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 } // namespace rc_opt
 
-class RcOptTable : public opt::OptTable {
+class RcOptTable : public opt::GenericOptTable {
 public:
-  RcOptTable() : OptTable(rc_opt::InfoTable, /* IgnoreCase = */ true) {}
+  RcOptTable() : GenericOptTable(rc_opt::InfoTable, /* IgnoreCase = */ true) {}
 };
 
 enum Windres_ID {
   WINDRES_INVALID = 0, // This is not a correct option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   WINDRES_##ID,
 #include "WindresOpts.inc"
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
    METAVAR,         WINDRES_##ID, opt::Option::KIND##Class,                    \
    PARAM,           FLAGS,        WINDRES_##GROUP,                             \
    WINDRES_##ALIAS, ALIASARGS,    VALUES},
 #include "WindresOpts.inc"
 #undef OPTION
 };
 } // namespace windres_opt
 
-class WindresOptTable : public opt::OptTable {
+class WindresOptTable : public opt::GenericOptTable {
 public:
   WindresOptTable()
-      : OptTable(windres_opt::InfoTable, /* IgnoreCase = */ false) {}
+      : GenericOptTable(windres_opt::InfoTable, /* IgnoreCase = */ false) {}
 };
 
 static ExitOnError ExitOnErr;
 static FileRemover TempPreprocFile;
 static FileRemover TempResFile;
 
 [[noreturn]] static void fatalError(const Twine &Message) {
   errs() << Message << "\n";

llvm/tools/llvm-readobj/llvm-readobj.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class ReadobjOptTable : public opt::OptTable {
+class ReadobjOptTable : public opt::GenericOptTable {
 public:
-  ReadobjOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  ReadobjOptTable() : opt::GenericOptTable(InfoTable) {
+    setGroupedShortOptions(true);
+  }
 };
 
 enum OutputFormatTy { bsd, sysv, posix, darwin, just_symbols };
 
 enum SortSymbolKeyTy {
   NAME = 0,
   TYPE = 1,
   UNKNOWN = 100,

llvm/tools/llvm-size/llvm-size.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class SizeOptTable : public opt::OptTable {
+class SizeOptTable : public opt::GenericOptTable {
 public:
-  SizeOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  SizeOptTable() : GenericOptTable(InfoTable) { setGroupedShortOptions(true); }
 };
 
 enum OutputFormatTy { berkeley, sysv, darwin };
 enum RadixTy { octal = 8, decimal = 10, hexadecimal = 16 };
 } // namespace
 
 static bool ArchAll = false;
 static std::vector<StringRef> ArchFlags;

llvm/tools/llvm-strings/llvm-strings.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class StringsOptTable : public opt::OptTable {
+class StringsOptTable : public opt::GenericOptTable {
 public:
-  StringsOptTable() : OptTable(InfoTable) { setGroupedShortOptions(true); }
+  StringsOptTable() : GenericOptTable(InfoTable) {
+    setGroupedShortOptions(true);
+  }
 };
 } // namespace
 
 static StringRef ToolName;
 
 static cl::list<std::string> InputFileNames(cl::Positional,
                                             cl::desc("<input object files>"));
 

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class SymbolizerOptTable : public opt::OptTable {
+class SymbolizerOptTable : public opt::GenericOptTable {
 public:
-  SymbolizerOptTable() : OptTable(InfoTable) {
+  SymbolizerOptTable() : GenericOptTable(InfoTable) {
     setGroupedShortOptions(true);
   }
 };
 } // namespace
 
 template <typename T>
 static void print(const Request &Request, Expected<T> &ResOrErr,
                   DIPrinter &Printer) {

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
       PREFIX,      NAME,      HELPTEXT,                                        \
       METAVAR,     OPT_##ID,  opt::Option::KIND##Class,                        \
       PARAM,       FLAGS,     OPT_##GROUP,                                     \
       OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
-class TLICheckerOptTable : public opt::OptTable {
+class TLICheckerOptTable : public opt::GenericOptTable {
 public:
-  TLICheckerOptTable() : OptTable(InfoTable) {}
+  TLICheckerOptTable() : GenericOptTable(InfoTable) {}
 };
 } // end anonymous namespace
 
 // We have three levels of reporting.
 enum class ReportKind {
   Error,       // For argument parsing errors.
   Summary,     // Report counts but not details.
   Discrepancy, // Report where TLI and the library differ.

llvm/unittests/Option/OptionParsingTest.cpp

 
 #define PREFIX(NAME, VALUE)                                                    \
   static constexpr StringLiteral NAME##_init[] = VALUE;                        \
   static constexpr ArrayRef<StringLiteral> NAME(NAME##_init,                   \
                                                 std::size(NAME##_init) - 1);
 #include "Opts.inc"
 #undef PREFIX
 
+static constexpr const StringLiteral PrefixTable_init[] =
+#define PREFIX_UNION(VALUES) VALUES
+#include "Opts.inc"
+#undef PREFIX_UNION
+    ;
+static constexpr const ArrayRef<StringLiteral>
+    PrefixTable(PrefixTable_init, std::size(PrefixTable_init) - 1);
+
 enum OptionFlags {
   OptFlag1 = (1 << 4),
   OptFlag2 = (1 << 5),
   OptFlag3 = (1 << 6)
 };
 
 static constexpr OptTable::Info InfoTable[] = {
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
                HELPTEXT, METAVAR, VALUES)                                      \
   {PREFIX, NAME,  HELPTEXT,    METAVAR,     OPT_##ID,  Option::KIND##Class,    \
    PARAM,  FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS, VALUES},
 #include "Opts.inc"
 #undef OPTION
 };
 
 namespace {
-class TestOptTable : public OptTable {
+class TestOptTable : public GenericOptTable {
 public:
   TestOptTable(bool IgnoreCase = false)
-    : OptTable(InfoTable, IgnoreCase) {}
+      : GenericOptTable(InfoTable, IgnoreCase) {}
+};
+
+class TestPrecomputedOptTable : public PrecomputedOptTable {
+public:
+  TestPrecomputedOptTable(bool IgnoreCase = false)
+      : PrecomputedOptTable(InfoTable, PrefixTable, IgnoreCase) {}
 };
 }
 
 const char *Args[] = {
   "-A",
   "-Bhi",
   "--C=desu",
   "-C", "bye",
   "-D,adena",
   "-E", "apple", "bloom",
   "-Fblarg",
   "-F", "42",
   "-Gchuu", "2"
   };
 
-TEST(Option, OptionParsing) {
-  TestOptTable T;
+// Test fixture
+template <typename T> class OptTableTest : public ::testing::Test {};
+
+template <typename T> class DISABLED_OptTableTest : public ::testing::Test {};
+
+// Test both precomputed and computed OptTables with the same suite of tests.
+using OptTableTestTypes =
+    ::testing::Types<TestOptTable, TestPrecomputedOptTable>;
+
+TYPED_TEST_SUITE(OptTableTest, OptTableTestTypes, );
+TYPED_TEST_SUITE(DISABLED_OptTableTest, OptTableTestTypes, );
+
+TYPED_TEST(OptTableTest, OptionParsing) {
+  TypeParam T;
   unsigned MAI, MAC;
   InputArgList AL = T.ParseArgs(Args, MAI, MAC);
 
   // Check they all exist.
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_TRUE(AL.hasArg(OPT_C));
   EXPECT_TRUE(AL.hasArg(OPT_D));
TYPED_TEST(OptTableTest, OptionParsing) {
   EXPECT_EQ("desu", StringRef((*Cs.begin())->getValue()));
   ArgStringList ASL;
   (*Cs.begin())->render(AL, ASL);
   ASSERT_EQ(2u, ASL.size());
   EXPECT_EQ("-C", StringRef(ASL[0]));
   EXPECT_EQ("desu", StringRef(ASL[1]));
 }
 
-TEST(Option, ParseWithFlagExclusions) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, ParseWithFlagExclusions) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   // Exclude flag3 to avoid parsing as OPT_SLASH_C.
   InputArgList AL = T.ParseArgs(Args, MAI, MAC,
                                 /*FlagsToInclude=*/0,
                                 /*FlagsToExclude=*/OptFlag3);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_C));
TYPED_TEST(OptTableTest, ParseWithFlagExclusions) {
   const char *NewArgs[] = { "/C", "foo", "--C=bar" };
   AL = T.ParseArgs(NewArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
   EXPECT_TRUE(AL.hasArg(OPT_C));
   EXPECT_EQ("foo", AL.getLastArgValue(OPT_SLASH_C));
   EXPECT_EQ("bar", AL.getLastArgValue(OPT_C));
 }
 
-TEST(Option, ParseAliasInGroup) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, ParseAliasInGroup) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-I" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_H));
 }
 
-TEST(Option, AliasArgs) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, AliasArgs) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-J", "-Joo" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
 }
 
-TEST(Option, IgnoreCase) {
-  TestOptTable T(true);
+TYPED_TEST(OptTableTest, IgnoreCase) {
+  TypeParam T(true);
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-a", "-joo" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_B));
 }
 
-TEST(Option, DoNotIgnoreCase) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, DoNotIgnoreCase) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-a", "-joo" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_FALSE(AL.hasArg(OPT_A));
   EXPECT_FALSE(AL.hasArg(OPT_B));
 }
 
-TEST(Option, SlurpEmpty) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, SlurpEmpty) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurp" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
   EXPECT_EQ(0U, AL.getAllArgValues(OPT_Slurp).size());
 }
 
-TEST(Option, Slurp) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, Slurp) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_EQ(AL.size(), 2U);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_FALSE(AL.hasArg(OPT_B));
   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_Slurp).size());
   EXPECT_EQ("-B", AL.getAllArgValues(OPT_Slurp)[0]);
   EXPECT_EQ("--", AL.getAllArgValues(OPT_Slurp)[1]);
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_Slurp)[2]);
 }
 
-TEST(Option, SlurpJoinedEmpty) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, SlurpJoinedEmpty) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurpjoined" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 0U);
 }
 
-TEST(Option, SlurpJoinedOneJoined) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, SlurpJoinedOneJoined) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurpjoinedfoo" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 1U);
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined)[0], "foo");
 }
 
-TEST(Option, SlurpJoinedAndSeparate) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, SlurpJoinedAndSeparate) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurpjoinedfoo", "bar", "baz" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 }
 
-TEST(Option, SlurpJoinedButSeparate) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, SlurpJoinedButSeparate) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurpjoined", "foo", "bar", "baz" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 }
 
-TEST(Option, FlagAliasToJoined) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, FlagAliasToJoined) {
+  TypeParam T;
   unsigned MAI, MAC;
 
   // Check that a flag alias provides an empty argument to a joined option.
   const char *MyArgs[] = { "-K" };
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_EQ(AL.size(), 1U);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
   EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
 }
 
-TEST(Option, FindNearest) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, FindNearest) {
+  TypeParam T;
   std::string Nearest;
 
   // Options that are too short should not be considered
   // "near" other short options.
   EXPECT_GT(T.findNearest("-A", Nearest), 4U);
   EXPECT_GT(T.findNearest("/C", Nearest), 4U);
   EXPECT_GT(T.findNearest("--C=foo", Nearest), 4U);
 
TYPED_TEST(OptTableTest, FindNearest) {
   EXPECT_EQ(1U, T.findNearest("-doopf", Nearest, /*FlagsToInclude=*/OptFlag2));
   EXPECT_EQ(Nearest, "-doopf2");
   EXPECT_EQ(1U, T.findNearest("-doopf", Nearest,
                               /*FlagsToInclude=*/0,
                               /*FlagsToExclude=*/OptFlag2));
   EXPECT_EQ(Nearest, "-doopf1");
 }
 
-TEST(DISABLED_Option, FindNearestFIXME) {
-  TestOptTable T;
+TYPED_TEST(DISABLED_OptTableTest, FindNearestFIXME) {
+  TypeParam T;
   std::string Nearest;
 
   // FIXME: Options with joined values should not have those values considered
   // when calculating distance. The test below would fail if run, but it should
   // succeed.
   EXPECT_EQ(1U, T.findNearest("--erbghFoo", Nearest));
   EXPECT_EQ(Nearest, "--ermghFoo");
-
 }
 
-TEST(Option, ParseGroupedShortOptions) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, ParseGroupedShortOptions) {
+  TypeParam T;
   T.setGroupedShortOptions(true);
   unsigned MAI, MAC;
 
   // Grouped short options can be followed by a long Flag (-Joo), or a non-Flag
   // option (-C=1).
   const char *Args1[] = {"-AIJ", "-AIJoo", "-AC=1"};
   InputArgList AL = T.ParseArgs(Args1, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
TYPED_TEST(OptTableTest, ParseGroupedShortOptions) {
 
   // Short options followed by a long option. We probably should disallow this.
   const char *Args3[] = {"-AIblorp"};
   InputArgList AL3 = T.ParseArgs(Args3, MAI, MAC);
   EXPECT_TRUE(AL3.hasArg(OPT_A));
   EXPECT_TRUE(AL3.hasArg(OPT_Blorp));
 }
 
-TEST(Option, UnknownOptions) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, UnknownOptions) {
+  TypeParam T;
   unsigned MAI, MAC;
   const char *Args[] = {"-u", "--long", "0"};
   for (int I = 0; I < 2; ++I) {
     T.setGroupedShortOptions(I != 0);
     InputArgList AL = T.ParseArgs(Args, MAI, MAC);
     const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
     ASSERT_EQ((size_t)2, Unknown.size());
     EXPECT_EQ("-u", Unknown[0]);
     EXPECT_EQ("--long", Unknown[1]);
   }
 }
 
-TEST(Option, FlagsWithoutValues) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, FlagsWithoutValues) {
+  TypeParam T;
   T.setGroupedShortOptions(true);
   unsigned MAI, MAC;
   const char *Args[] = {"-A=1", "-A="};
   InputArgList AL = T.ParseArgs(Args, MAI, MAC);
   const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
   ASSERT_EQ((size_t)2, Unknown.size());
   EXPECT_EQ("-A=1", Unknown[0]);
   EXPECT_EQ("-A=", Unknown[1]);
 }
 
-TEST(Option, UnknownGroupedShortOptions) {
-  TestOptTable T;
+TYPED_TEST(OptTableTest, UnknownGroupedShortOptions) {
+  TypeParam T;
   T.setGroupedShortOptions(true);
   unsigned MAI, MAC;
   const char *Args[] = {"-AuzK", "-AuzK"};
   InputArgList AL = T.ParseArgs(Args, MAI, MAC);
   const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
   ASSERT_EQ((size_t)4, Unknown.size());
   EXPECT_EQ("-u", Unknown[0]);
   EXPECT_EQ("-z", Unknown[1]);
   EXPECT_EQ("-u", Unknown[2]);
   EXPECT_EQ("-z", Unknown[3]);
 }

llvm/utils/TableGen/OptParserEmitter.cpp

for (const Record &R : llvm::make_pointee_range(Opts)) {
     std::vector<StringRef> RPrefixes = R.getValueAsListOfStrings("Prefixes");
     PrefixKeyT PrefixKey(RPrefixes.begin(), RPrefixes.end());
     unsigned NewPrefix = CurPrefix + 1;
     std::string Prefix = (Twine("prefix_") + Twine(NewPrefix)).str();
     if (Prefixes.insert(std::make_pair(PrefixKey, Prefix)).second)
       CurPrefix = NewPrefix;
   }
 
-  // Dump prefixes.
+  DenseSet<StringRef> PrefixesUnionSet;
+  for (const auto &Prefix : Prefixes)
+    PrefixesUnionSet.insert(Prefix.first.begin(), Prefix.first.end());
+  SmallVector<StringRef> PrefixesUnion(PrefixesUnionSet.begin(),
+                                       PrefixesUnionSet.end());
+  array_pod_sort(PrefixesUnion.begin(), PrefixesUnion.end());
 
+  // Dump prefixes.
   OS << "/////////\n";
   OS << "// Prefixes\n\n";
   OS << "#ifdef PREFIX\n";
   OS << "#define COMMA ,\n";
   for (const auto &Prefix : Prefixes) {
     OS << "PREFIX(";
 
     // Prefix name.
     OS << Prefix.second;
 
     // Prefix values.
     OS << ", {";
     for (const auto &PrefixKey : Prefix.first)
       OS << "llvm::StringLiteral(\"" << PrefixKey << "\") COMMA ";
     // Append an empty element to avoid ending up with an empty array.
     OS << "llvm::StringLiteral(\"\")})\n";
   }
   OS << "#undef COMMA\n";
   OS << "#endif // PREFIX\n\n";
 
+  // Dump prefix unions.
+  OS << "/////////\n";
+  OS << "// Prefix Union\n\n";
+  OS << "#ifdef PREFIX_UNION\n";
+  OS << "#define COMMA ,\n";
+  OS << "PREFIX_UNION({\n";
+  for (const auto &Prefix : PrefixesUnion) {
+    OS << "llvm::StringLiteral(\"" << Prefix << "\") COMMA ";
+  }
+  OS << "llvm::StringLiteral(\"\")})\n";
+  OS << "#undef COMMA\n";
+  OS << "#endif // PREFIX_UNION\n\n";
+
+  // Dump groups.
   OS << "/////////\n";
   OS << "// ValuesCode\n\n";
   OS << "#ifdef OPTTABLE_VALUES_CODE\n";
   for (const Record &R : llvm::make_pointee_range(Opts)) {
     // The option values, if any;
     if (!isa<UnsetInit>(R.getValueInit("ValuesCode"))) {
       assert(!isa<UnsetInit>(R.getValueInit("Values")) &&
            "Cannot choose between Values and ValuesCode");