[llvm] Construct option's prefixed name at compile-time

[jansvoboda11]

Summary

Some Clang command-line handling code could benefit from the option's prefixed name being a StringLiteral. This patch changes the llvm::opt TableGen backend to generate and emit that into the .inc file.

Depends on D157028.

[jansvoboda11]

Rebase on top of D157028.

[benlangmuir]

llvm/include/llvm/Option/Option.h

103

This could use a doc comment to differentiate it from other string representations.

How does this compare with Arg::getSpelling? With Arg, IIUC the "spelling" is how it was actually written rather than a canonical form. That might be confusing if this one is canonical; so we should at least clearly document it or maybe put "canonical" in the API name?

[jansvoboda11]

Improve Option::getPrefixedName() instead of introducing new Option::getSpelling().

[jansvoboda11]

llvm/include/llvm/Option/Option.h

103

You're right Arg::getSpelling() is the as-written prefix and name, while Option::getSpelling() was the canonical prefix and name. I noticed there's also Option::getPrefixedName() which used to return std::string. I decided to reuse that and return StringLiteral instead. Thanks!

[MaskRay]

This increases the size of Info (static data size and static relocations). In return, some dynamic relocations are saved. Is this a net win?

[jansvoboda11]

In D157029#4561490, @MaskRay wrote:

This increases the size of Info (static data size and static relocations). In return, some dynamic relocations are saved. Is this a net win?

If that's a concern, I can remove Info::Name and replace its usages with a function call that drops the prefix from prefixed name.

[jansvoboda11]

Remove OptTable::Info::Name.

[jansvoboda11]

In D157029#4561519, @jansvoboda11 wrote:

In D157029#4561490, @MaskRay wrote:

This increases the size of Info (static data size and static relocations). In return, some dynamic relocations are saved. Is this a net win?

If that's a concern, I can remove Info::Name and replace its usages with a function call that drops the prefix from prefixed name.

Done.

[jansvoboda11]

Rebase.

[jansvoboda11]

Rebase, remove unnecessary changes

[MaskRay]

LG! LLVMOption has users in llvm/ clang/ lldb/ lld/ clang-tools-extra/ flang/. You'll need to check that all the affected users are migrated...

clang-tools-extra/clangd/CompileCommands.cpp

static TableTy *Table = [] {
     };
     // Also grab prefixes for each option, these are not fully exposed.
     llvm::ArrayRef<llvm::StringLiteral> Prefixes[DriverID::LastOption];
 
 #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);
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELP, METAVAR, VALUES)                                          \
+#define OPTION(PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
+               FLAGS, PARAM, HELP, METAVAR, VALUES)                            \
   Prefixes[DriverID::OPT_##ID] = PREFIX;
 #include "clang/Driver/Options.inc"
 #undef OPTION
 #undef PREFIX
 
     struct {
       DriverID ID;
       DriverID AliasID;
       const void *AliasArgs;
     } AliasTable[] = {
-#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-               HELP, METAVAR, VALUES)                                          \
+#define OPTION(PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
+               FLAGS, PARAM, HELP, METAVAR, VALUES)                            \
   {DriverID::OPT_##ID, DriverID::OPT_##ALIAS, ALIASARGS},
 #include "clang/Driver/Options.inc"
 #undef OPTION
     };
     for (auto &E : AliasTable)
       if (E.AliasID != DriverID::OPT_INVALID && E.AliasArgs == nullptr)
         AddAlias(E.ID, E.AliasID);
 

clang/lib/Driver/Driver.cpp

#if defined(CLANG_CONFIG_FILE_USER_DIR)
   }
 #endif
 
   // Compute the path to the resource directory.
   ResourceDir = GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
 }
 
 void Driver::setDriverMode(StringRef Value) {
-  static const std::string OptName =
+  static StringRef OptName =
       getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
   if (auto M = llvm::StringSwitch<std::optional<DriverMode>>(Value)
                    .Case("gcc", GCCMode)
                    .Case("g++", GXXMode)
                    .Case("cpp", CPPMode)
                    .Case("cl", CLMode)
                    .Case("flang", FlangMode)
                    .Case("dxc", DXCMode)
bool clang::driver::willEmitRemarks(const ArgList &Args) {
   if (Args.hasFlag(options::OPT_foptimization_record_passes_EQ,
                    options::OPT_fno_save_optimization_record, false))
     return true;
   return false;
 }
 
 llvm::StringRef clang::driver::getDriverMode(StringRef ProgName,
                                              ArrayRef<const char *> Args) {
-  static const std::string OptName =
+  static StringRef OptName =
       getDriverOptTable().getOption(options::OPT_driver_mode).getPrefixedName();
   llvm::StringRef Opt;
   for (StringRef Arg : Args) {
     if (!Arg.startswith(OptName))
       continue;
     Opt = Arg;
   }
   if (Opt.empty())

clang/lib/Frontend/CompilerInvocation.cpp

 }
 
 template <typename T, typename U, U Value>
 static T extractMaskValue(T KeyPath) {
   return ((KeyPath & Value) == Value) ? static_cast<T>(Value) : T();
 }
 
 #define PARSE_OPTION_WITH_MARSHALLING(                                         \
-    ARGS, DIAGS, PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,  \
-    PARAM, HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT,     \
-    KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER,          \
-    DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)                              \
+    ARGS, DIAGS, PREFIX_TYPE, NAME, SPELLING, ID, KIND, GROUP, ALIAS,          \
+    ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR, VALUES, SHOULD_PARSE,          \
+    ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE,         \
+    NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)                  \
   if ((FLAGS)&options::CC1Option) {                                            \
     KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE);                                  \
     if (IMPLIED_CHECK)                                                         \
       KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE);                                \
     if (SHOULD_PARSE)                                                          \
       if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS))    \
         KEYPATH =                                                              \
             MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
   }
 
 // Capture the extracted value as a lambda argument to avoid potential issues
 // with lifetime extension of the reference.
 #define GENERATE_OPTION_WITH_MARSHALLING(                                      \
