[lldb] Make the g_arguments_data constexpr and fix the static assert

[JDevlieghere]

Summary

This fixes the static assert that's meant to keep the g_arguments_data table in sync with the CommandArgumentType enumeration. Indeed, the assert didn't fire even though the current code is missing an entry. This patches fixes that as well.

[jingham]

Ack, sorry I missed adding that one!

Everything else looks fine, but you parsed the enum incorrectly, it's eArgType - RecognizerID. This is in fact a stack-frame recognizer ID. I suggested an appropriate version above.

lldb/source/Interpreter/CommandObject.cpp

1137

lldb/include/lldb/Interpreter/CommandObject.h

CommandArgumentData(lldb::CommandArgumentType type = lldb::eArgTypeNone,
                         uint32_t opt_set = LLDB_OPT_SET_ALL)
         : arg_type(type), arg_repetition(repetition),
           arg_opt_set_association(opt_set) {}
   };
 
   typedef std::vector<CommandArgumentData>
       CommandArgumentEntry; // Used to build individual command argument lists
 
-  static ArgumentTableEntry g_arguments_data
-      [lldb::eArgTypeLastArg]; // Main argument information table
-
   typedef std::map<std::string, lldb::CommandObjectSP> CommandMap;
 
   CommandObject(CommandInterpreter &interpreter, llvm::StringRef name,
     llvm::StringRef help = "", llvm::StringRef syntax = "",
                 uint32_t flags = 0);
 
   virtual ~CommandObject() = default;
 

