[lldb] Also include the array definition in CommandOptions.inc

[teemperor]

Summary

Right now our CommandOptions.inc only generates the initializer for the options list but
not the array declaration boilerplate around it. As the array definition is identical for all arrays,
we might as well also let the CommandOptions.inc generate it alongside the initializers.

This patch will also allow us to generate additional declarations related to that option list in
the future (e.g. a enum class representing the specific options which would make our
handling code less prone).

This patch also fixes a few option tables that didn't follow our naming style.

[JDevlieghere]

LGTM

[JDevlieghere]

lldb/utils/TableGen/LLDBOptionDefEmitter.cpp

146

Let's move this before the comment.

lldb/source/Commands/CommandObjectBreakpoint.cpp

static void AddBreakpointDescription(Stream *s, Breakpoint *bp,
   s->IndentMore();
   bp->GetDescription(s, level, true);
   s->IndentLess();
   s->EOL();
 }
 
 // Modifiable Breakpoint Options
 #pragma mark Modify::CommandOptions
-static constexpr OptionDefinition g_breakpoint_modify_options[] = {
 #define LLDB_OPTIONS_breakpoint_modify
 #include "CommandOptions.inc"
-};
+
 class lldb_private::BreakpointOptionGroup : public OptionGroup
 {
 public:
   BreakpointOptionGroup() :
           OptionGroup(),
           m_bp_opts(false) {}
   
   ~BreakpointOptionGroup() override = default;
public:
   {
     return m_bp_opts;
   }
 
   std::vector<std::string> m_commands;
   BreakpointOptions m_bp_opts;
 
 };
-static constexpr OptionDefinition g_breakpoint_dummy_options[] = {
+
 #define LLDB_OPTIONS_breakpoint_dummy
 #include "CommandOptions.inc"
-};
 
 class BreakpointDummyOptionGroup : public OptionGroup
 {
 public:
   BreakpointDummyOptionGroup() :
           OptionGroup() {}
   
   ~BreakpointDummyOptionGroup() override = default;
public:
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_use_dummy = false;
   }
 
   bool m_use_dummy;
 
 };
 