-    CONSUMER, PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS,     \
-    PARAM, HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT,     \
+    CONSUMER, PREFIX_TYPE, NAME, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS,  \
+    FLAGS, PARAM, HELPTEXT, METAVAR, VALUES, SHOULD_PARSE, ALWAYS_EMIT,        \
     KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER,          \
     DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX)                              \
   if ((FLAGS)&options::CC1Option) {                                            \
     [&](const auto &Extracted) {                                               \
       if (ALWAYS_EMIT ||                                                       \
           (Extracted !=                                                        \
            static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE)    \
                                                           : (DEFAULT_VALUE)))) \

clang/lib/Tooling/Tooling.cpp

 }
 
 void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
                                     StringRef InvokedAs) {
   if (CommandLine.empty() || InvokedAs.empty())
     return;
   const auto &Table = driver::getDriverOptTable();
   // --target=X
-  const std::string TargetOPT =
+  StringRef TargetOPT =
       Table.getOption(driver::options::OPT_target).getPrefixedName();
   // -target X
-  const std::string TargetOPTLegacy =
+  StringRef TargetOPTLegacy =
       Table.getOption(driver::options::OPT_target_legacy_spelling)
           .getPrefixedName();
   // --driver-mode=X
-  const std::string DriverModeOPT =
+  StringRef DriverModeOPT =
       Table.getOption(driver::options::OPT_driver_mode).getPrefixedName();
   auto TargetMode =
       driver::ToolChain::getTargetAndModeFromProgramName(InvokedAs);
   // No need to search for target args if we don't have a target/mode to insert.
   bool ShouldAddTarget = TargetMode.TargetIsValid;
   bool ShouldAddMode = TargetMode.DriverMode != nullptr;
   // Skip CommandLine[0].
   for (auto Token = ++CommandLine.begin(); Token != CommandLine.end();
        ++Token) {
     StringRef TokenRef(*Token);
     ShouldAddTarget = ShouldAddTarget && !TokenRef.startswith(TargetOPT) &&
                       !TokenRef.equals(TargetOPTLegacy);
     ShouldAddMode = ShouldAddMode && !TokenRef.startswith(DriverModeOPT);
   }
   if (ShouldAddMode) {
     CommandLine.insert(++CommandLine.begin(), TargetMode.DriverMode);
   }
   if (ShouldAddTarget) {
     CommandLine.insert(++CommandLine.begin(),
-                       TargetOPT + TargetMode.TargetPrefix);
+                       (TargetOPT + TargetMode.TargetPrefix).str());
   }
 }
 
 void addExpandedResponseFiles(std::vector<std::string> &CommandLine,
                               llvm::StringRef WorkingDir,
                               llvm::cl::TokenizerCallback Tokenizer,
                               llvm::vfs::FileSystem &FS) {
   bool SeenRSPFile = false;

llvm/include/llvm/Option/OptTable.h

 /// parts of the driver still use Option instances where convenient.
 class OptTable {
 public:
   /// Entry for a single option instance in the option data table.
   struct Info {
     /// A null terminated array of prefix strings to apply to name while
     /// matching.
     ArrayRef<StringLiteral> Prefixes;
+    // TODO: Compute this from PrefixedName.
     StringRef Name;
+    StringLiteral PrefixedName;
     const char *HelpText;
     const char *MetaVar;
     unsigned ID;
     unsigned char Kind;
     unsigned char Param;
     unsigned int Flags;
     unsigned short GroupID;
     unsigned short AliasID;
ArrayRef<StringLiteral> getPrefixesUnion() const final {
     return PrefixesUnion;
   }
 };
 
 } // end namespace opt
 
 } // end namespace llvm
 