lldb/source/Interpreter/CommandObject.cpp

 CommandObject::LookupArgumentName(llvm::StringRef arg_name) {
   CommandArgumentType return_type = eArgTypeLastArg;
 
   arg_name = arg_name.ltrim('<').rtrim('>');
 
   const ArgumentTableEntry *table = GetArgumentTable();
   for (int i = 0; i < eArgTypeLastArg; ++i)
     if (arg_name == table[i].arg_name)
-      return_type = g_arguments_data[i].arg_type;
+      return_type = GetArgumentTable()[i].arg_type;
 
   return return_type;
 }
 
 static llvm::StringRef RegisterNameHelpTextCallback() {
   return "Register names can be specified using the architecture specific "
          "names.  "
          "They can also be specified using generic names.  Not all generic "
void CommandObject::AddIDsArgumentData(CommandArgumentEntry &arg,
   arg.push_back(id_arg);
   arg.push_back(id_range_arg);
 }
 
 const char *CommandObject::GetArgumentTypeAsCString(
     const lldb::CommandArgumentType arg_type) {
   assert(arg_type < eArgTypeLastArg &&
          "Invalid argument type passed to GetArgumentTypeAsCString");
-  return g_arguments_data[arg_type].arg_name;
+  return GetArgumentTable()[arg_type].arg_name;
 }
 
 const char *CommandObject::GetArgumentDescriptionAsCString(
     const lldb::CommandArgumentType arg_type) {
   assert(arg_type < eArgTypeLastArg &&
          "Invalid argument type passed to GetArgumentDescriptionAsCString");
-  return g_arguments_data[arg_type].help_text;
+  return GetArgumentTable()[arg_type].help_text;
 }
 
 Target &CommandObject::GetDummyTarget() {
   return m_interpreter.GetDebugger().GetDummyTarget();
 }
 
 Target &CommandObject::GetSelectedOrDummyTarget(bool prefer_dummy) {
   return m_interpreter.GetDebugger().GetSelectedOrDummyTarget(prefer_dummy);
if (g_archs_help.Empty()) {
 
     ArchSpec::ListSupportedArchNames(archs);
     g_archs_help.Printf("These are the supported architecture names:\n");
     archs.Join("\n", g_archs_help);
   }
   return g_archs_help.GetString();
 }
 
-CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
+static constexpr CommandObject::ArgumentTableEntry g_arguments_data[] = {
     // clang-format off
     { eArgTypeAddress, "address", CommandCompletions::eNoCompletion, { nullptr, false }, "A valid address in the target program's execution space." },
     { eArgTypeAddressOrExpression, "address-expression", CommandCompletions::eNoCompletion, { nullptr, false }, "An expression that resolves to an address." },
     { eArgTypeAliasName, "alias-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of an abbreviation (alias) for a debugger command." },
     { eArgTypeAliasOptions, "options-for-aliased-command", CommandCompletions::eNoCompletion, { nullptr, false }, "Command options to be used as part of an alias (abbreviation) definition.  (See 'help commands alias' for more information.)" },
     { eArgTypeArchitecture, "arch", CommandCompletions::eArchitectureCompletion, { arch_helper, true }, "The architecture name, e.g. i386 or x86_64." },
     { eArgTypeBoolean, "boolean", CommandCompletions::eNoCompletion, { nullptr, false }, "A Boolean value: 'true' or 'false'" },
     { eArgTypeBreakpointID, "breakpt-id", CommandCompletions::eNoCompletion, { BreakpointIDHelpTextCallback, false }, nullptr },
static constexpr CommandObject::ArgumentTableEntry g_arguments_data[] = {
     { eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, { nullptr, false }, "Specify the type for a watchpoint." },
     { eArgRawInput, "raw-input", CommandCompletions::eNoCompletion, { nullptr, false }, "Free-form text passed to a command without prior interpretation, allowing spaces without requiring quotes.  To pass arguments and free form text put two dashes ' -- ' between the last argument and any raw input." },
     { eArgTypeCommand, "command", CommandCompletions::eNoCompletion, { nullptr, false }, "An LLDB Command line command element." },
     { eArgTypeColumnNum, "column", CommandCompletions::eNoCompletion, { nullptr, false }, "Column number in a source file." },
     { eArgTypeModuleUUID, "module-uuid", CommandCompletions::eModuleUUIDCompletion, { nullptr, false }, "A module UUID value." },
     { eArgTypeSaveCoreStyle, "corefile-style", CommandCompletions::eNoCompletion, { nullptr, false }, "The type of corefile that lldb will try to create, dependant on this target's capabilities." },
     { eArgTypeLogHandler, "log-handler", CommandCompletions::eNoCompletion, { nullptr, false }, "The log handle that will be used to write out log messages." },
     { eArgTypeSEDStylePair, "substitution-pair", CommandCompletions::eNoCompletion, { nullptr, false }, "A sed-style pattern and target pair." },
+    { eArgTypeRecognizerID, "frame-recognizer-id", CommandCompletions::eNoCompletion, { nullptr, false }, "The ID for a stack frame recognizer." },
     { eArgTypeConnectURL, "process-connect-url", CommandCompletions::eNoCompletion, { nullptr, false }, "A URL-style specification for a remote connection." },
     { eArgTypeTargetID, "target-id", CommandCompletions::eNoCompletion, { nullptr, false }, "The index ID for an lldb Target." },
     { eArgTypeStopHookID, "stop-hook-id", CommandCompletions::eNoCompletion, { nullptr, false }, "The ID you receive when you create a stop-hook." }
     // clang-format on
 };
 
+static_assert(
+    (sizeof(g_arguments_data) / sizeof(CommandObject::ArgumentTableEntry)) ==
+        eArgTypeLastArg,
+    "g_arguments_data out of sync with CommandArgumentType enumeration");
+
 const CommandObject::ArgumentTableEntry *CommandObject::GetArgumentTable() {
-  // If this assertion fires, then the table above is out of date with the
-  // CommandArgumentType enumeration
-  static_assert((sizeof(CommandObject::g_arguments_data) /
-                 sizeof(CommandObject::ArgumentTableEntry)) == eArgTypeLastArg,
-                "");
-  return CommandObject::g_arguments_data;
+  return g_arguments_data;
 }