-static constexpr OptionDefinition g_breakpoint_set_options[] = {
 #define LLDB_OPTIONS_breakpoint_set
 #include "CommandOptions.inc"
-};
 
 // CommandObjectBreakpointSet
 
 class CommandObjectBreakpointSet : public CommandObjectParsed {
 public:
   enum BreakpointSetType {
     eSetTypeInvalid,
     eSetTypeFileAndLine,
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 };
 
 // CommandObjectBreakpointList
 
 #pragma mark List::CommandOptions
-static constexpr OptionDefinition g_breakpoint_list_options[] = {
 #define LLDB_OPTIONS_breakpoint_list
 #include "CommandOptions.inc"
-};
 
 #pragma mark List
 
 class CommandObjectBreakpointList : public CommandObjectParsed {
 public:
   CommandObjectBreakpointList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "breakpoint list",

 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectBreakpointClear
 #pragma mark Clear::CommandOptions
 
-static constexpr OptionDefinition g_breakpoint_clear_options[] = {
 #define LLDB_OPTIONS_breakpoint_clear
 #include "CommandOptions.inc"
-};
 
 #pragma mark Clear
 
 class CommandObjectBreakpointClear : public CommandObjectParsed {
 public:
   enum BreakpointClearType { eClearTypeInvalid, eClearTypeFileAndLine };
 
   CommandObjectBreakpointClear(CommandInterpreter &interpreter)
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectBreakpointDelete
-static constexpr OptionDefinition g_breakpoint_delete_options[] = {
 #define LLDB_OPTIONS_breakpoint_delete
 #include "CommandOptions.inc"
-};
 
 #pragma mark Delete
 
 class CommandObjectBreakpointDelete : public CommandObjectParsed {
 public:
   CommandObjectBreakpointDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint delete",
                             "Delete the specified breakpoint(s).  If no "
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectBreakpointName
-
-static constexpr OptionDefinition g_breakpoint_name_options[] = {
 #define LLDB_OPTIONS_breakpoint_name
 #include "CommandOptions.inc"
-};
+
 class BreakpointNameOptionGroup : public OptionGroup {
 public:
   BreakpointNameOptionGroup()
       : OptionGroup(), m_breakpoint(LLDB_INVALID_BREAK_ID), m_use_dummy(false) {
   }
 
   ~BreakpointNameOptionGroup() override = default;
 
public:
   }
 
   OptionValueString m_name;
   OptionValueUInt64 m_breakpoint;
   OptionValueBoolean m_use_dummy;
   OptionValueString m_help_string;
 };
 
-static constexpr OptionDefinition g_breakpoint_access_options[] = {
 #define LLDB_OPTIONS_breakpoint_access
 #include "CommandOptions.inc"
-};
 
 class BreakpointAccessOptionGroup : public OptionGroup {
 public:
   BreakpointAccessOptionGroup() : OptionGroup() {}
 
   ~BreakpointAccessOptionGroup() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
CommandObjectBreakpointName(CommandInterpreter &interpreter)
     LoadSubCommand("configure", configure_command_object);
   }
 
   ~CommandObjectBreakpointName() override = default;
 };
 
 // CommandObjectBreakpointRead
 #pragma mark Read::CommandOptions
-static constexpr OptionDefinition g_breakpoint_read_options[] = {
 #define LLDB_OPTIONS_breakpoint_read
 #include "CommandOptions.inc"
-};
 
 #pragma mark Read
 
 class CommandObjectBreakpointRead : public CommandObjectParsed {
 public:
   CommandObjectBreakpointRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint read",
                             "Read and set the breakpoints previously saved to "
protected:
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectBreakpointWrite
 #pragma mark Write::CommandOptions
-static constexpr OptionDefinition g_breakpoint_write_options[] = {
 #define LLDB_OPTIONS_breakpoint_write
 #include "CommandOptions.inc"
-};
 
 #pragma mark Write
 class CommandObjectBreakpointWrite : public CommandObjectParsed {
 public:
   CommandObjectBreakpointWrite(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint write",
                             "Write the breakpoints listed to a file that can "
                             "be read in with \"breakpoint read\".  "

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
     {eScriptLanguagePython, "python", "Commands are in the Python language."},
     {eSortOrderByName, "default-script",
      "Commands are in the default scripting language."} };
 
 static constexpr OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_breakpoint_add_options[] = {
 #define LLDB_OPTIONS_breakpoint_command_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectBreakpointCommandAdd : public CommandObjectParsed,
                                           public IOHandlerDelegateMultiline {
 public:
   CommandObjectBreakpointCommandAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "add",
                             "Add LLDB commands to a breakpoint, to be executed "
                             "whenever the breakpoint is hit."
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = option_arg;
         break;
 
       case 's':
         m_script_language = (lldb::ScriptLanguage)OptionArgParser::ToOptionEnum(
-            option_arg, g_breakpoint_add_options[option_idx].enum_values,
+            option_arg,
+            g_breakpoint_command_add_options[option_idx].enum_values,
             eScriptLanguageNone, error);
 
         if (m_script_language == eScriptLanguagePython ||
             m_script_language == eScriptLanguageDefault) {
           m_use_script_language = true;
         } else {
           m_use_script_language = false;
         }
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_one_liner = false;
       m_stop_on_error = true;
       m_one_liner.clear();
       m_function_name.clear();
       m_use_dummy = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::makeArrayRef(g_breakpoint_add_options);
+      return llvm::makeArrayRef(g_breakpoint_command_add_options);
     }
 
     // Instance variables to hold the values for command options.
 
     bool m_use_commands;
     bool m_use_script_language;
     lldb::ScriptLanguage m_script_language;
 
private:
   static const char *g_reader_instructions;
 };
 
 const char *CommandObjectBreakpointCommandAdd::g_reader_instructions =
     "Enter your debugger command(s).  Type 'DONE' to end.\n";
 
 // CommandObjectBreakpointCommandDelete
 
-static constexpr OptionDefinition g_breakpoint_delete_options[] = {
 #define LLDB_OPTIONS_breakpoint_command_delete
 #include "CommandOptions.inc"
-};
 
 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed {
 public:
   CommandObjectBreakpointCommandDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "delete",
                             "Delete the set of commands from a breakpoint.",
                             nullptr),
         m_options() {
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::makeArrayRef(g_breakpoint_delete_options);
+      return llvm::makeArrayRef(g_breakpoint_command_delete_options);
     }
 
     // Instance variables to hold the values for command options.
     bool m_use_dummy;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {

lldb/source/Commands/CommandObjectCommands.cpp

 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // CommandObjectCommandsSource
 
-static constexpr OptionDefinition g_history_options[] = {
 #define LLDB_OPTIONS_history
 #include "CommandOptions.inc"
-};
 
 class CommandObjectCommandsHistory : public CommandObjectParsed {
 public:
   CommandObjectCommandsHistory(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command history",
                             "Dump the history of commands in this session.\n"
                             "Commands in the history list can be run again "
                             "using \"!<INDEX>\".   \"!-<OFFSET>\" will re-run "
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 // CommandObjectCommandsSource
 
-static constexpr OptionDefinition g_source_options[] = {
 #define LLDB_OPTIONS_source
 #include "CommandOptions.inc"
-};
 
 class CommandObjectCommandsSource : public CommandObjectParsed {
 public:
   CommandObjectCommandsSource(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "command source",
             "Read and execute LLDB commands from the file <filename>.",
             nullptr),
protected:
   }
 
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectCommandsAlias
 // CommandObjectCommandsAlias
 
-static constexpr OptionDefinition g_alias_options[] = {
 #define LLDB_OPTIONS_alias
 #include "CommandOptions.inc"
-};
 
 static const char *g_python_command_instructions =
     "Enter your Python command(s). Type 'DONE' to end.\n"
     "You must define a Python function with this signature:\n"
     "def my_command_impl(debugger, args, result, internal_dict):\n";
 
 class CommandObjectCommandsAlias : public CommandObjectRaw {
 protected:
bool DoExecute(Args &args, CommandReturnObject &result) override {
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return true;
   }
 };
 
 // CommandObjectCommandsAddRegex
 
-static constexpr OptionDefinition g_regex_options[] = {
 #define LLDB_OPTIONS_regex
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectCommandsAddRegex
 
 class CommandObjectCommandsAddRegex : public CommandObjectParsed,
                                       public IOHandlerDelegateMultiline {
 public:
   CommandObjectCommandsAddRegex(CommandInterpreter &interpreter)
       : CommandObjectParsed(

 private:
   StructuredData::GenericSP m_cmd_obj_sp;
   ScriptedCommandSynchronicity m_synchro;
   bool m_fetched_help_short : 1;
   bool m_fetched_help_long : 1;
 };
 
 // CommandObjectCommandsScriptImport
-
-static constexpr OptionDefinition g_script_import_options[] = {
 #define LLDB_OPTIONS_script_import
 #include "CommandOptions.inc"
-};
 
 class CommandObjectCommandsScriptImport : public CommandObjectParsed {
 public:
   CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command script import",
                             "Import a scripting module in LLDB.", nullptr),
         m_options() {
     CommandArgumentEntry arg1;
static constexpr OptionEnumValueElement g_script_synchro_type[] = {
    "Run asynchronous"},
   {eScriptedCommandSynchronicityCurrentValue, "current",
    "Do not alter current setting"} };
 
 static constexpr OptionEnumValues ScriptSynchroType() {
   return OptionEnumValues(g_script_synchro_type);
 }
 
-static constexpr OptionDefinition g_script_add_options[] = {
 #define LLDB_OPTIONS_script_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectCommandsScriptAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command script add",
                             "Add a scripted function as an LLDB command.",
                             nullptr),

lldb/source/Commands/CommandObjectDisassemble.cpp

 #include "lldb/Target/Target.h"
 
 #define DEFAULT_DISASM_BYTE_SIZE 32
 #define DEFAULT_DISASM_NUM_INS 4
 
 using namespace lldb;
 using namespace lldb_private;
 
-static constexpr OptionDefinition g_disassemble_options[] = {
 #define LLDB_OPTIONS_disassemble
 #include "CommandOptions.inc"
-};
 
 CommandObjectDisassemble::CommandOptions::CommandOptions()
     : Options(), num_lines_context(0), num_instructions(0), func_name(),
       current_function(false), start_addr(), end_addr(), at_pc(false),
       frame_line(false), plugin_name(), flavor_string(), arch(),
       some_location_specified(false), symbol_containing_addr() {
   OptionParsingStarting(nullptr);
 }

lldb/source/Commands/CommandObjectExpression.cpp

static constexpr OptionEnumValueElement g_description_verbosity_type[] = {
      "Only show the description string"},
     {eLanguageRuntimeDescriptionDisplayVerbosityFull, "full",
      "Show the full output, including persistent variable's name and type"} };
 
 static constexpr OptionEnumValues DescriptionVerbosityTypes() {
   return OptionEnumValues(g_description_verbosity_type);
 }
 
-static constexpr OptionDefinition g_expression_options[] = {
 #define LLDB_OPTIONS_expression
 #include "CommandOptions.inc"
-};
 
 Status CommandObjectExpression::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Status error;
 
   const int short_option = GetDefinitions()[option_idx].short_option;
 

lldb/source/Commands/CommandObjectFrame.cpp

 using namespace lldb_private;
 
 #pragma mark CommandObjectFrameDiagnose
 
 // CommandObjectFrameInfo
 
 // CommandObjectFrameDiagnose
 
-static constexpr OptionDefinition g_frame_diag_options[] = {
 #define LLDB_OPTIONS_frame_diag
 #include "CommandOptions.inc"
-};
 
 class CommandObjectFrameDiagnose : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectFrameSelect
 
 // CommandObjectFrameSelect
 
-static OptionDefinition g_frame_select_options[] = {
 #define LLDB_OPTIONS_frame_select
 #include "CommandOptions.inc"
-};
 
 class CommandObjectFrameSelect : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
protected:
   OptionGroupOptions m_option_group;
   OptionGroupVariable m_option_variable;
   OptionGroupFormat m_option_format;
   OptionGroupValueObjectDisplay m_varobj_options;
 };
 
 #pragma mark CommandObjectFrameRecognizer
 
-static OptionDefinition g_frame_recognizer_add_options[] = {
 #define LLDB_OPTIONS_frame_recognizer_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectFrameRecognizerAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
     ~CommandOptions() override = default;
 

lldb/source/Commands/CommandObjectHelp.cpp

CommandObjectHelp::CommandObjectHelp(CommandInterpreter &interpreter)
   arg.push_back(command_arg);
 
   // Push the data for the first argument into the m_arguments vector.
   m_arguments.push_back(arg);
 }
 
 CommandObjectHelp::~CommandObjectHelp() = default;
 
-static constexpr OptionDefinition g_help_options[] = {
 #define LLDB_OPTIONS_help
 #include "CommandOptions.inc"
-};
 
 llvm::ArrayRef<OptionDefinition>
 CommandObjectHelp::CommandOptions::GetDefinitions() {
   return llvm::makeArrayRef(g_help_options);
 }
 
 bool CommandObjectHelp::DoExecute(Args &command, CommandReturnObject &result) {
   CommandObject::CommandMap::iterator pos;

lldb/source/Commands/CommandObjectLog.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static constexpr OptionDefinition g_log_options[] = {
 #define LLDB_OPTIONS_log
 #include "CommandOptions.inc"
-};
 
 class CommandObjectLogEnable : public CommandObjectParsed {
 public:
   // Constructors and Destructors
   CommandObjectLogEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "log enable",
                             "Enable logging for a single log channel.",
                             nullptr),

lldb/source/Commands/CommandObjectMemory.cpp

 #include "lldb/lldb-private.h"
 
 #include <cinttypes>
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
-static constexpr OptionDefinition g_read_memory_options[] = {
 #define LLDB_OPTIONS_memory_read
 #include "CommandOptions.inc"
-};
 
 class OptionGroupReadMemory : public OptionGroup {
 public:
   OptionGroupReadMemory()
       : m_num_per_line(1, 1), m_output_as_binary(false), m_view_as_type(),
         m_offset(0, 0), m_language_for_type(eLanguageTypeUnknown) {}
 
   ~OptionGroupReadMemory() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-    return llvm::makeArrayRef(g_read_memory_options);
+    return llvm::makeArrayRef(g_memory_read_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override {
     Status error;
-    const int short_option = g_read_memory_options[option_idx].short_option;
+    const int short_option = g_memory_read_options[option_idx].short_option;
 
     switch (short_option) {
     case 'l':
       error = m_num_per_line.SetValueFromString(option_value);
       if (m_num_per_line.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat(
             "invalid value for --num-per-line option '%s'",
             option_value.str().c_str());
#undef ALL_KEYWORDS
   lldb::addr_t m_prev_byte_size;
   OptionGroupFormat m_prev_format_options;
   OptionGroupReadMemory m_prev_memory_options;
   OptionGroupOutputFile m_prev_outfile_options;
   OptionGroupValueObjectDisplay m_prev_varobj_options;
   CompilerType m_prev_compiler_type;
 };
 
-static constexpr OptionDefinition g_memory_find_option_table[] = {
 #define LLDB_OPTIONS_memory_find
 #include "CommandOptions.inc"
-};
 
 // Find the specified data in memory
 class CommandObjectMemoryFind : public CommandObjectParsed {
 public:
   class OptionGroupFindMemory : public OptionGroup {
   public:
     OptionGroupFindMemory() : OptionGroup(), m_count(1), m_offset(0) {}
 
     ~OptionGroupFindMemory() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::makeArrayRef(g_memory_find_option_table);
+      return llvm::makeArrayRef(g_memory_find_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
-          g_memory_find_option_table[option_idx].short_option;
+      const int short_option = g_memory_find_options[option_idx].short_option;
 
       switch (short_option) {
       case 'e':
         m_expr.SetValueFromString(option_value);
         break;
 
       case 's':
         m_string.SetValueFromString(option_value);
lldb::addr_t FastSearch(lldb::addr_t low, lldb::addr_t high, uint8_t *buffer,
 
     return LLDB_INVALID_ADDRESS;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupFindMemory m_memory_options;
 };
 
-static constexpr OptionDefinition g_memory_write_option_table[] = {
 #define LLDB_OPTIONS_memory_write
 #include "CommandOptions.inc"
-};
 
 // Write memory to the inferior process
 class CommandObjectMemoryWrite : public CommandObjectParsed {
 public:
   class OptionGroupWriteMemory : public OptionGroup {
   public:
     OptionGroupWriteMemory() : OptionGroup() {}
 
     ~OptionGroupWriteMemory() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      return llvm::makeArrayRef(g_memory_write_option_table);
+      return llvm::makeArrayRef(g_memory_write_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                           ExecutionContext *execution_context) override {
       Status error;
-      const int short_option =
-          g_memory_write_option_table[option_idx].short_option;
+      const int short_option = g_memory_write_options[option_idx].short_option;
 
       switch (short_option) {
       case 'i':
         m_infile.SetFile(option_value, FileSpec::Style::native);
         FileSystem::Instance().Resolve(m_infile);
         if (!FileSystem::Instance().Exists(m_infile)) {
           m_infile.Clear();
           error.SetErrorStringWithFormat("input file does not exist: '%s'",

lldb/source/Commands/CommandObjectPlatform.cpp

static mode_t ParsePermissionString(llvm::StringRef permissions) {
   mode_t user, group, world;
   user = (user_r ? 4 : 0) | (user_w ? 2 : 0) | (user_x ? 1 : 0);
   group = (group_r ? 4 : 0) | (group_w ? 2 : 0) | (group_x ? 1 : 0);
   world = (world_r ? 4 : 0) | (world_w ? 2 : 0) | (world_x ? 1 : 0);
 
   return user | group | world;
 }
 
-static constexpr OptionDefinition g_permissions_options[] = {
 #define LLDB_OPTIONS_permissions
 #include "CommandOptions.inc"
-};
 
 class OptionPermissions : public OptionGroup {
 public:
   OptionPermissions() {}
 
   ~OptionPermissions() override = default;
 
   lldb_private::Status
if (platform_sp) {
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 };
 
 // "platform fread"
 
-static constexpr OptionDefinition g_platform_fread_options[] = {
 #define LLDB_OPTIONS_platform_fread
 #include "CommandOptions.inc"
-};
 
 class CommandObjectPlatformFRead : public CommandObjectParsed {
 public:
   CommandObjectPlatformFRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform file read",
                             "Read data from a file on the remote end.", nullptr,
                             0),
         m_options() {}
public:
     uint32_t m_count;
   };
 
   CommandOptions m_options;
 };
 
 // "platform fwrite"
 
-static constexpr OptionDefinition g_platform_fwrite_options[] = {
 #define LLDB_OPTIONS_platform_fwrite
 #include "CommandOptions.inc"
-};
 
 class CommandObjectPlatformFWrite : public CommandObjectParsed {
 public:
   CommandObjectPlatformFWrite(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform file write",
                             "Write data to a file on the remote end.", nullptr,
                             0),
         m_options() {}

 
 protected:
   ProcessLaunchCommandOptions m_options;
 };
 
 // "platform process list"
 
 static PosixPlatformCommandOptionValidator posix_validator;
-static constexpr OptionDefinition g_platform_process_list_options[] = {
 #define LLDB_OPTIONS_platform_process_list
 #include "CommandOptions.inc"
-};
 
 class CommandObjectPlatformProcessList : public CommandObjectParsed {
 public:
   CommandObjectPlatformProcessList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform process list",
                             "List processes on a remote platform by name, pid, "
                             "or many other matching attributes.",
                             "platform process list", 0),
bool DoExecute(Args &args, CommandReturnObject &result) override {
     } else {
       result.AppendError("no platform is currently selected");
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 };
 
-static constexpr OptionDefinition g_platform_process_attach_options[] = {
 #define LLDB_OPTIONS_platform_process_attach
 #include "CommandOptions.inc"
-};
 
 class CommandObjectPlatformProcessAttach : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
public:
   ~CommandObjectPlatformProcess() override = default;
 
 private:
   // For CommandObjectPlatform only
   DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
 };
 
 // "platform shell"
-static constexpr OptionDefinition g_platform_shell_options[] = {
 #define LLDB_OPTIONS_platform_shell
 #include "CommandOptions.inc"
-};
 
 class CommandObjectPlatformShell : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;

lldb/source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &launch_args, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
 protected:
   ProcessLaunchCommandOptions m_options;
 };
 
-static constexpr OptionDefinition g_process_attach_options[] = {
 #define LLDB_OPTIONS_process_attach
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessAttach
 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 // CommandObjectProcessContinue
 
-static constexpr OptionDefinition g_process_continue_options[] = {
 #define LLDB_OPTIONS_process_continue
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessContinue
 
 class CommandObjectProcessContinue : public CommandObjectParsed {
 public:
   CommandObjectProcessContinue(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "process continue",
protected:
   }
 
   Options *GetOptions() override { return &m_options; }
 
   CommandOptions m_options;
 };
 
 // CommandObjectProcessDetach
-static constexpr OptionDefinition g_process_detach_options[] = {
 #define LLDB_OPTIONS_process_detach
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessDetach
 
 class CommandObjectProcessDetach : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 // CommandObjectProcessConnect
-
-static constexpr OptionDefinition g_process_connect_options[] = {
 #define LLDB_OPTIONS_process_connect
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessConnect
 
 class CommandObjectProcessConnect : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
CommandObject *GetProxyCommandObject() override {
     Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
     if (process)
       return process->GetPluginCommandObject();
     return nullptr;
   }
 };
 
 // CommandObjectProcessLoad
-
-static constexpr OptionDefinition g_process_load_options[] = {
 #define LLDB_OPTIONS_process_load
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessLoad
 
 class CommandObjectProcessLoad : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     process->GetStatus(strm);
     process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
                              num_frames, num_frames_with_source, stop_format);
     return result.Succeeded();
   }
 };
 
 // CommandObjectProcessHandle
-
-static constexpr OptionDefinition g_process_handle_options[] = {
 #define LLDB_OPTIONS_process_handle
 #include "CommandOptions.inc"
-};
 
 #pragma mark CommandObjectProcessHandle
 
 class CommandObjectProcessHandle : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }

lldb/source/Commands/CommandObjectRegister.cpp

 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Errno.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // "register read"
-
-static constexpr OptionDefinition g_register_read_options[] = {
 #define LLDB_OPTIONS_register_read
 #include "CommandOptions.inc"
-};
 
 class CommandObjectRegisterRead : public CommandObjectParsed {
 public:
   CommandObjectRegisterRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "register read",
             "Dump the contents of one or more register values from the current "
             "frame.  If no register is specified, dumps them all.",

lldb/source/Commands/CommandObjectSettings.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // CommandObjectSettingsSet
-
-static constexpr OptionDefinition g_settings_set_options[] = {
 #define LLDB_OPTIONS_settings_set
 #include "CommandOptions.inc"
-};
 
 class CommandObjectSettingsSet : public CommandObjectRaw {
 public:
   CommandObjectSettingsSet(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "settings set",
                          "Set the value of the specified debugger setting."),
         m_options() {
     CommandArgumentEntry arg1;
if (!args.empty()) {
                                           OptionValue::eDumpGroupValue);
     }
 
     return result.Succeeded();
   }
 };
 
 // CommandObjectSettingsWrite -- Write settings to file
-
-static constexpr OptionDefinition g_settings_write_options[] = {
 #define LLDB_OPTIONS_settings_write
 #include "CommandOptions.inc"
-};
 
 class CommandObjectSettingsWrite : public CommandObjectParsed {
 public:
   CommandObjectSettingsWrite(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "settings export",
             "Write matching debugger settings and their "
             "current values to a file that can be read in with "
bool DoExecute(Args &args, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectSettingsRead -- Read settings from file
-
-static constexpr OptionDefinition g_settings_read_options[] = {
 #define LLDB_OPTIONS_settings_read
 #include "CommandOptions.inc"
-};
 
 class CommandObjectSettingsRead : public CommandObjectParsed {
 public:
   CommandObjectSettingsRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "settings read",
             "Read settings previously saved to a file with \"settings write\".",
             nullptr),

lldb/source/Commands/CommandObjectSource.cpp

 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/FileSpec.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark CommandObjectSourceInfo
 // CommandObjectSourceInfo - debug line entries dumping command
-
-static constexpr OptionDefinition g_source_info_options[] = {
 #define LLDB_OPTIONS_source_info
 #include "CommandOptions.inc"
-};
 
 class CommandObjectSourceInfo : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
protected:
   }
 
   CommandOptions m_options;
   ModuleList m_module_list;
 };
 
 #pragma mark CommandObjectSourceList
 // CommandObjectSourceList
-
-static constexpr OptionDefinition g_source_list_options[] = {
 #define LLDB_OPTIONS_source_list
 #include "CommandOptions.inc"
-};
 
 class CommandObjectSourceList : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 

lldb/source/Commands/CommandObjectTarget.cpp

 static constexpr OptionEnumValueElement g_dependents_enumaration[] = {
     {eLoadDependentsDefault, "default",
      "Only load dependents when the target is an executable."},
     {eLoadDependentsNo, "true",
      "Don't load dependents, even if the target is an executable."},
     {eLoadDependentsYes, "false",
      "Load dependents, even if the target is not an executable."}};
 
-static constexpr OptionDefinition g_dependents_options[] = {
 #define LLDB_OPTIONS_target_dependents
 #include "CommandOptions.inc"
-};
 
 class OptionGroupDependents : public OptionGroup {
 public:
   OptionGroupDependents() {}
 
   ~OptionGroupDependents() override {}
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-    return llvm::makeArrayRef(g_dependents_options);
+    return llvm::makeArrayRef(g_target_dependents_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override {
     Status error;
 
     // For compatibility no value means don't load dependents.
     if (option_value.empty()) {
       m_load_dependent_files = eLoadDependentsNo;
       return error;
     }
 
-    const char short_option = g_dependents_options[option_idx].short_option;
+    const char short_option =
+        g_target_dependents_options[option_idx].short_option;
     if (short_option == 'd') {
       LoadDependentFiles tmp_load_dependents;
       tmp_load_dependents = (LoadDependentFiles)OptionArgParser::ToOptionEnum(
-          option_value, g_dependents_options[option_idx].enum_values, 0, error);
+          option_value, g_target_dependents_options[option_idx].enum_values, 0,
+          error);
       if (error.Success())
         m_load_dependent_files = tmp_load_dependents;
     } else {
       error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                      short_option);
     }
 
     return error;

 #pragma mark CommandObjectTargetModulesDumpSymtab
 
 static constexpr OptionEnumValueElement g_sort_option_enumeration[] = {
     {eSortOrderNone, "none",
      "No sorting, use the original symbol table order."},
     {eSortOrderByAddress, "address", "Sort output by symbol address."},
     {eSortOrderByName, "name", "Sort output by symbol name."} };
 
-static constexpr OptionDefinition g_target_modules_dump_symtab_options[] = {
 #define LLDB_OPTIONS_target_modules_dump_symtab
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTargetModulesDumpSymtab
     : public CommandObjectTargetModulesModuleAutoComplete {
 public:
   CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesModuleAutoComplete(
             interpreter, "target modules dump symtab",
             "Dump the symbol table from one or more target modules.", nullptr),
if (target == nullptr) {
         result.SetStatus(eReturnStatusFailed);
       }
     }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpLineTable
+#define LLDB_OPTIONS_target_modules_dump
+#include "CommandOptions.inc"
 
 // Image debug line table dumping command
 
 class CommandObjectTargetModulesDumpLineTable
     : public CommandObjectTargetModulesSourceFileAutoComplete {
 public:
   CommandObjectTargetModulesDumpLineTable(CommandInterpreter &interpreter)
       : CommandObjectTargetModulesSourceFileAutoComplete(
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       return Status();
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_verbose = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
-      static constexpr OptionDefinition g_options[] = {
-#define LLDB_OPTIONS_target_modules_dump
-#include "CommandOptions.inc"
-      };
-      return llvm::makeArrayRef(g_options);
+      return llvm::makeArrayRef(g_target_modules_dump_options);
     }
 
     bool m_verbose;
   };
 
   CommandOptions m_options;
 };
 
protected:
   OptionGroupUUID m_uuid_option_group;
   OptionGroupString m_file_option;
   OptionGroupBoolean m_load_option;
   OptionGroupBoolean m_pc_option;
   OptionGroupUInt64 m_slide_option;
 };
 
 // List images with associated information
-
-static constexpr OptionDefinition g_target_modules_list_options[] = {
 #define LLDB_OPTIONS_target_modules_list
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTargetModulesList : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_format_array(), m_use_global_module_list(false),
           m_module_addr(LLDB_INVALID_ADDRESS) {}
protected:
   }
 
   CommandOptions m_options;
 };
 
 #pragma mark CommandObjectTargetModulesShowUnwind
 
 // Lookup unwind information in images
-
-static constexpr OptionDefinition g_target_modules_show_unwind_options[] = {
 #define LLDB_OPTIONS_target_modules_show_unwind
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed {
 public:
   enum {
     eLookupTypeInvalid = -1,
     eLookupTypeAddress = 0,
     eLookupTypeSymbol,
     eLookupTypeFunction,
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
 // Lookup information in images
-
-static constexpr OptionDefinition g_target_modules_lookup_options[] = {
 #define LLDB_OPTIONS_target_modules_lookup
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTargetModulesLookup : public CommandObjectParsed {
 public:
   enum {
     eLookupTypeInvalid = -1,
     eLookupTypeAddress = 0,
     eLookupTypeSymbol,
     eLookupTypeFileLine, // Line is optional

 private:
   // For CommandObjectTargetModules only
   DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetSymbols);
 };
 
 #pragma mark CommandObjectTargetStopHookAdd
 
 // CommandObjectTargetStopHookAdd
-
-static constexpr OptionDefinition g_target_stop_hook_add_options[] = {
 #define LLDB_OPTIONS_target_stop_hook_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_line_start(0), m_line_end(UINT_MAX),

lldb/source/Commands/CommandObjectThread.cpp

protected:
   }
 
   ReturnStatus m_success_return = eReturnStatusSuccessFinishResult;
   bool m_unique_stacks = false;
   bool m_add_return = true;
 };
 
 // CommandObjectThreadBacktrace
-
-static constexpr OptionDefinition g_thread_backtrace_options[] = {
 #define LLDB_OPTIONS_thread_backtrace
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
static constexpr OptionEnumValueElement g_tri_running_mode[] = {
     {eAllThreads, "all-threads", "Run all threads"},
     {eOnlyDuringStepping, "while-stepping",
      "Run only this thread while stepping"} };
 
 static constexpr OptionEnumValues TriRunningModes() {
   return OptionEnumValues(g_tri_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_step_scope_options[] = {
 #define LLDB_OPTIONS_thread_step_scope
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()

 static constexpr OptionEnumValueElement g_duo_running_mode[] = {
     {eOnlyThisThread, "this-thread", "Run only this thread"},
     {eAllThreads, "all-threads", "Run all threads"} };
 
 static constexpr OptionEnumValues DuoRunningModes() {
   return OptionEnumValues(g_duo_running_mode);
 }
 
-static constexpr OptionDefinition g_thread_until_options[] = {
 #define LLDB_OPTIONS_thread_until
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadUntil : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     uint32_t m_thread_idx;
     uint32_t m_frame_idx;
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     process->GetStatus(strm);
     process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
                              num_frames, num_frames_with_source, false);
     return result.Succeeded();
   }
 };
 
 // CommandObjectThreadInfo
-
-static constexpr OptionDefinition g_thread_info_options[] = {
 #define LLDB_OPTIONS_thread_info
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadInfo : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
if (exception_thread_sp && exception_thread_sp->IsValid()) {
                                      num_frames_with_source, stop_format);
     }
 
     return true;
   }
 };
 
 // CommandObjectThreadReturn
-
-static constexpr OptionDefinition g_thread_return_options[] = {
 #define LLDB_OPTIONS_thread_return
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadReturn : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_from_expression(false) {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
bool DoExecute(llvm::StringRef command,
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
   CommandOptions m_options;
 };
 
 // CommandObjectThreadJump
-
-static constexpr OptionDefinition g_thread_jump_options[] = {
 #define LLDB_OPTIONS_thread_jump
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadJump : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
protected:
   }
 
   CommandOptions m_options;
 };
 
 // Next are the subcommands of CommandObjectMultiwordThreadPlan
 
 // CommandObjectThreadPlanList
-
-static constexpr OptionDefinition g_thread_plan_list_options[] = {
 #define LLDB_OPTIONS_thread_plan_list
 #include "CommandOptions.inc"
-};
 
 class CommandObjectThreadPlanList : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()

lldb/source/Commands/CommandObjectType.cpp

if (next == "int" || next == "short" || next == "char" || next == "long") {
           "name use  quotes, as in \"unsigned %s\"\n",
           next.str().c_str(), next.str().c_str());
       return true;
     }
   }
   return false;
 }
 
-static constexpr OptionDefinition g_type_summary_add_options[] = {
 #define LLDB_OPTIONS_type_summary_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
                                     public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions(CommandInterpreter &interpreter) : Options() {}
 
static const char *g_synth_addreader_instructions =
     "    def __init__(self, valobj, dict):\n"
     "    def num_children(self):\n"
     "    def get_child_at_index(self, index):\n"
     "    def get_child_index(self, name):\n"
     "    def update(self):\n"
     "        '''Optional'''\n"
     "class synthProvider:\n";
 
-static constexpr OptionDefinition g_type_synth_add_options[] = {
 #define LLDB_OPTIONS_type_synth_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeSynthAdd : public CommandObjectParsed,
                                   public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
public:
 
   static bool AddSynth(ConstString type_name, lldb::SyntheticChildrenSP entry,
                        SynthFormatType type, std::string category_name,
                        Status *error);
 };
 
 // CommandObjectTypeFormatAdd
 
-static constexpr OptionDefinition g_type_format_add_options[] = {
 #define LLDB_OPTIONS_type_format_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeFormatAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions() : OptionGroup() {}
 
     ~CommandOptions() override = default;
for (auto &arg_entry : command.entries()) {
         category_sp->GetTypeFormatsContainer()->Add(typeCS, entry);
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 };
 
-static constexpr OptionDefinition g_type_formatter_delete_options[] = {
 #define LLDB_OPTIONS_type_formatter_delete
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else {
       result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 };
 
-static constexpr OptionDefinition g_type_formatter_clear_options[] = {
 #define LLDB_OPTIONS_type_formatter_clear
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeFormatterClear : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;

 public:
   CommandObjectTypeFormatClear(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterClear(
             interpreter,
             eFormatCategoryItemValue | eFormatCategoryItemRegexValue,
             "type format clear", "Delete all existing format styles.") {}
 };
 
-
-static constexpr OptionDefinition g_type_formatter_list_options[] = {
 #define LLDB_OPTIONS_type_formatter_list
 #include "CommandOptions.inc"
-};
 
 template <typename FormatterType>
 class CommandObjectTypeFormatterList : public CommandObjectParsed {
   typedef typename FormatterType::SharedPointer FormatterSharedPointer;
 
   class CommandOptions : public Options {
   public:
     CommandOptions()
if (DataVisualization::NamedSummaryFormats::GetCount() > 0) {
           });
       return true;
     }
     return false;
   }
 };
 
 // CommandObjectTypeCategoryDefine
-
-static constexpr OptionDefinition g_type_category_define_options[] = {
 #define LLDB_OPTIONS_type_category_define
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeCategoryDefine : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_define_enabled(false, false),
           m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
 // CommandObjectTypeCategoryEnable
-
-static constexpr OptionDefinition g_type_category_enable_options[] = {
 #define LLDB_OPTIONS_type_category_enable
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
if (success) {
       result.AppendError("cannot delete one or more categories\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 };
 
 // CommandObjectTypeCategoryDisable
-
-OptionDefinition constexpr g_type_category_disable_options[] = {
 #define LLDB_OPTIONS_type_category_disable
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
if (type == eRegexSynth) {
     return true;
   } else {
     category->GetTypeSyntheticsContainer()->Add(type_name, entry);
     return true;
   }
 }
 
 #endif // LLDB_DISABLE_PYTHON
-
-static constexpr OptionDefinition g_type_filter_add_options[] = {
 #define LLDB_OPTIONS_type_filter_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeFilterAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
     typedef std::vector<std::string> option_vector;
 
   public:
     CommandOptions() : Options() {}
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 };
 
 // "type lookup"
-static constexpr OptionDefinition g_type_lookup_options[] = {
 #define LLDB_OPTIONS_type_lookup
 #include "CommandOptions.inc"
-};
 
 class CommandObjectTypeLookup : public CommandObjectRaw {
 protected:
   // this function is allowed to do a more aggressive job at guessing languages
   // than the expression parser is comfortable with - so leave the original
   // call alone and add one that is specific to type lookup
   lldb::LanguageType GuessLanguage(StackFrame *frame) {
     lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;

lldb/source/Commands/CommandObjectWatchpoint.cpp

bool CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
   // It is an error if after the loop, we're still in_range.
   return !in_range;
 }
 
 // CommandObjectWatchpointList
 
 // CommandObjectWatchpointList::Options
 #pragma mark List::CommandOptions
-
-static constexpr OptionDefinition g_watchpoint_list_options[] = {
 #define LLDB_OPTIONS_watchpoint_list
 #include "CommandOptions.inc"
-};
 
 #pragma mark List
 
 class CommandObjectWatchpointList : public CommandObjectParsed {
 public:
   CommandObjectWatchpointList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint list",
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 };
 
 // CommandObjectWatchpointIgnore
 
 #pragma mark Ignore::CommandOptions
-static constexpr OptionDefinition g_watchpoint_ignore_options[] = {
 #define LLDB_OPTIONS_watchpoint_ignore
 #include "CommandOptions.inc"
-};
 
 class CommandObjectWatchpointIgnore : public CommandObjectParsed {
 public:
   CommandObjectWatchpointIgnore(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "watchpoint ignore",
                             "Set ignore count on the specified watchpoint(s).  "
                             "If no watchpoints are specified, set them all.",
                             nullptr),

 
 private:
   CommandOptions m_options;
 };
 
 // CommandObjectWatchpointModify
 
 #pragma mark Modify::CommandOptions
-
-static constexpr OptionDefinition g_watchpoint_modify_options[] = {
 #define LLDB_OPTIONS_watchpoint_modify
 #include "CommandOptions.inc"
-};
 
 #pragma mark Modify
 
 class CommandObjectWatchpointModify : public CommandObjectParsed {
 public:
   CommandObjectWatchpointModify(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint modify",

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

static constexpr OptionEnumValueElement g_script_option_enumeration[] = {
     {eScriptLanguagePython, "python", "Commands are in the Python language."},
     {eSortOrderByName, "default-script",
      "Commands are in the default scripting language."} };
 
 static constexpr OptionEnumValues ScriptOptionEnum() {
   return OptionEnumValues(g_script_option_enumeration);
 }
 
-static constexpr OptionDefinition g_watchpoint_command_add_options[] = {
 #define LLDB_OPTIONS_watchpoint_command_add
 #include "CommandOptions.inc"
-};
 
 class CommandObjectWatchpointCommandAdd : public CommandObjectParsed,
                                           public IOHandlerDelegateMultiline {
 public:
   CommandObjectWatchpointCommandAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "add",
                             "Add a set of LLDB commands to a watchpoint, to be "
                             "executed whenever the watchpoint is hit.",

lldb/utils/TableGen/LLDBOptionDefEmitter.cpp

static void emitOption(Record *Option, raw_ostream &OS) {
   } else
     OS << "\"\"";
   OS << "},\n";
 }
 
 /// Emits all option initializers to the raw_ostream.
 static void emitOptions(std::string Command, std::vector<Record *> Option,
                         raw_ostream &OS) {
+  std::string ID = Command;
+  std::replace(ID.begin(), ID.end(), ' ', '_');
   // Generate the macro that the user needs to define before including the
   // *.inc file.
-  std::string NeededMacro = "LLDB_OPTIONS_" + Command;
-  std::replace(NeededMacro.begin(), NeededMacro.end(), ' ', '_');
+  std::string NeededMacro = "LLDB_OPTIONS_" + ID;
 
   // All options are in one file, so we need put them behind macros and ask the
   // user to define the macro for the options that are needed.
   OS << "// Options for " << Command << "\n";
   OS << "#ifdef " << NeededMacro << "\n";
+  OS << "constexpr static OptionDefinition g_" + ID + "_options[] = {\n";
   for (Record *R : Option)
     emitOption(R, OS);
   // We undefine the macro for the user like Clang's include files are doing it.
+  OS << "};\n";
   OS << "#undef " << NeededMacro << "\n";
   OS << "#endif // " << Command << " command\n\n";
 }
 
 void lldb_private::EmitOptionDefs(RecordKeeper &Records, raw_ostream &OS) {
 
   std::vector<Record *> Options = Records.getAllDerivedDefinitions("Option");
 
   emitSourceFileHeader("Options for LLDB command line commands.", OS);
 
   RecordsByCommand ByCommand = getCommandList(Options);
 
   for (auto &CommandRecordPair : ByCommand) {
     emitOptions(CommandRecordPair.first, CommandRecordPair.second, OS);
   }
 }