-#define LLVM_MAKE_OPT_ID_WITH_ID_PREFIX(ID_PREFIX, PREFIX, NAME, ID, KIND,     \
-                                        GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
-                                        HELPTEXT, METAVAR, VALUES)             \
+#define LLVM_MAKE_OPT_ID_WITH_ID_PREFIX(                                       \
+    ID_PREFIX, PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
+    FLAGS, PARAM, HELPTEXT, METAVAR, VALUES)                                   \
   ID_PREFIX##ID
 
-#define LLVM_MAKE_OPT_ID(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS,      \
-                         FLAGS, PARAM, HELPTEXT, METAVAR, VALUES)              \
-  LLVM_MAKE_OPT_ID_WITH_ID_PREFIX(OPT_, PREFIX, NAME, ID, KIND, GROUP, ALIAS,  \
-                                  ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR,  \
-                                  VALUE)
+#define LLVM_MAKE_OPT_ID(PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS,  \
+                         ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR, VALUES)   \
+  LLVM_MAKE_OPT_ID_WITH_ID_PREFIX(OPT_, PREFIX, NAME, PREFIXED_NAME, ID, KIND, \
+                                  GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,       \
+                                  HELPTEXT, METAVAR, VALUE)
 
 #define LLVM_CONSTRUCT_OPT_INFO_WITH_ID_PREFIX(                                \
-    ID_PREFIX, PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
-    HELPTEXT, METAVAR, VALUES)                                                 \
+    ID_PREFIX, PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, \
+    FLAGS, PARAM, HELPTEXT, METAVAR, VALUES)                                   \
   llvm::opt::OptTable::Info {                                                  \
-    PREFIX, NAME, HELPTEXT, METAVAR, ID_PREFIX##ID,                            \
+    PREFIX, NAME, PREFIXED_NAME, HELPTEXT, METAVAR, ID_PREFIX##ID,             \
         llvm::opt::Option::KIND##Class, PARAM, FLAGS, ID_PREFIX##GROUP,        \
         ID_PREFIX##ALIAS, ALIASARGS, VALUES                                    \
   }
 
-#define LLVM_CONSTRUCT_OPT_INFO(PREFIX, NAME, ID, KIND, GROUP, ALIAS,          \
-                                ALIASARGS, FLAGS, PARAM, HELPTEXT, METAVAR,    \
-                                VALUES)                                        \
-  LLVM_CONSTRUCT_OPT_INFO_WITH_ID_PREFIX(OPT_, PREFIX, NAME, ID, KIND, GROUP,  \
-                                         ALIAS, ALIASARGS, FLAGS, PARAM,       \
-                                         HELPTEXT, METAVAR, VALUES)
+#define LLVM_CONSTRUCT_OPT_INFO(PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP,  \
+                                ALIAS, ALIASARGS, FLAGS, PARAM, HELPTEXT,      \
+                                METAVAR, VALUES)                               \
+  LLVM_CONSTRUCT_OPT_INFO_WITH_ID_PREFIX(                                      \
+      OPT_, PREFIX, NAME, PREFIXED_NAME, ID, KIND, GROUP, ALIAS, ALIASARGS,    \
+      FLAGS, PARAM, HELPTEXT, METAVAR, VALUES)
 
 #endif // LLVM_OPTION_OPTTABLE_H

llvm/include/llvm/Option/Option.h

public:
   }
 
   /// Get the name of this option without any prefix.
   StringRef getName() const {
     assert(Info && "Must have a valid info!");
     return Info->Name;
   }
 
   const Option getGroup() const {
     assert(Info && "Must have a valid info!");
     assert(Owner && "Must have a valid owner!");
     return Owner->getOption(Info->GroupID);
   }
 
   const Option getAlias() const {
     assert(Info && "Must have a valid info!");
     assert(Owner && "Must have a valid owner!");
public:
   /// Get the default prefix for this option.
   StringRef getPrefix() const {
     return Info->Prefixes.empty()
                ? StringRef()
                : static_cast<const StringRef &>(Info->Prefixes[0]);
   }
 
   /// Get the name of this option with the default prefix.
-  std::string getPrefixedName() const {
-    std::string Ret(getPrefix());
-    Ret += getName();
-    return Ret;
+  StringLiteral getPrefixedName() const {
+    assert(Info && "Must have a valid info!");
+    return Info->PrefixedName;
   }
 
   /// Get the help text for this option.
   StringRef getHelpText() const {
     assert(Info && "Must have a valid info!");
     return Info->HelpText;
   }
 

llvm/lib/Option/OptTable.cpp

else
       ErrorFn("unknown argument '" + Spelling + "', did you mean '" + Nearest +
               "'?");
   }
   return Args;
 }
 
 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
   const Option O = Opts.getOption(Id);
-  std::string Name = O.getPrefixedName();
+  std::string Name = O.getPrefixedName().str();
 
   // Add metavar, if used.
   switch (O.getKind()) {
   case Option::GroupClass: case Option::InputClass: case Option::UnknownClass:
     llvm_unreachable("Invalid option with help text.");
 
   case Option::MultiArgClass:
     if (const char *MetaVarName = Opts.getOptionMetaVar(Id)) {

llvm/utils/TableGen/OptParserEmitter.cpp

)";
 
   MarshallingInfo(const Record &R) : R(R) {}
 
   std::string getMacroName() const {
     return (MacroPrefix + MarshallingInfo::MacroName).str();
   }
 
   void emit(raw_ostream &OS) const {
-    write_cstring(OS, StringRef(getOptionSpelling(R)));
-    OS << ", ";
     OS << ShouldParse;
     OS << ", ";
     OS << ShouldAlwaysEmit;
     OS << ", ";
     OS << KeyPath;
     OS << ", ";
     emitScopedNormalizedValue(OS, DefaultValue);
     OS << ", ";
for (const Record &R : llvm::make_pointee_range(Groups)) {
     OS << "OPTION(";
 
     // The option prefix;
     OS << "llvm::ArrayRef<llvm::StringLiteral>()";
 
     // The option string.
     OS << ", \"" << R.getValueAsString("Name") << '"';
 
+    // The option spelling.
+    OS << ", \"" << R.getValueAsString("Name") << '"';
+
     // The option identifier name.
     OS << ", " << getOptionName(R);
 
     // The option kind.
     OS << ", Group";
 
     // The containing option group (if any).
     OS << ", ";
static void EmitOptParser(RecordKeeper &Records, raw_ostream &OS) {
   auto WriteOptRecordFields = [&](raw_ostream &OS, const Record &R) {
     // The option prefix;
     std::vector<StringRef> RPrefixes = R.getValueAsListOfStrings("Prefixes");
     OS << Prefixes[PrefixKeyT(RPrefixes.begin(), RPrefixes.end())] << ", ";
 
     // The option string.
     emitNameUsingSpelling(OS, R);
 
+    // The option spelling.
+    OS << ", llvm::StringLiteral(";
+    write_cstring(OS, getOptionSpelling(R));
+    OS << ")";
+
     // The option identifier name.
     OS << ", " << getOptionName(R);
 
     // The option kind.
     OS << ", " << R.getValueAsDef("Kind")->getValueAsString("Name");
 
     // The containing option group (if any).
     OS << ", ";