Convert option tables to use llvm::ArrayRefs

[zturner]

Summary

This change is very mechanical. All it does is change the signature of Options::GetDefinitions() and OptionGroup::GetDefinitions() to return an llvm::ArrayRef<OptionDefinition> instead of a const OptionDefinition*. In the case of the former, it deletes the sentinel entry from every table, and in the case of the latter, it deletes the GetNumDefinitions() method from the interface. These are no longer necessary as ArrayRef carries its own length.

The bulk of this CL is relocating the options table from one point in the file to another. This is because I removed the static OptionDefinition g_option_table from each of the classes. By raising them to the file statics instead of class statics, it should give them internal linkage, speeding up link times and possibly having positive effect on binary size. But it also means they have to appear above the option definition class instead of below, since there is no declaration.

[clayborg]

My only complaint is that many changes involve moving code from line N to line M. This will make merges harder. Is there any reason you actually moved all those C option array definitions?

[zturner]

Previously the option tables were declared as class statics and defined below the class. And only a pointer was returned, so the compiler didn't have to know about the size of the array at compile time.

In order for the compiler to know that the OptionDefinition[] is actually an OptionDefinition[7], or whatever (which is necessary in order to set the internal size member of the ArrayRef), the definition has to come before the class.

A side benefit is that this gives the arrays internal linkage, which should improve link times. A static class member still has external linkage.

[clayborg]

No, just making sure there was a reason they had to move. If there is, then this is ok.

lldb/trunk/include/lldb/Interpreter/OptionGroupArchitecture.h

 //-------------------------------------------------------------------------
 
 class OptionGroupArchitecture : public OptionGroup {
 public:
   OptionGroupArchitecture();
 
   ~OptionGroupArchitecture() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool GetArchitecture(Platform *platform, ArchSpec &arch);
 

lldb/trunk/include/lldb/Interpreter/OptionGroupBoolean.h

public:
   // inverse of the default value
   OptionGroupBoolean(uint32_t usage_mask, bool required,
                      const char *long_option, int short_option,
                      const char *usage_text, bool default_value,
                      bool no_argument_toggle_default);
 
   ~OptionGroupBoolean() override;
 
-  uint32_t GetNumDefinitions() override { return 1; }
-
-  const OptionDefinition *GetDefinitions() override {
-    return &m_option_definition;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueBoolean &GetOptionValue() { return m_value; }

lldb/trunk/include/lldb/Interpreter/OptionGroupFile.h

 public:
   OptionGroupFile(uint32_t usage_mask, bool required, const char *long_option,
                   int short_option, uint32_t completion_type,
                   lldb::CommandArgumentType argument_type,
                   const char *usage_text);
 
   ~OptionGroupFile() override;
 
-  uint32_t GetNumDefinitions() override { return 1; }
-
-  const OptionDefinition *GetDefinitions() override {
-    return &m_option_definition;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueFileSpec &GetOptionValue() { return m_file; }
public:
   OptionGroupFileList(uint32_t usage_mask, bool required,
                       const char *long_option, int short_option,
                       uint32_t completion_type,
                       lldb::CommandArgumentType argument_type,
                       const char *usage_text);
 
   ~OptionGroupFileList() override;
 
-  uint32_t GetNumDefinitions() override { return 1; }
-
-  const OptionDefinition *GetDefinitions() override {
-    return &m_option_definition;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueFileSpecList &GetOptionValue() { return m_file_list; }

lldb/trunk/include/lldb/Interpreter/OptionGroupFormat.h

OptionGroupFormat(
       lldb::Format default_format,
       uint64_t default_byte_size =
           UINT64_MAX, // Pass UINT64_MAX to disable the "--size" option
       uint64_t default_count =
           UINT64_MAX); // Pass UINT64_MAX to disable the "--count" option
 
   ~OptionGroupFormat() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   lldb::Format GetFormat() const { return m_format.GetCurrentValue(); }
 

lldb/trunk/include/lldb/Interpreter/OptionGroupOutputFile.h

 //-------------------------------------------------------------------------
 
 class OptionGroupOutputFile : public OptionGroup {
 public:
   OptionGroupOutputFile();
 
   ~OptionGroupOutputFile() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   const OptionValueFileSpec &GetFile() { return m_file; }
 

lldb/trunk/include/lldb/Interpreter/OptionGroupPlatform.h

public:
   OptionGroupPlatform(bool include_platform_option)
       : OptionGroup(), m_platform_name(), m_sdk_sysroot(),
         m_os_version_major(UINT32_MAX), m_os_version_minor(UINT32_MAX),
         m_os_version_update(UINT32_MAX),
         m_include_platform_option(include_platform_option) {}
 
   ~OptionGroupPlatform() override = default;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   lldb::PlatformSP CreatePlatformWithOptions(CommandInterpreter &interpreter,
                                              const ArchSpec &arch,

lldb/trunk/include/lldb/Interpreter/OptionGroupString.h

 public:
   OptionGroupString(uint32_t usage_mask, bool required, const char *long_option,
                     int short_option, uint32_t completion_type,
                     lldb::CommandArgumentType argument_type,
                     const char *usage_text, const char *default_value);
 
   ~OptionGroupString() override;
 
-  uint32_t GetNumDefinitions() override { return 1; }
-
-  const OptionDefinition *GetDefinitions() override {
-    return &m_option_definition;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueString &GetOptionValue() { return m_value; }

lldb/trunk/include/lldb/Interpreter/OptionGroupUInt64.h

 public:
   OptionGroupUInt64(uint32_t usage_mask, bool required, const char *long_option,
                     int short_option, uint32_t completion_type,
                     lldb::CommandArgumentType argument_type,
                     const char *usage_text, uint64_t default_value);
 
   ~OptionGroupUInt64() override;
 
-  uint32_t GetNumDefinitions() override { return 1; }
-
-  const OptionDefinition *GetDefinitions() override {
-    return &m_option_definition;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueUInt64 &GetOptionValue() { return m_value; }

lldb/trunk/include/lldb/Interpreter/OptionGroupUUID.h

 //-------------------------------------------------------------------------
 
 class OptionGroupUUID : public OptionGroup {
 public:
   OptionGroupUUID();
 
   ~OptionGroupUUID() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   const OptionValueUUID &GetOptionValue() const { return m_uuid; }
 
 protected:
   OptionValueUUID m_uuid;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupUUID_h_

lldb/trunk/include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

 //-------------------------------------------------------------------------
 
 class OptionGroupValueObjectDisplay : public OptionGroup {
 public:
   OptionGroupValueObjectDisplay();
 
   ~OptionGroupValueObjectDisplay() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool AnyOptionWasSet() const {
     return show_types || no_summary_depth != 0 || show_location ||

lldb/trunk/include/lldb/Interpreter/OptionGroupVariable.h

 //-------------------------------------------------------------------------
 
 class OptionGroupVariable : public OptionGroup {
 public:
   OptionGroupVariable(bool show_frame_options);
 
   ~OptionGroupVariable() override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool include_frame_options : 1,
       show_args : 1,    // Frame option only (include_frame_options == true)

lldb/trunk/include/lldb/Interpreter/OptionGroupWatchpoint.h

 class OptionGroupWatchpoint : public OptionGroup {
 public:
   OptionGroupWatchpoint();
 
   ~OptionGroupWatchpoint() override;
 
   static bool IsWatchSizeSupported(uint32_t watch_size);
 
-  uint32_t GetNumDefinitions() override;
-
-  const OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   // Note:
   // eWatchRead == LLDB_WATCH_TYPE_READ; and

lldb/trunk/include/lldb/Interpreter/Options.h

 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Interpreter/Args.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private.h"
 
+#include "llvm/ADT/ArrayRef.h"
+
 namespace lldb_private {
 
 static inline bool isprint8(int ch) {
   if (ch & 0xffffff00u)
     return false;
   return isprint(ch);
 }
 
public:
   void GenerateOptionUsage(Stream &strm, CommandObject *cmd,
                            uint32_t screen_width);
 
   bool SupportsLongOption(const char *long_option);
 
   // The following two pure virtual functions must be defined by every
   // class that inherits from this class.
 
-  virtual const OptionDefinition *GetDefinitions() { return nullptr; }
+  virtual llvm::ArrayRef<OptionDefinition> GetDefinitions() {
+    return llvm::ArrayRef<OptionDefinition>();
+  }
 
   // Call this prior to parsing any options. This call will call the
   // subclass OptionParsingStarting() and will avoid the need for all
   // OptionParsingStarting() function instances from having to call the
   // Option::OptionParsingStarting() like they did before. This was error
   // prone and subclasses shouldn't have to do it.
   void NotifyOptionParsingStarting(ExecutionContext *execution_context);
 

 };
 
 class OptionGroup {
 public:
   OptionGroup() = default;
 
   virtual ~OptionGroup() = default;
 
-  virtual uint32_t GetNumDefinitions() = 0;
-
-  virtual const OptionDefinition *GetDefinitions() = 0;
+  virtual llvm::ArrayRef<OptionDefinition> GetDefinitions() = 0;
 
   virtual Error SetOptionValue(uint32_t option_idx, const char *option_value,
                                ExecutionContext *execution_context) = 0;
 
   virtual void OptionParsingStarting(ExecutionContext *execution_context) = 0;
 
   virtual Error OptionParsingFinished(ExecutionContext *execution_context) {
     // If subclasses need to know when the options are done being parsed
public:
 
   Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   Error OptionParsingFinished(ExecutionContext *execution_context) override;
 
-  const OptionDefinition *GetDefinitions() override {
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     assert(m_did_finalize);
-    return &m_option_defs[0];
+    return m_option_defs;
   }
 
   const OptionGroup *GetGroupWithOption(char short_opt);
 
   struct OptionInfo {
     OptionInfo(OptionGroup *g, uint32_t i) : option_group(g), option_index(i) {}
     OptionGroup *option_group; // The group that this option came from
     uint32_t option_index;     // The original option index from the OptionGroup

lldb/trunk/include/lldb/Target/Platform.h

public:
   ~OptionGroupPlatformRSync() override = default;
 
   lldb_private::Error
   SetOptionValue(uint32_t option_idx, const char *option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-  const lldb_private::OptionDefinition *GetDefinitions() override;
-
-  uint32_t GetNumDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 
   static lldb_private::OptionDefinition g_option_table[];
 
   // Instance variables to hold the values for command options.
 
   bool m_rsync;
public:
   ~OptionGroupPlatformSSH() override = default;
 
   lldb_private::Error
   SetOptionValue(uint32_t option_idx, const char *option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const lldb_private::OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 
   static lldb_private::OptionDefinition g_option_table[];
 
   // Instance variables to hold the values for command options.
 
   bool m_ssh;
public:
   ~OptionGroupPlatformCaching() override = default;
 
   lldb_private::Error
   SetOptionValue(uint32_t option_idx, const char *option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-  uint32_t GetNumDefinitions() override;
-
-  const lldb_private::OptionDefinition *GetDefinitions() override;
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 
   static lldb_private::OptionDefinition g_option_table[];
 
   // Instance variables to hold the values for command options.
 
   std::string m_cache_dir;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformCaching);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Platform_h_

lldb/trunk/include/lldb/Target/Process.h

public:
   Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                        ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     launch_info.Clear();
     disable_aslr = eLazyBoolCalculate;
   }
 
-  const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-  // Options table: Required for subclasses of Options.
-
-  static OptionDefinition g_option_table[];
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Instance variables to hold the values for command options.
 
   ProcessLaunchInfo launch_info;
   lldb_private::LazyBool disable_aslr;
 };
 
 //----------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectArgs.h

public:
 
     ~CommandOptions() override;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-    const OptionDefinition *GetDefinitions() override;
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
   };
 
   CommandObjectArgs(CommandInterpreter &interpreter);
 
   ~CommandObjectArgs() override;
 
   Options *GetOptions() override;
 

lldb/trunk/source/Commands/CommandObjectArgs.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 // This command is a toy.  I'm just using it to have a way to construct the
 // arguments to
 // calling functions.
 //
 
+static OptionDefinition g_arg_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "debug", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation." },
+    // clang-format on
+};
+
 CommandObjectArgs::CommandOptions::CommandOptions(
     CommandInterpreter &interpreter)
     : Options() {
   // Keep only one place to reset the values to their defaults
   OptionParsingStarting(nullptr);
 }
 
 CommandObjectArgs::CommandOptions::~CommandOptions() = default;
 
 Error CommandObjectArgs::CommandOptions::SetOptionValue(
     uint32_t option_idx, const char *option_arg,
     ExecutionContext *execution_context) {
   Error error;
 
   const int short_option = m_getopt_table[option_idx].val;
   error.SetErrorStringWithFormat("invalid short option character '%c'",
                                  short_option);
 
   return error;
 }
 
 void CommandObjectArgs::CommandOptions::OptionParsingStarting(
     ExecutionContext *execution_context) {}
 
-const OptionDefinition *CommandObjectArgs::CommandOptions::GetDefinitions() {
-  return g_option_table;
+llvm::ArrayRef<OptionDefinition>
+CommandObjectArgs::CommandOptions::GetDefinitions() {
+  return g_arg_options;
 }
 
 CommandObjectArgs::CommandObjectArgs(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "args",
                           "When stopped at the start of a function, reads "
                           "function arguments of type (u?)int(8|16|32|64)_t, "
                           "(void|char)*",
                           "args"),
for (arg_index = 0; arg_index < num_args; ++arg_index) {
     result.GetOutputStream().Printf("%" PRIu64 " (%s): ", (uint64_t)arg_index,
                                     args.GetArgumentAtIndex(arg_index));
     value_list.GetValueAtIndex(arg_index)->Dump(&result.GetOutputStream());
     result.GetOutputStream().Printf("\n");
   }
 
   return result.Succeeded();
 }
-
-OptionDefinition CommandObjectArgs::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_1, false, "debug", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

 static void AddBreakpointDescription(Stream *s, Breakpoint *bp,
                                      lldb::DescriptionLevel level) {
   s->IndentMore();
   bp->GetDescription(s, level, true);
   s->IndentLess();
   s->EOL();
 }
 
+// If an additional option set beyond LLDB_OPTION_SET_10 is added, make sure to
+// update the numbers passed to LLDB_OPT_SET_FROM_TO(...) appropriately.
+#define LLDB_OPT_FILE (LLDB_OPT_SET_FROM_TO(1, 9) & ~LLDB_OPT_SET_2)
+#define LLDB_OPT_NOT_10 (LLDB_OPT_SET_FROM_TO(1, 10) & ~LLDB_OPT_SET_10)
+#define LLDB_OPT_SKIP_PROLOGUE (LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3, 8))
+#define LLDB_OPT_OFFSET_APPLIES (LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3, 8))
+#define LLDB_OPT_MOVE_TO_NEAREST_CODE (LLDB_OPT_SET_1 | LLDB_OPT_SET_9)
+#define LLDB_OPT_EXPR_LANGUAGE (LLDB_OPT_SET_FROM_TO(3, 8))
+
+static OptionDefinition g_breakpoint_set_options[] = {
+    // clang-format off
+  { LLDB_OPT_NOT_10,               false, "shlib",                  's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Set the breakpoint only in this shared library.  Can repeat this option "
+  "multiple times to specify multiple shared libraries." },
+  { LLDB_OPT_SET_ALL,              false, "ignore-count",           'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "Set the number of times this breakpoint is skipped before stopping." },
+  { LLDB_OPT_SET_ALL,              false, "one-shot",               'o', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "The breakpoint is deleted the first time it causes a stop." },
+  { LLDB_OPT_SET_ALL,              false, "condition",              'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeExpression,          "The breakpoint stops only if this condition expression evaluates to true." },
+  { LLDB_OPT_SET_ALL,              false, "thread-index",           'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadIndex,         "The breakpoint stops only for the thread whose indeX matches this argument." },
+  { LLDB_OPT_SET_ALL,              false, "thread-id",              't', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadID,            "The breakpoint stops only for the thread whose TID matches this argument." },
+  { LLDB_OPT_SET_ALL,              false, "thread-name",            'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadName,          "The breakpoint stops only for the thread whose thread name matches this "
+  "argument." },
+  { LLDB_OPT_SET_ALL,              false, "hardware",               'H', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Require the breakpoint to use hardware breakpoints." },
+  { LLDB_OPT_SET_ALL,              false, "queue-name",             'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeQueueName,           "The breakpoint stops only for threads in the queue whose name is given by "
+  "this argument." },
+  { LLDB_OPT_FILE,                 false, "file",                   'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "Specifies the source file in which to set this breakpoint.  Note, by default "
+  "lldb only looks for files that are #included if they use the standard include "
+  "file extensions.  To set breakpoints on .c/.cpp/.m/.mm files that are "
+  "#included, set target.inline-breakpoint-strategy to \"always\"." },
+  { LLDB_OPT_SET_1,                true,  "line",                   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "Specifies the line number on which to set this breakpoint." },
+
+  // Comment out this option for the moment, as we don't actually use it, but will in the future.
+  // This way users won't see it, but the infrastructure is left in place.
+  //    { 0, false, "column",     'C', OptionParser::eRequiredArgument, nullptr, "<column>",
+  //    "Set the breakpoint by source location at this particular column."},
+
+  { LLDB_OPT_SET_2,                true,  "address",                'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Set the breakpoint at the specified address.  If the address maps uniquely to "
+  "a particular binary, then the address will be converted to a \"file\" "
+  "address, so that the breakpoint will track that binary+offset no matter where "
+  "the binary eventually loads.  Alternately, if you also specify the module - "
+  "with the -s option - then the address will be treated as a file address in "
+  "that module, and resolved accordingly.  Again, this will allow lldb to track "
+  "that offset on subsequent reloads.  The module need not have been loaded at "
+  "the time you specify this breakpoint, and will get resolved when the module "
+  "is loaded." },
+  { LLDB_OPT_SET_3,                true,  "name",                   'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "Set the breakpoint by function name.  Can be repeated multiple times to make "
+  "one breakpoint for multiple names" },
+  { LLDB_OPT_SET_9,                false, "source-regexp-function", 'X', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "When used with '-p' limits the source regex to source contained in the named "
+  "functions.  Can be repeated multiple times." },
+  { LLDB_OPT_SET_4,                true,  "fullname",               'F', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFullName,            "Set the breakpoint by fully qualified function names. For C++ this means "
+  "namespaces and all arguments, and for Objective C this means a full function "
+  "prototype with class and selector.  Can be repeated multiple times to make "
+  "one breakpoint for multiple names." },
+  { LLDB_OPT_SET_5,                true,  "selector",               'S', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeSelector,            "Set the breakpoint by ObjC selector name. Can be repeated multiple times to "
+  "make one breakpoint for multiple Selectors." },
+  { LLDB_OPT_SET_6,                true,  "method",                 'M', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeMethod,              "Set the breakpoint by C++ method names.  Can be repeated multiple times to "
+  "make one breakpoint for multiple methods." },
+  { LLDB_OPT_SET_7,                true,  "func-regex",             'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeRegularExpression,   "Set the breakpoint by function name, evaluating a regular-expression to find "
+  "the function name(s)." },
+  { LLDB_OPT_SET_8,                true,  "basename",               'b', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "Set the breakpoint by function basename (C++ namespaces and arguments will be "
+  "ignored).  Can be repeated multiple times to make one breakpoint for multiple "
+  "symbols." },
+  { LLDB_OPT_SET_9,                true,  "source-pattern-regexp",  'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeRegularExpression,   "Set the breakpoint by specifying a regular expression which is matched "
+  "against the source text in a source file or files specified with the -f "
+  "option.  The -f option can be specified more than once.  If no source files "
+  "are specified, uses the current \"default source file\".  If you want to "
+  "match against all source files, pass the \"--all-files\" option." },
+  { LLDB_OPT_SET_9,                false, "all-files",              'A', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "All files are searched for source pattern matches." },
+  { LLDB_OPT_SET_10,               true,  "language-exception",     'E', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLanguage,            "Set the breakpoint on exceptions thrown by the specified language (without "
+  "options, on throw but not catch.)" },
+  { LLDB_OPT_SET_10,               false, "on-throw",               'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Set the breakpoint on exception throW." },
+  { LLDB_OPT_SET_10,               false, "on-catch",               'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Set the breakpoint on exception catcH." },
+
+  //  Don't add this option till it actually does something useful...
+  //    { LLDB_OPT_SET_10, false, "exception-typename", 'O', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeTypeName,
+  //        "The breakpoint will only stop if an exception Object of this type is thrown.  Can be repeated multiple times to stop for multiple object types" },
+
+  { LLDB_OPT_EXPR_LANGUAGE,        false, "language",               'L', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLanguage,            "Specifies the Language to use when interpreting the breakpoint's expression "
+  "(note: currently only implemented for setting breakpoints on identifiers).  "
+  "If not set the target.language setting is used." },
+  { LLDB_OPT_SKIP_PROLOGUE,        false, "skip-prologue",          'K', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "sKip the prologue if the breakpoint is at the beginning of a function.  "
+  "If not set the target.skip-prologue setting is used." },
+  { LLDB_OPT_SET_ALL,              false, "dummy-breakpoints",      'D', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, "
+  "which prime new targets." },
+  { LLDB_OPT_SET_ALL,              false, "breakpoint-name",        'N', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBreakpointName,      "Adds this to the list of names for this breakpoint." },
+  { LLDB_OPT_OFFSET_APPLIES,       false, "address-slide",          'R', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddress,             "Add the specified offset to whatever address(es) the breakpoint resolves to.  "
+  "At present this applies the offset directly as given, and doesn't try to align it to instruction boundaries." },
+  { LLDB_OPT_MOVE_TO_NEAREST_CODE, false, "move-to-nearest-code", 'm', OptionParser::eRequiredArgument,   nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Move breakpoints to nearest code. If not set the target.move-to-nearest-code "
+  "setting is used." },
+    // clang-format on
+};
+
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointSet
 //-------------------------------------------------------------------------
 
 class CommandObjectBreakpointSet : public CommandObjectParsed {
 public:
   typedef enum BreakpointSetType {
     eSetTypeInvalid,
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
       m_breakpoint_names.clear();
       m_all_files = false;
       m_exception_extra_args.Clear();
       m_move_to_nearest_code = eLazyBoolCalculate;
       m_source_regex_func_names.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_set_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     FileSpecList m_filenames;
     uint32_t m_line_num;
     uint32_t m_column;
     std::vector<std::string> m_func_names;
if (!target->GetSourceManager().GetDefaultFileAndLine(file, default_line)) {
       }
     }
     return true;
   }
 
   CommandOptions m_options;
 };
 
-// If an additional option set beyond LLDB_OPTION_SET_10 is added, make sure to
-// update the numbers passed to LLDB_OPT_SET_FROM_TO(...) appropriately.
-#define LLDB_OPT_FILE (LLDB_OPT_SET_FROM_TO(1, 9) & ~LLDB_OPT_SET_2)
-#define LLDB_OPT_NOT_10 (LLDB_OPT_SET_FROM_TO(1, 10) & ~LLDB_OPT_SET_10)
-#define LLDB_OPT_SKIP_PROLOGUE (LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3, 8))
-#define LLDB_OPT_OFFSET_APPLIES (LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3, 8))
-#define LLDB_OPT_MOVE_TO_NEAREST_CODE (LLDB_OPT_SET_1 | LLDB_OPT_SET_9)
-#define LLDB_OPT_EXPR_LANGUAGE (LLDB_OPT_SET_FROM_TO(3, 8))
+//-------------------------------------------------------------------------
+// CommandObjectBreakpointModify
+//-------------------------------------------------------------------------
 
-OptionDefinition CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_NOT_10,               false, "shlib",                  's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Set the breakpoint only in this shared library.  Can repeat this option "
-                                                                                                                                                                                                   "multiple times to specify multiple shared libraries."},
-  {LLDB_OPT_SET_ALL,              false, "ignore-count",           'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "Set the number of times this breakpoint is skipped before stopping." },
-  {LLDB_OPT_SET_ALL,              false, "one-shot",               'o', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "The breakpoint is deleted the first time it causes a stop." },
-  {LLDB_OPT_SET_ALL,              false, "condition",              'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeExpression,          "The breakpoint stops only if this condition expression evaluates to true."},
-  {LLDB_OPT_SET_ALL,              false, "thread-index",           'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadIndex,         "The breakpoint stops only for the thread whose indeX matches this argument."},
-  {LLDB_OPT_SET_ALL,              false, "thread-id",              't', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadID,            "The breakpoint stops only for the thread whose TID matches this argument."},
-  {LLDB_OPT_SET_ALL,              false, "thread-name",            'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeThreadName,          "The breakpoint stops only for the thread whose thread name matches this "
-                                                                                                                                                                                                   "argument."},
-  {LLDB_OPT_SET_ALL,              false, "hardware",               'H', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Require the breakpoint to use hardware breakpoints."},
-  {LLDB_OPT_SET_ALL,              false, "queue-name",             'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeQueueName,           "The breakpoint stops only for threads in the queue whose name is given by "
-                                                                                                                                                                                                   "this argument."},
-  {LLDB_OPT_FILE,                 false, "file",                   'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "Specifies the source file in which to set this breakpoint.  Note, by default "
-                                                                                                                                                                                                   "lldb only looks for files that are #included if they use the standard include "
-                                                                                                                                                                                                   "file extensions.  To set breakpoints on .c/.cpp/.m/.mm files that are "
-                                                                                                                                                                                                   "#included, set target.inline-breakpoint-strategy to \"always\"."},
-  {LLDB_OPT_SET_1,                true,  "line",                   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "Specifies the line number on which to set this breakpoint."},
-
-    // Comment out this option for the moment, as we don't actually use it, but will in the future.
-    // This way users won't see it, but the infrastructure is left in place.
-    //    { 0, false, "column",     'C', OptionParser::eRequiredArgument, nullptr, "<column>",
-    //    "Set the breakpoint by source location at this particular column."},
-
-  {LLDB_OPT_SET_2,                true,  "address",                'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Set the breakpoint at the specified address.  If the address maps uniquely to "
-                                                                                                                                                                                                   "a particular binary, then the address will be converted to a \"file\" "
-                                                                                                                                                                                                   "address, so that the breakpoint will track that binary+offset no matter where "
-                                                                                                                                                                                                   "the binary eventually loads.  Alternately, if you also specify the module - "
-                                                                                                                                                                                                   "with the -s option - then the address will be treated as a file address in "
-                                                                                                                                                                                                   "that module, and resolved accordingly.  Again, this will allow lldb to track "
-                                                                                                                                                                                                   "that offset on subsequent reloads.  The module need not have been loaded at "
-                                                                                                                                                                                                   "the time you specify this breakpoint, and will get resolved when the module "
-                                                                                                                                                                                                   "is loaded."},
-  {LLDB_OPT_SET_3,                true,  "name",                   'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "Set the breakpoint by function name.  Can be repeated multiple times to make "
-                                                                                                                                                                                                   "one breakpoint for multiple names"},
-  {LLDB_OPT_SET_9,                false, "source-regexp-function", 'X', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "When used with '-p' limits the source regex to source contained in the named "
-                                                                                                                                                                                                   "functions.  Can be repeated multiple times."},
-  {LLDB_OPT_SET_4,                true,  "fullname",               'F', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFullName,            "Set the breakpoint by fully qualified function names. For C++ this means "
-                                                                                                                                                                                                   "namespaces and all arguments, and for Objective C this means a full function "
-                                                                                                                                                                                                   "prototype with class and selector.  Can be repeated multiple times to make "
-                                                                                                                                                                                                   "one breakpoint for multiple names."},
-  {LLDB_OPT_SET_5,                true,  "selector",               'S', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeSelector,            "Set the breakpoint by ObjC selector name. Can be repeated multiple times to "
-                                                                                                                                                                                                   "make one breakpoint for multiple Selectors."},
-  {LLDB_OPT_SET_6,                true,  "method",                 'M', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeMethod,              "Set the breakpoint by C++ method names.  Can be repeated multiple times to "
-                                                                                                                                                                                                   "make one breakpoint for multiple methods."},
-  {LLDB_OPT_SET_7,                true,  "func-regex",             'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeRegularExpression,   "Set the breakpoint by function name, evaluating a regular-expression to find "
-                                                                                                                                                                                                   "the function name(s)."},
-  {LLDB_OPT_SET_8,                true,  "basename",               'b', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeFunctionName,        "Set the breakpoint by function basename (C++ namespaces and arguments will be "
-                                                                                                                                                                                                   "ignored).  Can be repeated multiple times to make one breakpoint for multiple "
-                                                                                                                                                                                                   "symbols."},
-  {LLDB_OPT_SET_9,                true,  "source-pattern-regexp",  'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeRegularExpression,   "Set the breakpoint by specifying a regular expression which is matched "
-                                                                                                                                                                                                   "against the source text in a source file or files specified with the -f "
-                                                                                                                                                                                                   "option.  The -f option can be specified more than once.  If no source files "
-                                                                                                                                                                                                   "are specified, uses the current \"default source file\".  If you want to "
-                                                                                                                                                                                                   "match against all source files, pass the \"--all-files\" option."},
-  {LLDB_OPT_SET_9,                false, "all-files",              'A', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "All files are searched for source pattern matches."},
-  {LLDB_OPT_SET_10,               true,  "language-exception",     'E', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLanguage,            "Set the breakpoint on exceptions thrown by the specified language (without "
-                                                                                                                                                                                                   "options, on throw but not catch.)"},
-  {LLDB_OPT_SET_10,               false, "on-throw",               'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Set the breakpoint on exception throW."},
-  {LLDB_OPT_SET_10,               false, "on-catch",               'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Set the breakpoint on exception catcH."},
-
-//  Don't add this option till it actually does something useful...
-//    { LLDB_OPT_SET_10, false, "exception-typename", 'O', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeTypeName,
-//        "The breakpoint will only stop if an exception Object of this type is thrown.  Can be repeated multiple times to stop for multiple object types" },
-
-  {LLDB_OPT_EXPR_LANGUAGE,        false, "language",               'L', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLanguage,            "Specifies the Language to use when interpreting the breakpoint's expression "
-                                                                                                                                                                                                   "(note: currently only implemented for setting breakpoints on identifiers).  "
-                                                                                                                                                                                                   "If not set the target.language setting is used."},
-  {LLDB_OPT_SKIP_PROLOGUE,        false, "skip-prologue",          'K', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBoolean,             "sKip the prologue if the breakpoint is at the beginning of a function.  "
-                                                                                                                                                                                                   "If not set the target.skip-prologue setting is used."},
-  {LLDB_OPT_SET_ALL,              false, "dummy-breakpoints",      'D', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, "
-                                                                                                                                                                                                   "which prime new targets."},
-  {LLDB_OPT_SET_ALL,              false, "breakpoint-name",        'N', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeBreakpointName,      "Adds this to the list of names for this breakpoint."},
-  {LLDB_OPT_OFFSET_APPLIES,       false, "address-slide",          'R', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddress,             "Add the specified offset to whatever address(es) the breakpoint resolves to.  "
-        "At present this applies the offset directly as given, and doesn't try to align it to instruction boundaries."},
-  {LLDB_OPT_MOVE_TO_NEAREST_CODE, false, "move-to-nearest-code", 'm', OptionParser::eRequiredArgument,   nullptr, nullptr, 0,                                         eArgTypeBoolean,             "Move breakpoints to nearest code. If not set the target.move-to-nearest-code "
-                                                                                                                                                                                                   "setting is used."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+#pragma mark Modify::CommandOptions
+static OptionDefinition g_breakpoint_modify_options[] = {
+  { LLDB_OPT_SET_ALL, false, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,       "Set the number of times this breakpoint is skipped before stopping." },
+  { LLDB_OPT_SET_ALL, false, "one-shot",     'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,     "The breakpoint is deleted the first time it stop causes a stop." },
+  { LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadIndex, "The breakpoint stops only for the thread whose index matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadID,    "The breakpoint stops only for the thread whose TID matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadName,  "The breakpoint stops only for the thread whose thread name matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeQueueName,   "The breakpoint stops only for threads in the queue whose name is given by this argument." },
+  { LLDB_OPT_SET_ALL, false, "condition",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpression,  "The breakpoint stops only if this condition expression evaluates to true." },
+  { LLDB_OPT_SET_1,   false, "enable",       'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Enable the breakpoint." },
+  { LLDB_OPT_SET_2,   false, "disable",      'd', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Disable the breakpoint." },
+  { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,  nullptr, nullptr, 0, eArgTypeNone,        "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectBreakpointModify
-//-------------------------------------------------------------------------
 #pragma mark Modify
 
 class CommandObjectBreakpointModify : public CommandObjectParsed {
 public:
   CommandObjectBreakpointModify(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint modify",
                             "Modify the options on a breakpoint or set of "
                             "breakpoints in the executable.  "
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_enable_passed = false;
       m_queue_passed = false;
       m_name_passed = false;
       m_condition_passed = false;
       m_one_shot_passed = false;
       m_use_dummy = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_modify_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_ignore_count;
     lldb::tid_t m_thread_id;
     bool m_thread_id_passed;
     uint32_t m_thread_index;
     bool m_thread_index_passed;
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Modify::CommandOptions
-OptionDefinition
-    CommandObjectBreakpointModify::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,       "Set the number of times this breakpoint is skipped before stopping."},
-  {LLDB_OPT_SET_ALL, false, "one-shot",     'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,     "The breakpoint is deleted the first time it stop causes a stop."},
-  {LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadIndex, "The breakpoint stops only for the thread whose index matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadID,    "The breakpoint stops only for the thread whose TID matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadName,  "The breakpoint stops only for the thread whose thread name matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeQueueName,   "The breakpoint stops only for threads in the queue whose name is given by this argument."},
-  {LLDB_OPT_SET_ALL, false, "condition",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpression,  "The breakpoint stops only if this condition expression evaluates to true."},
-  {LLDB_OPT_SET_1,   false, "enable",       'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Enable the breakpoint."},
-  {LLDB_OPT_SET_2,   false, "disable",      'd', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Disable the breakpoint."},
-  {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,  nullptr, nullptr, 0, eArgTypeNone,        "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointEnable
 //-------------------------------------------------------------------------
 #pragma mark Enable
 
 class CommandObjectBreakpointEnable : public CommandObjectParsed {
 public:
   CommandObjectBreakpointEnable(CommandInterpreter &interpreter)
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointList
 //-------------------------------------------------------------------------
+
+#pragma mark List::CommandOptions
+static OptionDefinition g_breakpoint_list_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "internal",          'i', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Show debugger internal breakpoints" },
+  { LLDB_OPT_SET_1,   false, "brief",             'b', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a brief description of the breakpoint (no location info)." },
+  // FIXME: We need to add an "internal" command, and then add this sort of thing to it.
+  // But I need to see it for now, and don't want to wait.
+  { LLDB_OPT_SET_2,   false, "full",              'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a full description of the breakpoint and its locations." },
+  { LLDB_OPT_SET_3,   false, "verbose",           'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Explain everything we know about the breakpoint (for debugging debugger bugs)." },
+  { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "List Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
+    // clang-format on
+};
+
 #pragma mark List
 
 class CommandObjectBreakpointList : public CommandObjectParsed {
 public:
   CommandObjectBreakpointList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "breakpoint list",
             "List some or all breakpoints at configurable levels of detail.",
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_level = lldb::eDescriptionLevelFull;
       m_internal = false;
       m_use_dummy = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_list_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     lldb::DescriptionLevel m_level;
 
     bool m_internal;
     bool m_use_dummy;
   };
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark List::CommandOptions
-OptionDefinition CommandObjectBreakpointList::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-    {LLDB_OPT_SET_ALL, false, "internal",          'i', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Show debugger internal breakpoints" },
-    {LLDB_OPT_SET_1,   false, "brief",             'b', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a brief description of the breakpoint (no location info)."},
-    // FIXME: We need to add an "internal" command, and then add this sort of thing to it.
-    // But I need to see it for now, and don't want to wait.
-    {LLDB_OPT_SET_2,   false, "full",              'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a full description of the breakpoint and its locations."},
-    {LLDB_OPT_SET_3,   false, "verbose",           'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Explain everything we know about the breakpoint (for debugging debugger bugs)."},
-    {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "List Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectBreakpointClear
+//-------------------------------------------------------------------------
+#pragma mark Clear::CommandOptions
+
+static OptionDefinition g_breakpoint_clear_options[] = {
+  { LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the breakpoint by source location in this particular file." },
+  { LLDB_OPT_SET_1, true,  "line", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,  "Specify the breakpoint by source location at this particular line." }
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectBreakpointClear
-//-------------------------------------------------------------------------
 #pragma mark Clear
 
 class CommandObjectBreakpointClear : public CommandObjectParsed {
 public:
   typedef enum BreakpointClearType {
     eClearTypeInvalid,
     eClearTypeFileAndLine
   } BreakpointClearType;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
       m_line_num = 0;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_clear_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_filename;
     uint32_t m_line_num;
   };
 
 protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Clear::CommandOptions
-
-OptionDefinition
-    CommandObjectBreakpointClear::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the breakpoint by source location in this particular file."},
-  {LLDB_OPT_SET_1, true,  "line", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,  "Specify the breakpoint by source location at this particular line."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectBreakpointDelete
+//-------------------------------------------------------------------------
+static OptionDefinition g_breakpoint_delete_options[] = {
+  { LLDB_OPT_SET_1, false, "force",             'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete all breakpoints without querying for confirmation." },
+  { LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectBreakpointDelete
-//-------------------------------------------------------------------------
 #pragma mark Delete
 
 class CommandObjectBreakpointDelete : public CommandObjectParsed {
 public:
   CommandObjectBreakpointDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint delete",
                             "Delete the specified breakpoint(s).  If no "
                             "breakpoints are specified, delete them all.",
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
       m_force = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_delete_options;
+    }
 
     // Instance variables to hold the values for command options.
     bool m_use_dummy;
     bool m_force;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectBreakpointDelete::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "force",             'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete all breakpoints without querying for confirmation."},
-  {LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointName
 //-------------------------------------------------------------------------
 
 static OptionDefinition g_breakpoint_name_options[] = {
     // clang-format off
   {LLDB_OPT_SET_1,   false, "name",              'N', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBreakpointName, "Specifies a breakpoint name to use."},
   {LLDB_OPT_SET_2,   false, "breakpoint-id",     'B', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBreakpointID,   "Specify a breakpoint ID to use."},
   {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Operate on Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
     // clang-format on
 };
 class BreakpointNameOptionGroup : public OptionGroup {
 public:
   BreakpointNameOptionGroup()
       : OptionGroup(), m_breakpoint(LLDB_INVALID_BREAK_ID), m_use_dummy(false) {
   }
 
   ~BreakpointNameOptionGroup() override = default;
 
-  uint32_t GetNumDefinitions() override {
-    return sizeof(g_breakpoint_name_options) / sizeof(OptionDefinition);
-  }
-
-  const OptionDefinition *GetDefinitions() override {
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return g_breakpoint_name_options;
   }
 
   Error SetOptionValue(uint32_t option_idx, const char *option_value,
                        ExecutionContext *execution_context) override {
     Error error;
     const int short_option = g_breakpoint_name_options[option_idx].short_option;
     llvm::StringRef option_strref(option_value ? option_value : "");
public:
   }
 
   ~CommandObjectBreakpointName() override = default;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointRead
 //-------------------------------------------------------------------------
-#pragma mark Restore
+#pragma mark Modify::CommandOptions
+static OptionDefinition g_breakpoint_read_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,    "The file from which to read the breakpoints." },
+    // clang-format on
+};
+
+#pragma mark Read
 
 class CommandObjectBreakpointRead : public CommandObjectParsed {
 public:
   CommandObjectBreakpointRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "breakpoint read",
                             "Read and set the breakpoints previously saved to "
                             "a file with \"breakpoint write\".  ",
                             nullptr),
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_read_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_filename;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // FIXME: Report the newly created breakpoints.
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Modify::CommandOptions
-OptionDefinition CommandObjectBreakpointRead::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,    "The file from which to read the breakpoints."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectBreakpointWrite
+//-------------------------------------------------------------------------
+#pragma mark Write::CommandOptions
+static OptionDefinition g_breakpoint_write_options[] = {
+  { LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,    "The file into which to write the breakpoints." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectBreakpointWrite
-//-------------------------------------------------------------------------
-#pragma mark Save
+#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\".  "
                             "If given no arguments, writes all breakpoints.",
                             nullptr),
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_filename.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_write_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_filename;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Modify::CommandOptions
-OptionDefinition
-    CommandObjectBreakpointWrite::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eDiskFileCompletion, eArgTypeFilename,    "The file into which to write the breakpoints."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordBreakpoint
 //-------------------------------------------------------------------------
 #pragma mark MultiwordBreakpoint
 
 CommandObjectMultiwordBreakpoint::CommandObjectMultiwordBreakpoint(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointCommandAdd
 //-------------------------------------------------------------------------
 
+// FIXME: "script-type" needs to have its contents determined dynamically, so
+// somebody can add a new scripting
+// language to lldb and have it pickable here without having to change this
+// enumeration by hand and rebuild lldb proper.
+
+static OptionEnumValueElement g_script_option_enumeration[4] = {
+    {eScriptLanguageNone, "command",
+     "Commands are in the lldb command interpreter language"},
+    {eScriptLanguagePython, "python", "Commands are in the Python language."},
+    {eSortOrderByName, "default-script",
+     "Commands are in the default scripting language."},
+    {0, nullptr, nullptr}};
+
+static OptionDefinition g_breakpoint_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1,   false, "one-liner",         'o', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeOneLiner,       "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
+  { LLDB_OPT_SET_ALL, false, "stop-on-error",     'e', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeBoolean,        "Specify whether breakpoint command execution should terminate on error." },
+  { LLDB_OPT_SET_ALL, false, "script-type",       's', OptionParser::eRequiredArgument, nullptr, g_script_option_enumeration, 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used." },
+  { LLDB_OPT_SET_2,   false, "python-function",   'F', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate." },
+  { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,       nullptr, nullptr,                     0, eArgTypeNone,           "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
+    // clang-format on
+};
+
 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."
                             "  If no breakpoint is specified, adds the "
Error SetOptionValue(uint32_t option_idx, const char *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)Args::StringToOptionEnum(
-            option_arg, g_option_table[option_idx].enum_values,
+            option_arg, g_breakpoint_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;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_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;
 
     // Instance variables to hold the values for one_liner options.
private:
   // so it isn't worthwhile to come up with a more complex mechanism
   // to address this particular weakness right now.
   static const char *g_reader_instructions;
 };
 
 const char *CommandObjectBreakpointCommandAdd::g_reader_instructions =
     "Enter your debugger command(s).  Type 'DONE' to end.\n";
 
-// FIXME: "script-type" needs to have its contents determined dynamically, so
-// somebody can add a new scripting
-// language to lldb and have it pickable here without having to change this
-// enumeration by hand and rebuild lldb proper.
-
-static OptionEnumValueElement g_script_option_enumeration[4] = {
-    {eScriptLanguageNone, "command",
-     "Commands are in the lldb command interpreter language"},
-    {eScriptLanguagePython, "python", "Commands are in the Python language."},
-    {eSortOrderByName, "default-script",
-     "Commands are in the default scripting language."},
-    {0, nullptr, nullptr}};
+//-------------------------------------------------------------------------
+// CommandObjectBreakpointCommandDelete
+//-------------------------------------------------------------------------
 
-OptionDefinition
-    CommandObjectBreakpointCommandAdd::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1,   false, "one-liner",         'o', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeOneLiner,       "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
-  {LLDB_OPT_SET_ALL, false, "stop-on-error",     'e', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeBoolean,        "Specify whether breakpoint command execution should terminate on error." },
-  {LLDB_OPT_SET_ALL, false, "script-type",       's', OptionParser::eRequiredArgument, nullptr, g_script_option_enumeration, 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
-  {LLDB_OPT_SET_2,   false, "python-function",   'F', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this breakpoint. Be sure to give a module name if appropriate."},
-  {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument,       nullptr, nullptr,                     0, eArgTypeNone,           "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+static OptionDefinition g_breakpoint_delete_options[] = {
+  { LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete commands from Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectBreakpointCommandDelete
-//-------------------------------------------------------------------------
-
 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed {
 public:
   CommandObjectBreakpointCommandDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "delete",
                             "Delete the set of commands from a breakpoint.",
                             nullptr),
         m_options() {
     CommandArgumentEntry arg;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_breakpoint_delete_options;
+    }
 
     // Instance variables to hold the values for command options.
     bool m_use_dummy;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectBreakpointCommandDelete::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Delete commands from Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointCommandList
 //-------------------------------------------------------------------------
 
 class CommandObjectBreakpointCommandList : public CommandObjectParsed {
 public:
   CommandObjectBreakpointCommandList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "list", "List the script or set of "

lldb/trunk/source/Commands/CommandObjectCommands.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsSource
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_history_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "count",       'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "How many history commands to print." },
+  { LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)." },
+  { LLDB_OPT_SET_1, false, "end-index",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to stop printing history commands." },
+  { LLDB_OPT_SET_2, false, "clear",       'C', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeBoolean,         "Clears the current command history." },
+    // clang-format on
+};
+
 class CommandObjectCommandsHistory : public CommandObjectParsed {
 public:
   CommandObjectCommandsHistory(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command history",
                             "Dump the history of commands in this session.",
                             nullptr),
         m_options() {}
 
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_start_idx.Clear();
       m_stop_idx.Clear();
       m_count.Clear();
       m_clear.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_history_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     OptionValueUInt64 m_start_idx;
     OptionValueUInt64 m_stop_idx;
     OptionValueUInt64 m_count;
     OptionValueBoolean m_clear;
   };
if (m_options.m_clear.GetCurrentValue() &&
       }
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectCommandsHistory::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "count",       'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "How many history commands to print."},
-  {LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)."},
-  {LLDB_OPT_SET_1, false, "end-index",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to stop printing history commands."},
-  {LLDB_OPT_SET_2, false, "clear",       'C', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeBoolean,         "Clears the current command history."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectCommandsSource
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_source_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "stop-on-error",    'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on error." },
+  { LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on continue." },
+  { LLDB_OPT_SET_ALL, false, "silent-run",       's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true don't echo commands while executing." },
+    // clang-format on
+};
+
 class CommandObjectCommandsSource : public CommandObjectParsed {
 public:
   CommandObjectCommandsSource(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "command source",
             "Read and execute LLDB commands from the file <filename>.",
             nullptr),
         m_options() {
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_stop_on_error.Clear();
       m_silent_run.Clear();
       m_stop_on_continue.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_source_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     OptionValueBoolean m_stop_on_error;
     OptionValueBoolean m_silent_run;
     OptionValueBoolean m_stop_on_continue;
   };
 
if (argc == 1) {
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectCommandsSource::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "stop-on-error",    'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on error."},
-  {LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on continue."},
-  {LLDB_OPT_SET_ALL, false, "silent-run",       's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true don't echo commands while executing."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 #pragma mark CommandObjectCommandsAlias
 //-------------------------------------------------------------------------
 // CommandObjectCommandsAlias
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_alias_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "help",      'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Help text for this command" },
+  { LLDB_OPT_SET_ALL, false, "long-help", 'H', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Long help text for this command" },
+    // clang-format on
+};
+
 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:
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions() : OptionGroup(), m_help(), m_long_help() {}
 
     ~CommandOptions() override = default;
 
-    uint32_t GetNumDefinitions() override { return 3; }
-
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_alias_options;
+    }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override {
       Error error;
 
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option = GetDefinitions()[option_idx].short_option;
 
       switch (short_option) {
       case 'h':
         m_help.SetCurrentValue(option_value);
         m_help.SetOptionWasSet();
         break;
 
       case 'H':
Error SetOptionValue(uint32_t option_idx, const char *option_value,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_help.Clear();
       m_long_help.Clear();
     }
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
     OptionValueString m_help;
     OptionValueString m_long_help;
   };
 
   OptionGroupOptions m_option_group;
   CommandOptions m_command_options;
 
 public:
if (m_interpreter.CommandExists(alias_command.c_str())) {
         return false;
       }
     }
 
     return result.Succeeded();
   }
 };
 
-OptionDefinition CommandObjectCommandsAlias::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "help",      'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Help text for this command"},
-  {LLDB_OPT_SET_ALL, false, "long-help", 'H', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Long help text for this command"},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 #pragma mark CommandObjectCommandsUnalias
 //-------------------------------------------------------------------------
 // CommandObjectCommandsUnalias
 //-------------------------------------------------------------------------
 
 class CommandObjectCommandsUnalias : public CommandObjectParsed {
 public:
   CommandObjectCommandsUnalias(CommandInterpreter &interpreter)
bool DoExecute(Args &args, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsAddRegex
 //-------------------------------------------------------------------------
+
+static OptionDefinition g_regex_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "help"  , 'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "The help text to display for this command." },
+  { LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "A syntax string showing the typical usage syntax." },
+    // clang-format on
+};
+
 #pragma mark CommandObjectCommandsAddRegex
 
 class CommandObjectCommandsAddRegex : public CommandObjectParsed,
                                       public IOHandlerDelegateMultiline {
 public:
   CommandObjectCommandsAddRegex(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "command regex", "Define a custom command in terms of "
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_help.clear();
       m_syntax.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_regex_options;
+    }
 
     const char *GetHelp() {
       return (m_help.empty() ? nullptr : m_help.c_str());
     }
 
     const char *GetSyntax() {
       return (m_syntax.empty() ? nullptr : m_syntax.c_str());
     }
 
   protected:
     // Instance variables to hold the values for command options.
 
     std::string m_help;
     std::string m_syntax;
   };
 
   Options *GetOptions() override { return &m_options; }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectCommandsAddRegex::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "help"  , 'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "The help text to display for this command."},
-  {LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "A syntax string showing the typical usage syntax."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 class CommandObjectPythonFunction : public CommandObjectRaw {
 public:
   CommandObjectPythonFunction(CommandInterpreter &interpreter, std::string name,
                               std::string funct, std::string help,
                               ScriptedCommandSynchronicity synch)
       : CommandObjectRaw(interpreter, name.c_str(), nullptr, nullptr),
         m_function_name(funct), m_synchro(synch), m_fetched_help_long(false) {
     if (!help.empty())
private:
   bool m_fetched_help_short : 1;
   bool m_fetched_help_long : 1;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectCommandsScriptImport
 //-------------------------------------------------------------------------
 
+OptionDefinition g_script_import_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not." },
+    // clang-format on
+};
+
 class CommandObjectCommandsScriptImport : public CommandObjectParsed {
 public:
   CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command script import",
                             "Import a scripting module in LLDB.", nullptr),
         m_options() {
     CommandArgumentEntry arg1;
     CommandArgumentData cmd_arg;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_allow_reload = true;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_script_import_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     bool m_allow_reload;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_interpreter.GetDebugger().GetScriptLanguage() !=
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
 
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectCommandsScriptImport::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectCommandsScriptAdd
 //-------------------------------------------------------------------------
 
+static OptionEnumValueElement g_script_synchro_type[] = {
+    {eScriptedCommandSynchronicitySynchronous, "synchronous",
+     "Run synchronous"},
+    {eScriptedCommandSynchronicityAsynchronous, "asynchronous",
+     "Run asynchronous"},
+    {eScriptedCommandSynchronicityCurrentValue, "current",
+     "Do not alter current setting"},
+    {0, nullptr, nullptr}};
+
+static OptionDefinition g_script_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1,   false, "function",      'f', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypePythonFunction,               "Name of the Python function to bind to this command name." },
+  { LLDB_OPT_SET_2,   false, "class",         'c', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypePythonClass,                  "Name of the Python class to bind to this command name." },
+  { LLDB_OPT_SET_1,   false, "help"  ,        'h', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypeHelpText,                     "The help text to display for this command." },
+  { LLDB_OPT_SET_ALL, false, "synchronicity", 's', OptionParser::eRequiredArgument, nullptr, g_script_synchro_type, 0, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system." },
+    // clang-format on
+};
+
 class CommandObjectCommandsScriptAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command script add",
                             "Add a scripted function as an LLDB command.",
                             nullptr),
         IOHandlerDelegateMultiline("DONE"), m_options() {
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         break;
       case 'h':
         if (option_arg)
           m_short_help.assign(option_arg);
         break;
       case 's':
         m_synchronicity =
             (ScriptedCommandSynchronicity)Args::StringToOptionEnum(
-                option_arg, g_option_table[option_idx].enum_values, 0, error);
+                option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
         if (!error.Success())
           error.SetErrorStringWithFormat(
               "unrecognized value for synchronicity '%s'", option_arg);
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_class_name.clear();
       m_funct_name.clear();
       m_short_help.clear();
       m_synchronicity = eScriptedCommandSynchronicitySynchronous;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_script_add_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_class_name;
     std::string m_funct_name;
     std::string m_short_help;
     ScriptedCommandSynchronicity m_synchronicity;
   };
protected:
   }
 
   CommandOptions m_options;
   std::string m_cmd_name;
   std::string m_short_help;
   ScriptedCommandSynchronicity m_synchronicity;
 };
 
-static OptionEnumValueElement g_script_synchro_type[] = {
-    {eScriptedCommandSynchronicitySynchronous, "synchronous",
-     "Run synchronous"},
-    {eScriptedCommandSynchronicityAsynchronous, "asynchronous",
-     "Run asynchronous"},
-    {eScriptedCommandSynchronicityCurrentValue, "current",
-     "Do not alter current setting"},
-    {0, nullptr, nullptr}};
-
-OptionDefinition
-    CommandObjectCommandsScriptAdd::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1,   false, "function",      'f', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypePythonFunction,               "Name of the Python function to bind to this command name."},
-  {LLDB_OPT_SET_2,   false, "class",         'c', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypePythonClass,                  "Name of the Python class to bind to this command name."},
-  {LLDB_OPT_SET_1,   false, "help"  ,        'h', OptionParser::eRequiredArgument, nullptr, nullptr,               0, eArgTypeHelpText,                     "The help text to display for this command."},
-  {LLDB_OPT_SET_ALL, false, "synchronicity", 's', OptionParser::eRequiredArgument, nullptr, g_script_synchro_type, 0, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectCommandsScriptList
 //-------------------------------------------------------------------------
 
 class CommandObjectCommandsScriptList : public CommandObjectParsed {
 public:
   CommandObjectCommandsScriptList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "command script list",

lldb/trunk/source/Commands/CommandObjectDisassemble.h

public:
 
     ~CommandOptions() override;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-    const OptionDefinition *GetDefinitions() override;
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
     const char *GetPluginName() {
       return (plugin_name.empty() ? nullptr : plugin_name.c_str());
     }
 
     const char *GetFlavorString() {
       if (flavor_string.empty() || flavor_string == "default")
         return nullptr;

lldb/trunk/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 OptionDefinition g_disassemble_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "bytes",         'b', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Show opcode bytes when disassembling." },
+  { LLDB_OPT_SET_ALL, false, "context",       'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeNumLines,            "Number of context lines of source to show." },
+  { LLDB_OPT_SET_ALL, false, "mixed",         'm', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Enable mixed source and assembly display." },
+  { LLDB_OPT_SET_ALL, false, "raw",           'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Print raw disassembly with no symbol information." },
+  { LLDB_OPT_SET_ALL, false, "plugin",        'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypePlugin,              "Name of the disassembler plugin you want to use." },
+  { LLDB_OPT_SET_ALL, false, "flavor",        'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeDisassemblyFlavor,   "Name of the disassembly flavor you want to use.  "
+  "Currently the only valid options are default, and for Intel "
+  "architectures, att and intel." },
+  { LLDB_OPT_SET_ALL, false, "arch",          'A', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeArchitecture,        "Specify the architecture to use from cross disassembly." },
+  { LLDB_OPT_SET_1 |
+  LLDB_OPT_SET_2,   true,  "start-address", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Address at which to start disassembling." },
+  { LLDB_OPT_SET_1,   false, "end-address",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Address at which to end disassembling." },
+  { LLDB_OPT_SET_2 |
+  LLDB_OPT_SET_3 |
+  LLDB_OPT_SET_4 |
+  LLDB_OPT_SET_5,   false, "count",         'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeNumLines,            "Number of instructions to display." },
+  { LLDB_OPT_SET_3,   false, "name",          'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName,        "Disassemble entire contents of the given function name." },
+  { LLDB_OPT_SET_4,   false, "frame",         'f', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble from the start of the current frame's function." },
+  { LLDB_OPT_SET_5,   false, "pc",            'p', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble around the current pc." },
+  { LLDB_OPT_SET_6,   false, "line",          'l', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble the current frame's current source line instructions if there is debug line "
+  "table information, else disassemble around the pc." },
+  { LLDB_OPT_SET_7,   false, "address",       'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Disassemble function containing this address." },
+    // clang-format on
+};
+
 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);
 }
 

 
 Error CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
     ExecutionContext *execution_context) {
   if (!some_location_specified)
     current_function = true;
   return Error();
 }
 
-const OptionDefinition *
+llvm::ArrayRef<OptionDefinition>
 CommandObjectDisassemble::CommandOptions::GetDefinitions() {
-  return g_option_table;
+  return g_disassemble_options;
 }
 
-OptionDefinition CommandObjectDisassemble::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL, false, "bytes",         'b', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Show opcode bytes when disassembling."},
-  {LLDB_OPT_SET_ALL, false, "context",       'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeNumLines,            "Number of context lines of source to show."},
-  {LLDB_OPT_SET_ALL, false, "mixed",         'm', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Enable mixed source and assembly display."},
-  {LLDB_OPT_SET_ALL, false, "raw",           'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Print raw disassembly with no symbol information."},
-  {LLDB_OPT_SET_ALL, false, "plugin",        'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypePlugin,              "Name of the disassembler plugin you want to use."},
-  {LLDB_OPT_SET_ALL, false, "flavor",        'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeDisassemblyFlavor,   "Name of the disassembly flavor you want to use.  "
-                                                                                                                                                                         "Currently the only valid options are default, and for Intel "
-                                                                                                                                                                         "architectures, att and intel."},
-  {LLDB_OPT_SET_ALL, false, "arch",          'A', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeArchitecture,        "Specify the architecture to use from cross disassembly."},
-  {LLDB_OPT_SET_1 |
-   LLDB_OPT_SET_2,   true,  "start-address", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Address at which to start disassembling."},
-  {LLDB_OPT_SET_1,   false, "end-address",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Address at which to end disassembling."},
-  {LLDB_OPT_SET_2 |
-   LLDB_OPT_SET_3 |
-   LLDB_OPT_SET_4 |
-   LLDB_OPT_SET_5,   false, "count",         'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeNumLines,            "Number of instructions to display."},
-  {LLDB_OPT_SET_3,   false, "name",          'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName,        "Disassemble entire contents of the given function name."},
-  {LLDB_OPT_SET_4,   false, "frame",         'f', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble from the start of the current frame's function."},
-  {LLDB_OPT_SET_5,   false, "pc",            'p', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble around the current pc."},
-  {LLDB_OPT_SET_6,   false, "line",          'l', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                     eArgTypeNone,                "Disassemble the current frame's current source line instructions if there is debug line "
-                                                                                                                                                                         "table information, else disassemble around the pc."},
-  {LLDB_OPT_SET_7,   false, "address",       'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                     eArgTypeAddressOrExpression, "Disassemble function containing this address."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectDisassemble
 //-------------------------------------------------------------------------
 
 CommandObjectDisassemble::CommandObjectDisassemble(
     CommandInterpreter &interpreter)
     : CommandObjectParsed(
           interpreter, "disassemble",

lldb/trunk/source/Commands/CommandObjectExpression.h

class CommandObjectExpression : public CommandObjectRaw,
                                 public IOHandlerDelegate {
 public:
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions();
 
     ~CommandOptions() override;
 
-    uint32_t GetNumDefinitions() override;
-
-    const OptionDefinition *GetDefinitions() override;
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
     // Options table: Required for subclasses of Options.
 

lldb/trunk/source/Commands/CommandObjectExpression.cpp

 
 static OptionEnumValueElement g_description_verbosity_type[] = {
     {eLanguageRuntimeDescriptionDisplayVerbosityCompact, "compact",
      "Only show the description string"},
     {eLanguageRuntimeDescriptionDisplayVerbosityFull, "full",
      "Show the full output, including persistent variable's name and type"},
     {0, nullptr, nullptr}};
 
-OptionDefinition CommandObjectExpression::CommandOptions::g_option_table[] = {
+static OptionDefinition g_expression_options[] = {
     // clang-format off
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "all-threads",           'a', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeBoolean,              "Should we run all threads if the execution doesn't complete on one thread."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "ignore-breakpoints",    'i', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeBoolean,              "Ignore breakpoint hits while running expressions"},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout",               't', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeUnsignedInteger,      "Timeout value (in microseconds) for running the expression."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error",       'u', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeBoolean,              "Clean up program state if the expression causes a crash, or raises a signal.  "
                                                                                                                                                                                   "Note, unlike gdb hitting a breakpoint is controlled by another option (-i)."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug",                 'g', OptionParser::eNoArgument,       nullptr, nullptr,                      0, eArgTypeNone,                 "When specified, debug the JIT code by setting a breakpoint on the first instruction "
                                                                                                                                                                                   "and forcing breakpoints to not be ignored (-i0) and no unwinding to happen on error (-u0)."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "language",              'l', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeLanguage,             "Specifies the Language to use when parsing the expression.  If not set the target.language "
                                                                                                                                                                                   "setting is used." },
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "apply-fixits",          'X', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeLanguage,             "If true, simple fix-it hints will be automatically applied to the expression." },
   {LLDB_OPT_SET_1,                  false, "description-verbosity", 'v', OptionParser::eOptionalArgument, nullptr, g_description_verbosity_type, 0, eArgTypeDescriptionVerbosity, "How verbose should the output of this expression be, if the object description is asked for."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "top-level",             'p', OptionParser::eNoArgument,       nullptr, nullptr,                      0, eArgTypeNone,                 "Interpret the expression as top-level definitions rather than code to be immediately "
                                                                                                                                                                                   "executed."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "allow-jit",             'j', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeBoolean,              "Controls whether the expression can fall back to being JITted if it's not supported by "
                                                                                                                                                                                   "the interpreter (defaults to true)."}
     // clang-format on
 };
 
-uint32_t CommandObjectExpression::CommandOptions::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
-
 Error CommandObjectExpression::CommandOptions::SetOptionValue(
     uint32_t option_idx, const char *option_arg,
     ExecutionContext *execution_context) {
   Error error;
 
   auto option_strref = llvm::StringRef::withNullAsEmpty(option_arg);
-  const int short_option = g_option_table[option_idx].short_option;
+  const int short_option = GetDefinitions()[option_idx].short_option;
 
   switch (short_option) {
   case 'l':
     language = Language::GetLanguageTypeFromString(option_arg);
     if (language == eLanguageTypeUnknown)
       error.SetErrorStringWithFormat(
           "unknown language type: '%s' for expression", option_arg);
     break;
Error CommandObjectExpression::CommandOptions::SetOptionValue(
 
   case 'v':
     if (!option_arg) {
       m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull;
       break;
     }
     m_verbosity =
         (LanguageRuntimeDescriptionDisplayVerbosity)Args::StringToOptionEnum(
-            option_arg, g_option_table[option_idx].enum_values, 0, error);
+            option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
     if (!error.Success())
       error.SetErrorStringWithFormat(
           "unrecognized value for description-verbosity '%s'", option_arg);
     break;
 
   case 'g':
     debug = true;
     unwind_on_error = false;
void CommandObjectExpression::CommandOptions::OptionParsingStarting(
   debug = false;
   language = eLanguageTypeUnknown;
   m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
   auto_apply_fixits = eLazyBoolCalculate;
   top_level = false;
   allow_jit = true;
 }
 
-const OptionDefinition *
+llvm::ArrayRef<OptionDefinition>
 CommandObjectExpression::CommandOptions::GetDefinitions() {
-  return g_option_table;
+  return g_expression_options;
 }
 
 CommandObjectExpression::CommandObjectExpression(
     CommandInterpreter &interpreter)
     : CommandObjectRaw(
           interpreter, "expression", "Evaluate an expression on the current "
                                      "thread.  Displays any returned value "
                                      "with LLDB's default formatting.",

lldb/trunk/source/Commands/CommandObjectFrame.cpp

 //-------------------------------------------------------------------------
 // CommandObjectFrameInfo
 //-------------------------------------------------------------------------
 
 //-------------------------------------------------------------------------
 // CommandObjectFrameDiagnose
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_frame_diag_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "register", 'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeRegisterName,    "A register to diagnose." },
+  { LLDB_OPT_SET_1, false, "address",  'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddress,         "An address to diagnose." },
+  { LLDB_OPT_SET_1, false, "offset",   'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset,          "An optional offset.  Requires --register." }
+    // clang-format on
+};
+
 class CommandObjectFrameDiagnose : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       address.reset();
       reg.reset();
       offset.reset();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_frame_diag_options;
+    }
 
     // Options.
     llvm::Optional<lldb::addr_t> address;
     llvm::Optional<ConstString> reg;
     llvm::Optional<int64_t> offset;
   };
 
   CommandObjectFrameDiagnose(CommandInterpreter &interpreter)
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return true;
   }
 
 protected:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectFrameDiagnose::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-    {LLDB_OPT_SET_1, false, "register", 'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeRegisterName,    "A register to diagnose."},
-    {LLDB_OPT_SET_1, false, "address",  'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddress,         "An address to diagnose."},
-    {LLDB_OPT_SET_1, false, "offset",   'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset,          "An optional offset.  Requires --register."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 #pragma mark CommandObjectFrameInfo
 
 //-------------------------------------------------------------------------
 // CommandObjectFrameInfo
 //-------------------------------------------------------------------------
 
 class CommandObjectFrameInfo : public CommandObjectParsed {
 public:

 };
 
 #pragma mark CommandObjectFrameSelect
 
 //-------------------------------------------------------------------------
 // CommandObjectFrameSelect
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_frame_select_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "relative", 'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset, "A relative frame index offset from the current frame index." },
+    // clang-format on
+};
+
 class CommandObjectFrameSelect : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       relative_frame_offset = INT32_MIN;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_frame_select_options;
+    }
 
-    static OptionDefinition g_option_table[];
     int32_t relative_frame_offset;
   };
 
   CommandObjectFrameSelect(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "frame select", "Select the current stack frame by "
                                          "index from within the current thread "
                                          "(see 'thread backtrace'.)",
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 protected:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectFrameSelect::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_1, false, "relative", 'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset, "A relative frame index offset from the current frame index."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 #pragma mark CommandObjectFrameVariable
 //----------------------------------------------------------------------
 // List images with associated information
 //----------------------------------------------------------------------
 class CommandObjectFrameVariable : public CommandObjectParsed {
 public:
   CommandObjectFrameVariable(CommandInterpreter &interpreter)
       : CommandObjectParsed(

lldb/trunk/source/Commands/CommandObjectHelp.h

public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_aliases = true;
       m_show_user_defined = true;
       m_show_hidden = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
     // Instance variables to hold the values for command options.
 
     bool m_show_aliases;
     bool m_show_user_defined;
     bool m_show_hidden;
   };
 

lldb/trunk/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;
 
-OptionDefinition CommandObjectHelp::CommandOptions::g_option_table[] = {
+static OptionDefinition g_help_options[] = {
     // clang-format off
   {LLDB_OPT_SET_ALL, false, "hide-aliases",         'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Hide aliases in the command list."},
   {LLDB_OPT_SET_ALL, false, "hide-user-commands",   'u', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Hide user-defined commands from the list."},
   {LLDB_OPT_SET_ALL, false, "show-hidden-commands", 'h', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Include commands prefixed with an underscore."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
     // clang-format on
 };
 
+llvm::ArrayRef<OptionDefinition>
+CommandObjectHelp::CommandOptions::GetDefinitions() {
+  return g_help_options;
+}
+
 bool CommandObjectHelp::DoExecute(Args &command, CommandReturnObject &result) {
   CommandObject::CommandMap::iterator pos;
   CommandObject *cmd_obj;
   const size_t argc = command.GetArgumentCount();
 
   // 'help' doesn't take any arguments, other than command names.  If argc is 0,
   // we show the user
   // all commands (aliases and user commands if asked for).  Otherwise every

lldb/trunk/source/Commands/CommandObjectLog.cpp

 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static OptionDefinition g_log_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Set the destination file to log to." },
+  { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable thread safe logging to avoid interweaved log lines." },
+  { LLDB_OPT_SET_1, false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable verbose logging." },
+  { LLDB_OPT_SET_1, false, "debug",      'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable debug logging." },
+  { LLDB_OPT_SET_1, false, "sequence",   's', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with an increasing integer sequence id." },
+  { LLDB_OPT_SET_1, false, "timestamp",  'T', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with a timestamp." },
+  { LLDB_OPT_SET_1, false, "pid-tid",    'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the process and thread ID that generates the log line." },
+  { LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the thread name for the thread that generates the log line." },
+  { LLDB_OPT_SET_1, false, "stack",      'S', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append a stack backtrace to each log line." },
+  { LLDB_OPT_SET_1, false, "append",     'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append to the log file instead of overwriting." },
+    // clang-format on
+};
+
 class CommandObjectLogEnable : public CommandObjectParsed {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   CommandObjectLogEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "log enable",
                             "Enable logging for a single log channel.",
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       log_file.Clear();
       log_options = 0;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_log_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     FileSpec log_file;
     uint32_t log_options;
   };
 
 protected:
if (args.GetArgumentCount() < 2) {
         result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectLogEnable::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_1, false, "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Set the destination file to log to."},
-  {LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable thread safe logging to avoid interweaved log lines."},
-  {LLDB_OPT_SET_1, false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable verbose logging."},
-  {LLDB_OPT_SET_1, false, "debug",      'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable debug logging."},
-  {LLDB_OPT_SET_1, false, "sequence",   's', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with an increasing integer sequence id."},
-  {LLDB_OPT_SET_1, false, "timestamp",  'T', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with a timestamp."},
-  {LLDB_OPT_SET_1, false, "pid-tid",    'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the process and thread ID that generates the log line."},
-  {LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the thread name for the thread that generates the log line."},
-  {LLDB_OPT_SET_1, false, "stack",      'S', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append a stack backtrace to each log line."},
-  {LLDB_OPT_SET_1, false, "append",     'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append to the log file instead of overwriting."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 class CommandObjectLogDisable : public CommandObjectParsed {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   CommandObjectLogDisable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "log disable",
                             "Disable one or more log channel categories.",

lldb/trunk/source/Commands/CommandObjectMemory.cpp

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static OptionDefinition g_option_table[] = {
+static OptionDefinition g_read_memory_options[] = {
     // clang-format off
   {LLDB_OPT_SET_1, false, "num-per-line", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNumberPerLine, "The number of items per line to display." },
   {LLDB_OPT_SET_2, false, "binary",       'b', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,          "If true, memory will be saved as binary. If false, the memory is saved save as an ASCII dump that "
                                                                                                                             "uses the format, size, count and number per line settings." },
   {LLDB_OPT_SET_3, true , "type",         't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone,          "The name of a type to view memory as." },
   {LLDB_OPT_SET_3, false, "offset",       'E', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,         "How many elements of the specified type to skip before starting to display data." },
   {LLDB_OPT_SET_1 |
    LLDB_OPT_SET_2 |
    LLDB_OPT_SET_3, false, "force",        'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,          "Necessary if reading over target.max-memory-read-size bytes." },
     // clang-format on
 };
 
 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) {}
 
   ~OptionGroupReadMemory() override = default;
 
-  uint32_t GetNumDefinitions() override {
-    return sizeof(g_option_table) / sizeof(OptionDefinition);
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+    return g_read_memory_options;
   }
 
-  const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
   Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                        ExecutionContext *execution_context) override {
     Error error;
-    const int short_option = g_option_table[option_idx].short_option;
+    const int short_option = g_read_memory_options[option_idx].short_option;
 
     switch (short_option) {
     case 'l':
       error = m_num_per_line.SetValueFromString(option_arg);
       if (m_num_per_line.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat(
             "invalid value for --num-per-line option '%s'", option_arg);
       break;

 class CommandObjectMemoryFind : public CommandObjectParsed {
 public:
   class OptionGroupFindMemory : public OptionGroup {
   public:
     OptionGroupFindMemory() : OptionGroup(), m_count(1), m_offset(0) {}
 
     ~OptionGroupFindMemory() override = default;
 
-    uint32_t GetNumDefinitions() override {
-      return sizeof(g_memory_find_option_table) / sizeof(OptionDefinition);
-    }
-
-    const OptionDefinition *GetDefinitions() override {
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return g_memory_find_option_table;
     }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option =
           g_memory_find_option_table[option_idx].short_option;

 class CommandObjectMemoryWrite : public CommandObjectParsed {
 public:
   class OptionGroupWriteMemory : public OptionGroup {
   public:
     OptionGroupWriteMemory() : OptionGroup() {}
 
     ~OptionGroupWriteMemory() override = default;
 
-    uint32_t GetNumDefinitions() override {
-      return sizeof(g_memory_write_option_table) / sizeof(OptionDefinition);
-    }
-
-    const OptionDefinition *GetDefinitions() override {
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return g_memory_write_option_table;
     }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option =
           g_memory_write_option_table[option_idx].short_option;

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

SetOptionValue(uint32_t option_idx, const char *option_arg,
 
     return error;
   }
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_permissions = 0;
   }
 
-  uint32_t GetNumDefinitions() override {
-    return llvm::array_lengthof(g_permissions_options);
-  }
-
-  const lldb_private::OptionDefinition *GetDefinitions() override {
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return g_permissions_options;
   }
 
   // Instance variables to hold the values for command options.
 
   uint32_t m_permissions;
 
 private:
bool DoExecute(Args &args, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 };
 
 //----------------------------------------------------------------------
 // "platform fread"
 //----------------------------------------------------------------------
+
+static OptionDefinition g_platform_fread_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Offset into the file at which to start reading." },
+  { LLDB_OPT_SET_1, false, "count",  'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount, "Number of bytes to read from the file." },
+    // clang-format on
+};
+
 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() {}
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_offset = 0;
       m_count = 1;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_platform_fread_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_offset;
     uint32_t m_count;
   };
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectPlatformFRead::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Offset into the file at which to start reading."},
-  {LLDB_OPT_SET_1, false, "count",  'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount, "Number of bytes to read from the file."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//----------------------------------------------------------------------
+// "platform fwrite"
+//----------------------------------------------------------------------
+
+static OptionDefinition g_platform_fwrite_options[] = {
+  { LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Offset into the file at which to start reading." },
+  { LLDB_OPT_SET_1, false, "data",   'd', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue, "Text to write to the file." },
 };
 
-//----------------------------------------------------------------------
-// "platform fwrite"
-//----------------------------------------------------------------------
 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() {}
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_offset = 0;
       m_data.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_platform_fwrite_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_offset;
     std::string m_data;
   };
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectPlatformFWrite::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Offset into the file at which to start reading."},
-  {LLDB_OPT_SET_1, false, "data",   'd', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue, "Text to write to the file."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 class CommandObjectPlatformFile : public CommandObjectMultiword {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   CommandObjectPlatformFile(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "platform file",

 
 protected:
   ProcessLaunchCommandOptions m_options;
 };
 
 //----------------------------------------------------------------------
 // "platform process list"
 //----------------------------------------------------------------------
+
+OptionDefinition g_platform_process_list_option_array[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1,             false, "pid",         'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,               "List the process info for a specific process ID." },
+  { LLDB_OPT_SET_2,             true,  "name",        'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that match a string." },
+  { LLDB_OPT_SET_3,             true,  "ends-with",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that end with a string." },
+  { LLDB_OPT_SET_4,             true,  "starts-with", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that start with a string." },
+  { LLDB_OPT_SET_5,             true,  "contains",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that contain a string." },
+  { LLDB_OPT_SET_6,             true,  "regex",       'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeRegularExpression, "Find processes with executable basenames that match a regular expression." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "parent",      'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,               "Find processes that have a matching parent process ID." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "uid",         'u', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching user ID." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "euid",        'U', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching effective user ID." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "gid",         'g', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching group ID." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "egid",        'G', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching effective group ID." },
+  { LLDB_OPT_SET_FROM_TO(2, 6), false, "arch",        'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeArchitecture,      "Find processes that have a matching architecture." },
+  { LLDB_OPT_SET_FROM_TO(1, 6), false, "show-args",   'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Show process arguments instead of the process executable basename." },
+  { LLDB_OPT_SET_FROM_TO(1, 6), false, "verbose",     'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Enable verbose output." },
+    // clang-format on
+};
+llvm::MutableArrayRef<OptionDefinition>
+    g_platform_process_list_options(g_platform_process_list_option_array);
+
 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),
         m_options() {}
protected:
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), match_info(), show_args(false), verbose(false) {
       static std::once_flag g_once_flag;
       std::call_once(g_once_flag, []() {
         PosixPlatformCommandOptionValidator *posix_validator =
             new PosixPlatformCommandOptionValidator();
-        for (size_t i = 0; g_option_table[i].short_option != 0; ++i) {
-          switch (g_option_table[i].short_option) {
+        for (auto &Option : g_platform_process_list_options) {
+          switch (Option.short_option) {
           case 'u':
           case 'U':
           case 'g':
           case 'G':
-            g_option_table[i].validator = posix_validator;
+            Option.validator = posix_validator;
             break;
           default:
             break;
           }
         }
       });
     }
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       match_info.Clear();
       show_args = false;
       verbose = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_platform_process_list_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     ProcessInstanceInfoMatch match_info;
     bool show_args;
     bool verbose;
   };
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectPlatformProcessList::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1,             false, "pid",         'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,               "List the process info for a specific process ID."},
-  {LLDB_OPT_SET_2,             true,  "name",        'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that match a string."},
-  {LLDB_OPT_SET_3,             true,  "ends-with",   'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that end with a string."},
-  {LLDB_OPT_SET_4,             true,  "starts-with", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that start with a string."},
-  {LLDB_OPT_SET_5,             true,  "contains",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,       "Find processes with executable basenames that contain a string."},
-  {LLDB_OPT_SET_6,             true,  "regex",       'r', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeRegularExpression, "Find processes with executable basenames that match a regular expression."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "parent",      'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,               "Find processes that have a matching parent process ID."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "uid",         'u', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching user ID."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "euid",        'U', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching effective user ID."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "gid",         'g', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching group ID."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "egid",        'G', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger,   "Find processes that have a matching effective group ID."},
-  {LLDB_OPT_SET_FROM_TO(2, 6), false, "arch",        'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeArchitecture,      "Find processes that have a matching architecture."},
-  {LLDB_OPT_SET_FROM_TO(1, 6), false, "show-args",   'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Show process arguments instead of the process executable basename."},
-  {LLDB_OPT_SET_FROM_TO(1, 6), false, "verbose",     'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Enable verbose output."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //----------------------------------------------------------------------
 // "platform process info"
 //----------------------------------------------------------------------
 class CommandObjectPlatformProcessInfo : public CommandObjectParsed {
 public:
   CommandObjectPlatformProcessInfo(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "platform process info",
bool DoExecute(Args &args, CommandReturnObject &result) override {
     } else {
       result.AppendError("no platform is currently selected");
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 };
 
+static OptionDefinition g_platform_process_attach_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "plugin",  'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin,      "Name of the process plugin you want to use." },
+  { LLDB_OPT_SET_1,   false, "pid",     'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,         "The process ID of an existing process to attach to." },
+  { LLDB_OPT_SET_2,   false, "name",    'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName, "The name of the process to attach to." },
+  { LLDB_OPT_SET_2,   false, "waitfor", 'w', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Wait for the process with <process-name> to launch." },
+    // clang-format on
+};
+
 class CommandObjectPlatformProcessAttach : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_platform_process_attach_options;
+    }
 
     bool HandleOptionArgumentCompletion(
         Args &input, int cursor_index, int char_pos,
         OptionElementVector &opt_element_vector, int opt_element_index,
         int match_start_point, int max_return_elements,
         CommandInterpreter &interpreter, bool &word_complete,
         StringList &matches) override {
       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
       // We are only completing the name option for now...
 
-      const OptionDefinition *opt_defs = GetDefinitions();
-      if (opt_defs[opt_defs_index].short_option == 'n') {
+      if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
         // Look to see if there is a -P argument provided, and if so use that
         // plugin, otherwise
         // use the default plugin.
 
         const char *partial_name = nullptr;
         partial_name = input.GetArgumentAtIndex(opt_arg_pos);
public:
   }
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectPlatformProcessAttach::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "plugin",  'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin,      "Name of the process plugin you want to use."},
-  {LLDB_OPT_SET_1,   false, "pid",     'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,         "The process ID of an existing process to attach to."},
-  {LLDB_OPT_SET_2,   false, "name",    'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName, "The name of the process to attach to."},
-  {LLDB_OPT_SET_2,   false, "waitfor", 'w', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Wait for the process with <process-name> to launch."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 class CommandObjectPlatformProcess : public CommandObjectMultiword {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   CommandObjectPlatformProcess(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "platform process",
                                "Commands to query, launch and attach to "
private:
   // For CommandObjectPlatform only
   //------------------------------------------------------------------
   DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
 };
 
 //----------------------------------------------------------------------
 // "platform shell"
 //----------------------------------------------------------------------
+static OptionDefinition g_platform_shell_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "timeout", 't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue, "Seconds to wait for the remote host to finish running the command." },
+    // clang-format on
+};
+
 class CommandObjectPlatformShell : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), timeout(10) {}
 
     ~CommandOptions() override = default;
 
-    virtual uint32_t GetNumDefinitions() { return 1; }
-
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_platform_shell_options;
+    }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override {
       Error error;
 
-      const char short_option = (char)g_option_table[option_idx].short_option;
+      const char short_option = (char)GetDefinitions()[option_idx].short_option;
 
       switch (short_option) {
       case 't': {
         bool success;
         timeout = StringConvert::ToUInt32(option_value, 10, 10, &success);
         if (!success)
           error.SetErrorStringWithFormat(
               "could not convert \"%s\" to a numeric value.", option_value);
         break;
       }
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {}
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
     uint32_t timeout;
   };
 
   CommandObjectPlatformShell(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "platform shell",
                          "Run a shell command on the current platform.",
                          "platform shell <shell-command>", 0),
         m_options() {}
if (error.Fail()) {
       result.SetStatus(eReturnStatusSuccessFinishResult);
     }
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectPlatformShell::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "timeout", 't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue, "Seconds to wait for the remote host to finish running the command."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //----------------------------------------------------------------------
 // "platform install" - install a target to a remote end
 //----------------------------------------------------------------------
 class CommandObjectPlatformInstall : public CommandObjectParsed {
 public:
   CommandObjectPlatformInstall(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "platform target-install",

lldb/trunk/source/Commands/CommandObjectProcess.cpp

 //
 //#undef SET1
 //#undef SET2
 //#undef SET3
 
 //-------------------------------------------------------------------------
 // CommandObjectProcessAttach
 //-------------------------------------------------------------------------
+
+static OptionDefinition g_process_attach_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "continue",         'c', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Immediately continue the process once attached." },
+  { LLDB_OPT_SET_ALL, false, "plugin",           'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin,       "Name of the process plugin you want to use." },
+  { LLDB_OPT_SET_1,   false, "pid",              'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,          "The process ID of an existing process to attach to." },
+  { LLDB_OPT_SET_2,   false, "name",             'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,  "The name of the process to attach to." },
+  { LLDB_OPT_SET_2,   false, "include-existing", 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Include existing processes when doing attach -w." },
+  { LLDB_OPT_SET_2,   false, "waitfor",          'w', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Wait for the process with <process-name> to launch." },
+    // clang-format on
+};
+
 #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
       // ()
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_attach_options;
+    }
 
     bool HandleOptionArgumentCompletion(
         Args &input, int cursor_index, int char_pos,
         OptionElementVector &opt_element_vector, int opt_element_index,
         int match_start_point, int max_return_elements,
         CommandInterpreter &interpreter, bool &word_complete,
         StringList &matches) override {
       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
       // We are only completing the name option for now...
 
-      const OptionDefinition *opt_defs = GetDefinitions();
-      if (opt_defs[opt_defs_index].short_option == 'n') {
+      if (GetDefinitions()[opt_defs_index].short_option == 'n') {
         // Are we in the name?
 
         // Look to see if there is a -P argument provided, and if so use that
         // plugin, otherwise
         // use the default plugin.
 
         const char *partial_name = nullptr;
         partial_name = input.GetArgumentAtIndex(opt_arg_pos);
bool HandleOptionArgumentCompletion(
             }
           }
         }
       }
 
       return false;
     }
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
 
     ProcessAttachInfo attach_info;
   };
 
   CommandObjectProcessAttach(CommandInterpreter &interpreter)
       : CommandObjectProcessLaunchOrAttach(
             interpreter, "process attach", "Attach to a process.",
if (m_options.attach_info.GetContinueOnceAttached())
       m_interpreter.HandleCommand("process continue", eLazyBoolNo, result);
 
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectProcessAttach::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "continue",         'c', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Immediately continue the process once attached."},
-  {LLDB_OPT_SET_ALL, false, "plugin",           'P', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin,       "Name of the process plugin you want to use."},
-  {LLDB_OPT_SET_1,   false, "pid",              'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePid,          "The process ID of an existing process to attach to."},
-  {LLDB_OPT_SET_2,   false, "name",             'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeProcessName,  "The name of the process to attach to."},
-  {LLDB_OPT_SET_2,   false, "include-existing", 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Include existing processes when doing attach -w."},
-  {LLDB_OPT_SET_2,   false, "waitfor",          'w', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,         "Wait for the process with <process-name> to launch."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectProcessContinue
+//-------------------------------------------------------------------------
+
+static OptionDefinition g_process_continue_options[] = {
+  { LLDB_OPT_SET_ALL, false, "ignore-count",'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Ignore <N> crossings of the breakpoint (if it exists) for the currently selected thread." }
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectProcessContinue
-//-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessContinue
 
 class CommandObjectProcessContinue : public CommandObjectParsed {
 public:
   CommandObjectProcessContinue(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "process continue",
             "Continue execution of all threads in the current process.",
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_ignore = 0;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_continue_options;
+    }
 
     uint32_t m_ignore;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Process *process = m_exe_ctx.GetProcessPtr();
     bool synchronous_execution = m_interpreter.GetSynchronous();
     StateType state = process->GetState();
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
   Options *GetOptions() override { return &m_options; }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectProcessContinue::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "ignore-count",'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Ignore <N> crossings of the breakpoint (if it exists) for the currently selected thread."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectProcessDetach
+//-------------------------------------------------------------------------
+static OptionDefinition g_process_detach_options[] = {
+  { LLDB_OPT_SET_1, false, "keep-stopped", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the process should be kept stopped on detach (if possible)." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectProcessDetach
-//-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessDetach
 
 class CommandObjectProcessDetach : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_keep_stopped = eLazyBoolCalculate;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_detach_options;
+    }
 
     // Instance variables to hold the values for command options.
     LazyBool m_keep_stopped;
   };
 
   CommandObjectProcessDetach(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process detach",
                             "Detach from the current target process.",
if (error.Success()) {
       return false;
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectProcessDetach::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "keep-stopped", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the process should be kept stopped on detach (if possible)."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//-------------------------------------------------------------------------
+// CommandObjectProcessConnect
+//-------------------------------------------------------------------------
+
+static OptionDefinition g_process_connect_options[] = {
+  { LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin, "Name of the process plugin you want to use." },
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectProcessConnect
-//-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessConnect
 
 class CommandObjectProcessConnect : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       plugin_name.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_connect_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string plugin_name;
   };
 
   CommandObjectProcessConnect(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process connect",
if (error.Fail() || process_sp == nullptr) {
       return false;
     }
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectProcessConnect::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin, "Name of the process plugin you want to use."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectProcessPlugin
 //-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessPlugin
 
 class CommandObjectProcessPlugin : public CommandObjectProxy {
 public:
   CommandObjectProcessPlugin(CommandInterpreter &interpreter)
if (process)
       return process->GetPluginCommandObject();
     return nullptr;
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectProcessLoad
 //-------------------------------------------------------------------------
+
+static OptionDefinition g_process_load_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "install", 'i', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypePath, "Install the shared library to the target. If specified without an argument then the library will installed in the current working directory." },
+    // clang-format on
+};
+
 #pragma mark CommandObjectProcessLoad
 
 class CommandObjectProcessLoad : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       do_install = false;
       install_path.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_load_options;
+    }
 
     // Instance variables to hold the values for command options.
     bool do_install;
     FileSpec install_path;
   };
 
   CommandObjectProcessLoad(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process load",
for (uint32_t i = 0; i < argc; ++i) {
       }
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectProcessLoad::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL, false, "install", 'i', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypePath, "Install the shared library to the target. If specified without an argument then the library will installed in the current working directory."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectProcessUnload
 //-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessUnload
 
 class CommandObjectProcessUnload : public CommandObjectParsed {
 public:
   CommandObjectProcessUnload(CommandInterpreter &interpreter)
process->GetThreadStatus(strm, only_threads_with_stop_reason, start_frame,
                              num_frames, num_frames_with_source);
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectProcessHandle
 //-------------------------------------------------------------------------
+
+static OptionDefinition g_process_handle_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "stop",   's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the process should be stopped if the signal is received." },
+  { LLDB_OPT_SET_1, false, "notify", 'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the debugger should notify the user if the signal is received." },
+  { LLDB_OPT_SET_1, false, "pass",   'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the signal should be passed to the process." }
+    // clang-format on
+};
+
 #pragma mark CommandObjectProcessHandle
 
 class CommandObjectProcessHandle : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       stop.clear();
       notify.clear();
       pass.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_process_handle_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string stop;
     std::string notify;
     std::string pass;
   };
 
else
       result.SetStatus(eReturnStatusFailed);
 
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectProcessHandle::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "stop",   's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the process should be stopped if the signal is received."},
-  {LLDB_OPT_SET_1, false, "notify", 'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the debugger should notify the user if the signal is received."},
-  {LLDB_OPT_SET_1, false, "pass",   'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Whether or not the signal should be passed to the process."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordProcess
 //-------------------------------------------------------------------------
 
 CommandObjectMultiwordProcess::CommandObjectMultiwordProcess(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "process",

lldb/trunk/source/Commands/CommandObjectRegister.cpp

 #include "lldb/Target/Thread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // "register read"
 //----------------------------------------------------------------------
+
+static OptionDefinition g_register_read_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "alternate", 'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,  "Display register names using the alternate register name if there is one." },
+  { LLDB_OPT_SET_1,   false, "set",       's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Specify which register sets to dump by index." },
+  { LLDB_OPT_SET_2,   false, "all",       'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,  "Show all register sets." },
+    // clang-format on
+};
+
 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.",
             nullptr,
public:
     CommandOptions()
         : OptionGroup(),
           set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
           dump_all_sets(false, false), // Initial and default values are false
           alternate_name(false, false) {}
 
     ~CommandOptions() override = default;
 
-    uint32_t GetNumDefinitions() override;
-
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_register_read_options;
+    }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       set_indexes.Clear();
       dump_all_sets.Clear();
       alternate_name.Clear();
     }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override {
       Error error;
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 's': {
         OptionValueSP value_sp(OptionValueUInt64::Create(option_value, error));
         if (value_sp)
           set_indexes.AppendValue(value_sp);
       } break;
 
       case 'a':
Error SetOptionValue(uint32_t option_idx, const char *option_value,
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                        short_option);
         break;
       }
       return error;
     }
 
-    // Options table: Required for subclasses of Options.
-
-    static const OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
     OptionValueArray set_indexes;
     OptionValueBoolean dump_all_sets;
     OptionValueBoolean alternate_name;
   };
 
   OptionGroupOptions m_option_group;
   OptionGroupFormat m_format_options;
   CommandOptions m_command_options;
 };
 
-const OptionDefinition
-    CommandObjectRegisterRead::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "alternate", 'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,  "Display register names using the alternate register name if there is one."},
-  {LLDB_OPT_SET_1,   false, "set",       's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeIndex, "Specify which register sets to dump by index."},
-  {LLDB_OPT_SET_2,   false, "all",       'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,  "Show all register sets."},
-        // clang-format on
-};
-
-uint32_t CommandObjectRegisterRead::CommandOptions::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
-
 //----------------------------------------------------------------------
 // "register write"
 //----------------------------------------------------------------------
 class CommandObjectRegisterWrite : public CommandObjectParsed {
 public:
   CommandObjectRegisterWrite(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "register write",
                             "Modify a single register value.", nullptr,

lldb/trunk/source/Commands/CommandObjectSettings.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectSettingsSet
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_settings_set_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_2, false, "global", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Apply the new value to the global default value." }
+    // clang-format on
+};
+
 class CommandObjectSettingsSet : public CommandObjectRaw {
 public:
   CommandObjectSettingsSet(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "settings set",
                          "Set the value of the specified debugger setting.",
                          nullptr),
         m_options() {
     CommandArgumentEntry arg1;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_global = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_settings_set_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     bool m_global;
   };
 
   int HandleArgumentCompletion(Args &input, int &cursor_index,
                                int &cursor_char_position,
bool DoExecute(const char *command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectSettingsSet::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_2, false, "global", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Apply the new value to the global default value."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectSettingsShow -- Show current values
 //-------------------------------------------------------------------------
 
 class CommandObjectSettingsShow : public CommandObjectParsed {
 public:
   CommandObjectSettingsShow(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "settings show",

lldb/trunk/source/Commands/CommandObjectSource.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark CommandObjectSourceInfo
 //----------------------------------------------------------------------
 // CommandObjectSourceInfo - debug line entries dumping command
 //----------------------------------------------------------------------
 
+static OptionDefinition g_source_info_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL,                false, "count",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "The number of line entries to display." },
+  { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib",    's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Look up the source in the given module or shared library (can be specified more than once)." },
+  { LLDB_OPT_SET_1,                  false, "file",     'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "The file from which to display source." },
+  { LLDB_OPT_SET_1,                  false, "line",     'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to start the displaying lines." },
+  { LLDB_OPT_SET_1,                  false, "end-line", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to stop displaying lines." },
+  { LLDB_OPT_SET_2,                  false, "name",     'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeSymbol,              "The name of a function whose source to display." },
+  { LLDB_OPT_SET_3,                  false, "address",  'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line." },
+    // clang-format on
+};
+
 class CommandObjectSourceInfo : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 'l':
         start_line = StringConvert::ToUInt32(option_arg, 0);
         if (start_line == 0)
           error.SetErrorStringWithFormat("invalid line number: '%s'",
                                          option_arg);
         break;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       symbol_name.clear();
       address = LLDB_INVALID_ADDRESS;
       start_line = 0;
       end_line = 0;
       num_lines = 0;
       modules.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_source_info_options;
+    }
 
     // Instance variables to hold the values for command options.
     FileSpec file_spec;
     std::string file_name;
     std::string symbol_name;
     lldb::addr_t address;
     uint32_t start_line;
     uint32_t end_line;
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
   ModuleList m_module_list;
 };
 
-OptionDefinition CommandObjectSourceInfo::CommandOptions::g_option_table[] = {
+#pragma mark CommandObjectSourceList
+//-------------------------------------------------------------------------
+// CommandObjectSourceList
+//-------------------------------------------------------------------------
+
+static OptionDefinition g_source_list_options[] = {
     // clang-format off
-  {LLDB_OPT_SET_ALL,                false, "count",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "The number of line entries to display."},
-  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib",    's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Look up the source in the given module or shared library (can be specified more than once)."},
-  {LLDB_OPT_SET_1,                  false, "file",     'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "The file from which to display source."},
-  {LLDB_OPT_SET_1,                  false, "line",     'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to start the displaying lines."},
-  {LLDB_OPT_SET_1,                  false, "end-line", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to stop displaying lines."},
-  {LLDB_OPT_SET_2,                  false, "name",     'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeSymbol,              "The name of a function whose source to display."},
-  {LLDB_OPT_SET_3,                  false, "address",  'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
+  { LLDB_OPT_SET_ALL,                false, "count",            'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "The number of source lines to display." },
+  { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib",            's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Look up the source file in the given shared library." },
+  { LLDB_OPT_SET_ALL,                false, "show-breakpoints", 'b', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Show the line table locations from the debug information that indicate valid places to set source level breakpoints." },
+  { LLDB_OPT_SET_1,                  false, "file",             'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "The file from which to display source." },
+  { LLDB_OPT_SET_1,                  false, "line",             'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to start the display source." },
+  { LLDB_OPT_SET_2,                  false, "name",             'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeSymbol,              "The name of a function whose source to display." },
+  { LLDB_OPT_SET_3,                  false, "address",          'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line." },
+  { LLDB_OPT_SET_4,                  false, "reverse",          'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Reverse the listing to look backwards from the last displayed block of source." },
     // clang-format on
 };
 
-#pragma mark CommandObjectSourceList
-//-------------------------------------------------------------------------
-// CommandObjectSourceList
-//-------------------------------------------------------------------------
-
 class CommandObjectSourceList : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 'l':
         start_line = StringConvert::ToUInt32(option_arg, 0);
         if (start_line == 0)
           error.SetErrorStringWithFormat("invalid line number: '%s'",
                                          option_arg);
         break;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       address = LLDB_INVALID_ADDRESS;
       start_line = 0;
       num_lines = 0;
       show_bp_locs = false;
       reverse = false;
       modules.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_source_list_options;
+    }
 
     // Instance variables to hold the values for command options.
     FileSpec file_spec;
     std::string file_name;
     std::string symbol_name;
     lldb::addr_t address;
     uint32_t start_line;
     uint32_t num_lines;
const SymbolContextList *GetBreakpointLocations() {
     return nullptr;
   }
 
   CommandOptions m_options;
   FileLineResolver m_breakpoint_locations;
   std::string m_reverse_name;
 };
 
-OptionDefinition CommandObjectSourceList::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL,                false, "count",            'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeCount,               "The number of source lines to display."},
-  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib",            's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion,     eArgTypeShlibName,           "Look up the source file in the given shared library."},
-  {LLDB_OPT_SET_ALL,                false, "show-breakpoints", 'b', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Show the line table locations from the debug information that indicate valid places to set source level breakpoints."},
-  {LLDB_OPT_SET_1,                  false, "file",             'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "The file from which to display source."},
-  {LLDB_OPT_SET_1,                  false, "line",             'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "The line number at which to start the display source."},
-  {LLDB_OPT_SET_2,                  false, "name",             'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion,     eArgTypeSymbol,              "The name of a function whose source to display."},
-  {LLDB_OPT_SET_3,                  false, "address",          'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."},
-  {LLDB_OPT_SET_4,                  false, "reverse",          'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Reverse the listing to look backwards from the last displayed block of source."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 #pragma mark CommandObjectMultiwordSource
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordSource
 //-------------------------------------------------------------------------
 
 CommandObjectMultiwordSource::CommandObjectMultiwordSource(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "source", "Commands for examining "

lldb/trunk/source/Commands/CommandObjectTarget.cpp

if (num_dumped > 0) {
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 };
 
 #pragma mark CommandObjectTargetModulesDumpSymtab
 
+static OptionEnumValueElement g_sort_option_enumeration[4] = {
+    {eSortOrderNone, "none",
+     "No sorting, use the original symbol table order."},
+    {eSortOrderByAddress, "address", "Sort output by symbol address."},
+    {eSortOrderByName, "name", "Sort output by symbol name."},
+    {0, nullptr, nullptr}};
+
+static OptionDefinition g_target_modules_dump_symtab_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table." }
+    // clang-format on
+};
+
 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),
         m_options() {}
public:
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 's':
         m_sort_order = (SortOrder)Args::StringToOptionEnum(
-            option_arg, g_option_table[option_idx].enum_values, eSortOrderNone,
-            error);
+            option_arg, GetDefinitions()[option_idx].enum_values,
+            eSortOrderNone, error);
         break;
 
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_sort_order = eSortOrderNone;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_target_modules_dump_symtab_options;
+    }
 
     SortOrder m_sort_order;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
     if (target == nullptr) {
if (target == nullptr) {
       }
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-static OptionEnumValueElement g_sort_option_enumeration[4] = {
-    {eSortOrderNone, "none",
-     "No sorting, use the original symbol table order."},
-    {eSortOrderByAddress, "address", "Sort output by symbol address."},
-    {eSortOrderByName, "name", "Sort output by symbol name."},
-    {0, nullptr, nullptr}};
-
-OptionDefinition
-    CommandObjectTargetModulesDumpSymtab::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 #pragma mark CommandObjectTargetModulesDumpSections
 
 //----------------------------------------------------------------------
 // Image section dumping command
 //----------------------------------------------------------------------
 
 class CommandObjectTargetModulesDumpSections
     : public CommandObjectTargetModulesModuleAutoComplete {
protected:
   OptionGroupUUID m_uuid_option_group;
   OptionGroupString m_file_option;
   OptionGroupUInt64 m_slide_option;
 };
 
 //----------------------------------------------------------------------
 // List images with associated information
 //----------------------------------------------------------------------
+
+static OptionDefinition g_target_modules_list_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "address",        'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Display the image at this address." },
+  { LLDB_OPT_SET_1, false, "arch",           'A', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the architecture when listing images." },
+  { LLDB_OPT_SET_1, false, "triple",         't', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the triple when listing images." },
+  { LLDB_OPT_SET_1, false, "header",         'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address as a load address if debugging, a file address otherwise." },
+  { LLDB_OPT_SET_1, false, "offset",         'o', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address offset from the header file address (the slide amount)." },
+  { LLDB_OPT_SET_1, false, "uuid",           'u', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the UUID when listing images." },
+  { LLDB_OPT_SET_1, false, "fullpath",       'f', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image object file." },
+  { LLDB_OPT_SET_1, false, "directory",      'd', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the directory with optional width for the image object file." },
+  { LLDB_OPT_SET_1, false, "basename",       'b', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the basename with optional width for the image object file." },
+  { LLDB_OPT_SET_1, false, "symfile",        's', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image symbol file with optional width." },
+  { LLDB_OPT_SET_1, false, "symfile-unique", 'S', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the symbol file with optional width only if it is different from the executable object file." },
+  { LLDB_OPT_SET_1, false, "mod-time",       'm', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the modification time with optional width of the module." },
+  { LLDB_OPT_SET_1, false, "ref-count",      'r', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the reference count if the module is still in the shared module cache." },
+  { LLDB_OPT_SET_1, false, "pointer",        'p', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeNone,                "Display the module pointer." },
+  { LLDB_OPT_SET_1, false, "global",         'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the modules from the global module list, not just the current target." }
+    // clang-format on
+};
+
 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) {}
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_format_array.clear();
       m_use_global_module_list = false;
       m_module_addr = LLDB_INVALID_ADDRESS;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_target_modules_list_options;
+    }
 
     // Instance variables to hold the values for command options.
     typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection;
     FormatWidthCollection m_format_array;
     bool m_use_global_module_list;
     lldb::addr_t m_module_addr;
   };
 
if (dump_object_name) {
         strm.Printf("(%s)", object_name);
     }
     strm.EOL();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectTargetModulesList::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "address",        'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Display the image at this address."},
-  {LLDB_OPT_SET_1, false, "arch",           'A', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the architecture when listing images."},
-  {LLDB_OPT_SET_1, false, "triple",         't', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the triple when listing images."},
-  {LLDB_OPT_SET_1, false, "header",         'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address as a load address if debugging, a file address otherwise."},
-  {LLDB_OPT_SET_1, false, "offset",         'o', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the image header address offset from the header file address (the slide amount)."},
-  {LLDB_OPT_SET_1, false, "uuid",           'u', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the UUID when listing images."},
-  {LLDB_OPT_SET_1, false, "fullpath",       'f', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image object file."},
-  {LLDB_OPT_SET_1, false, "directory",      'd', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the directory with optional width for the image object file."},
-  {LLDB_OPT_SET_1, false, "basename",       'b', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the basename with optional width for the image object file."},
-  {LLDB_OPT_SET_1, false, "symfile",        's', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the fullpath to the image symbol file with optional width."},
-  {LLDB_OPT_SET_1, false, "symfile-unique", 'S', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the symbol file with optional width only if it is different from the executable object file."},
-  {LLDB_OPT_SET_1, false, "mod-time",       'm', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the modification time with optional width of the module."},
-  {LLDB_OPT_SET_1, false, "ref-count",      'r', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeWidth,               "Display the reference count if the module is still in the shared module cache."},
-  {LLDB_OPT_SET_1, false, "pointer",        'p', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeNone,                "Display the module pointer."},
-  {LLDB_OPT_SET_1, false, "global",         'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Display the modules from the global module list, not just the current target."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 #pragma mark CommandObjectTargetModulesShowUnwind
 
 //----------------------------------------------------------------------
 // Lookup unwind information in images
 //----------------------------------------------------------------------
 
+static OptionDefinition g_target_modules_show_unwind_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "name",    'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Show unwind instructions for a function or symbol name." },
+  { LLDB_OPT_SET_2, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Show unwind instructions for a function or symbol containing an address" }
+    // clang-format on
+};
+
 class CommandObjectTargetModulesShowUnwind : public CommandObjectParsed {
 public:
   enum {
     eLookupTypeInvalid = -1,
     eLookupTypeAddress = 0,
     eLookupTypeSymbol,
     eLookupTypeFunction,
     eLookupTypeFunctionOrSymbol,
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_type = eLookupTypeInvalid;
       m_str.clear();
       m_addr = LLDB_INVALID_ADDRESS;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_target_modules_show_unwind_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     int m_type;        // Should be a eLookupTypeXXX enum after parsing options
     std::string m_str; // Holds name lookup
     lldb::addr_t m_addr; // Holds the address to lookup
   };
 
for (uint32_t idx = 0; idx < num_matches; idx++) {
       result.GetOutputStream().Printf("\n");
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectTargetModulesShowUnwind::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "name",    'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Show unwind instructions for a function or symbol name."},
-  {LLDB_OPT_SET_2, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Show unwind instructions for a function or symbol containing an address"},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//----------------------------------------------------------------------
+// Lookup information in images
+//----------------------------------------------------------------------
+
+static OptionDefinition g_target_modules_lookup_options[] = {
+  { LLDB_OPT_SET_1,                                  true,  "address",    'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Lookup an address in one or more target modules." },
+  { LLDB_OPT_SET_1,                                  false, "offset",     'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset,              "When looking up an address subtract <offset> from any addresses before doing the lookup." },
+  /* FIXME: re-enable regex for types when the LookupTypeInModule actually uses the regex option: | LLDB_OPT_SET_6 */
+  { LLDB_OPT_SET_2 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "regex",      'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "The <name> argument for name lookups are regular expressions." },
+  { LLDB_OPT_SET_2,                                  true,  "symbol",     's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSymbol,              "Lookup a symbol by name in the symbol tables in one or more target modules." },
+  { LLDB_OPT_SET_3,                                  true,  "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename,            "Lookup a file by fullpath or basename in one or more target modules." },
+  { LLDB_OPT_SET_3,                                  false, "line",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,             "Lookup a line number in a file (must be used in conjunction with --file)." },
+  { LLDB_OPT_SET_FROM_TO(3,5),                       false, "no-inlines", 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Ignore inline entries (must be used in conjunction with --file or --function)." },
+  { LLDB_OPT_SET_4,                                  true,  "function",   'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Lookup a function by name in the debug symbols in one or more target modules." },
+  { LLDB_OPT_SET_5,                                  true,  "name",       'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionOrSymbol,    "Lookup a function or symbol by name in one or more target modules." },
+  { LLDB_OPT_SET_6,                                  true,  "type",       't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,                "Lookup a type by name in the debug symbols in one or more target modules." },
+  { LLDB_OPT_SET_ALL,                                false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Enable verbose lookup information." },
+  { LLDB_OPT_SET_ALL,                                false, "all",        'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Print all matches, not just the best match, if a best match is available." },
 };
 
-//----------------------------------------------------------------------
-// Lookup information in images
-//----------------------------------------------------------------------
 class CommandObjectTargetModulesLookup : public CommandObjectParsed {
 public:
   enum {
     eLookupTypeInvalid = -1,
     eLookupTypeAddress = 0,
     eLookupTypeSymbol,
     eLookupTypeFileLine, // Line is optional
     eLookupTypeFunction,
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_offset = 0;
       m_line_number = 0;
       m_use_regex = false;
       m_include_inlines = true;
       m_verbose = false;
       m_print_all = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_target_modules_lookup_options;
+    }
 
-    static OptionDefinition g_option_table[];
     int m_type;        // Should be a eLookupTypeXXX enum after parsing options
     std::string m_str; // Holds name lookup
     FileSpec m_file;   // Files for file lookups
     lldb::addr_t m_addr; // Holds the address to lookup
     lldb::addr_t
         m_offset; // Subtract this offset from m_addr before doing lookups.
     uint32_t m_line_number; // Line number for file+line lookups
     bool m_use_regex;       // Name lookups in m_str are regular expressions.
if (target == nullptr) {
         result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectTargetModulesLookup::CommandOptions::g_option_table[] =
-        {
-            // clang-format off
-  {LLDB_OPT_SET_1,                                  true,  "address",    'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeAddressOrExpression, "Lookup an address in one or more target modules."},
-  {LLDB_OPT_SET_1,                                  false, "offset",     'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOffset,              "When looking up an address subtract <offset> from any addresses before doing the lookup."},
-  /* FIXME: re-enable regex for types when the LookupTypeInModule actually uses the regex option: | LLDB_OPT_SET_6 */
-  {LLDB_OPT_SET_2| LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "regex",      'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "The <name> argument for name lookups are regular expressions."},
-  {LLDB_OPT_SET_2,                                  true,  "symbol",     's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSymbol,              "Lookup a symbol by name in the symbol tables in one or more target modules."},
-  {LLDB_OPT_SET_3,                                  true,  "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename,            "Lookup a file by fullpath or basename in one or more target modules."},
-  {LLDB_OPT_SET_3,                                  false, "line",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,             "Lookup a line number in a file (must be used in conjunction with --file)."},
-  {LLDB_OPT_SET_FROM_TO(3,5),                       false, "no-inlines", 'i', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Ignore inline entries (must be used in conjunction with --file or --function)."},
-  {LLDB_OPT_SET_4,                                  true,  "function",   'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionName,        "Lookup a function by name in the debug symbols in one or more target modules."},
-  {LLDB_OPT_SET_5,                                  true,  "name",       'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFunctionOrSymbol,    "Lookup a function or symbol by name in one or more target modules."},
-  {LLDB_OPT_SET_6,                                  true,  "type",       't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,                "Lookup a type by name in the debug symbols in one or more target modules."},
-  {LLDB_OPT_SET_ALL,                                false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Enable verbose lookup information."},
-  {LLDB_OPT_SET_ALL,                                false, "all",        'A', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,                "Print all matches, not just the best match, if a best match is available."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-            // clang-format on
-};
-
 #pragma mark CommandObjectMultiwordImageSearchPaths
 
 //-------------------------------------------------------------------------
 // CommandObjectMultiwordImageSearchPaths
 //-------------------------------------------------------------------------
 
 class CommandObjectTargetModulesImageSearchPaths
     : public CommandObjectMultiword {

 };
 
 #pragma mark CommandObjectTargetStopHookAdd
 
 //-------------------------------------------------------------------------
 // CommandObjectTargetStopHookAdd
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_target_stop_hook_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "one-liner",    'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner,                                         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes." },
+  { LLDB_OPT_SET_ALL, false, "shlib",        's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion, eArgTypeShlibName,    "Set the module within which the stop-hook is to be run." },
+  { LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadIndex,                                      "The stop hook is run only for the thread whose index matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadID,                                         "The stop hook is run only for the thread whose TID matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadName,                                       "The stop hook is run only for the thread whose thread name matches this argument." },
+  { LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeQueueName,                                        "The stop hook is run only for threads in the queue whose name is given by this argument." },
+  { LLDB_OPT_SET_1,   false, "file",         'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the source file within which the stop-hook is to be run." },
+  { LLDB_OPT_SET_1,   false, "start-line",   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the start of the line range for which the stop-hook is to be run." },
+  { LLDB_OPT_SET_1,   false, "end-line",     'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the end of the line range for which the stop-hook is to be run." },
+  { LLDB_OPT_SET_2,   false, "classname",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeClassName,                                        "Specify the class within which the stop-hook is to be run." },
+  { LLDB_OPT_SET_3,   false, "name",         'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the function name within which the stop hook will be run." },
+    // clang-format on
+};
+
 class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_line_start(0), m_line_end(UINT_MAX),
           m_func_name_type_mask(eFunctionNameTypeAuto),
           m_sym_ctx_specified(false), m_thread_specified(false),
           m_use_one_liner(false), m_one_liner() {}
 
     ~CommandOptions() override = default;
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_target_stop_hook_add_options;
+    }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
       bool success;
 
       switch (short_option) {
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_no_inlines = false;
       m_sym_ctx_specified = false;
       m_thread_specified = false;
 
       m_use_one_liner = false;
       m_one_liner.clear();
     }
 
-    static OptionDefinition g_option_table[];
-
     std::string m_class_name;
     std::string m_function_name;
     uint32_t m_line_start;
     uint32_t m_line_end;
     std::string m_file_name;
     std::string m_module_name;
     uint32_t m_func_name_type_mask; // A pick from lldb::FunctionNameType.
     lldb::tid_t m_thread_id;
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
   Target::StopHookSP m_stop_hook_sp;
 };
 
-OptionDefinition
-    CommandObjectTargetStopHookAdd::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "one-liner",    'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeOneLiner,                                         "Specify a one-line breakpoint command inline. Be sure to surround it with quotes."},
-  {LLDB_OPT_SET_ALL, false, "shlib",        's', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eModuleCompletion, eArgTypeShlibName,    "Set the module within which the stop-hook is to be run."},
-  {LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadIndex,                                      "The stop hook is run only for the thread whose index matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "thread-id",    't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadID,                                         "The stop hook is run only for the thread whose TID matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "thread-name",  'T', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeThreadName,                                       "The stop hook is run only for the thread whose thread name matches this argument."},
-  {LLDB_OPT_SET_ALL, false, "queue-name",   'q', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeQueueName,                                        "The stop hook is run only for threads in the queue whose name is given by this argument."},
-  {LLDB_OPT_SET_1,   false, "file",         'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the source file within which the stop-hook is to be run."},
-  {LLDB_OPT_SET_1,   false, "start-line",   'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the start of the line range for which the stop-hook is to be run."},
-  {LLDB_OPT_SET_1,   false, "end-line",     'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLineNum,                                          "Set the end of the line range for which the stop-hook is to be run."},
-  {LLDB_OPT_SET_2,   false, "classname",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeClassName,                                        "Specify the class within which the stop-hook is to be run."},
-  {LLDB_OPT_SET_3,   false, "name",         'n', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the function name within which the stop hook will be run."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-        // clang-format on
-};
-
 #pragma mark CommandObjectTargetStopHookDelete
 
 //-------------------------------------------------------------------------
 // CommandObjectTargetStopHookDelete
 //-------------------------------------------------------------------------
 
 class CommandObjectTargetStopHookDelete : public CommandObjectParsed {
 public:

lldb/trunk/source/Commands/CommandObjectThread.cpp

protected:
   ReturnStatus m_success_return = eReturnStatusSuccessFinishResult;
   bool m_add_return = true;
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadBacktrace
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_backtrace_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,      "How many frames to display (-1 for all)" },
+  { LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace" },
+  { LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,    "Show the extended backtrace, if available" }
+    // clang-format on
+};
+
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_count = UINT32_MAX;
       m_start = 0;
       m_extended_backtrace = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_backtrace_options;
+    }
 
     // Instance variables to hold the values for command options.
     uint32_t m_count;
     uint32_t m_start;
     bool m_extended_backtrace;
   };
 
   CommandObjectThreadBacktrace(CommandInterpreter &interpreter)
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     }
 
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectThreadBacktrace::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "count",    'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,      "How many frames to display (-1 for all)"},
-  {LLDB_OPT_SET_1, false, "start",    's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFrameIndex, "Frame in which to start the backtrace"},
-  {LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,    "Show the extended backtrace, if available"},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+enum StepScope { eStepScopeSource, eStepScopeInstruction };
+
+static OptionEnumValueElement g_tri_running_mode[] = {
+    {eOnlyThisThread, "this-thread", "Run only this thread"},
+    {eAllThreads, "all-threads", "Run all threads"},
+    {eOnlyDuringStepping, "while-stepping",
+     "Run only this thread while stepping"},
+    {0, nullptr, nullptr}};
+
+static OptionEnumValueElement g_duo_running_mode[] = {
+    {eOnlyThisThread, "this-thread", "Run only this thread"},
+    {eAllThreads, "all-threads", "Run all threads"},
+    {0, nullptr, nullptr}};
+
+static OptionDefinition g_thread_step_scope_options[] = {
+  { LLDB_OPT_SET_1, false, "step-in-avoids-no-debug",   'a', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeBoolean,           "A boolean value that sets whether stepping into functions will step over functions with no debug information." },
+  { LLDB_OPT_SET_1, false, "step-out-avoids-no-debug",  'A', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeBoolean,           "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information." },
+  { LLDB_OPT_SET_1, false, "count",                     'c', OptionParser::eRequiredArgument, nullptr, nullptr,            1, eArgTypeCount,             "How many times to perform the stepping operation - currently only supported for step-inst and next-inst." },
+  { LLDB_OPT_SET_1, false, "end-linenumber",            'e', OptionParser::eRequiredArgument, nullptr, nullptr,            1, eArgTypeLineNum,           "The line at which to stop stepping - defaults to the next line and only supported for step-in and step-over.  You can also pass the string 'block' to step to the end of the current block.  This is particularly useful in conjunction with --step-target to step through a complex calling sequence." },
+  { LLDB_OPT_SET_1, false, "run-mode",                  'm', OptionParser::eRequiredArgument, nullptr, g_tri_running_mode, 0, eArgTypeRunMode,           "Determine how to run other threads while stepping the current thread." },
+  { LLDB_OPT_SET_1, false, "step-over-regexp",          'r', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeRegularExpression, "A regular expression that defines function names to not to stop at when stepping in." },
+  { LLDB_OPT_SET_1, false, "step-in-target",            't', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeFunctionName,      "The name of the directly called function step in should stop at when stepping into." },
+  { LLDB_OPT_SET_2, false, "python-class",              'C', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypePythonClass,       "The name of the class that will manage this step - only supported for Scripted Step." }
 };
 
-enum StepScope { eStepScopeSource, eStepScopeInstruction };
-
 class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       case 'C':
         m_class_name.clear();
         m_class_name.assign(option_arg);
         break;
 
       case 'm': {
         OptionEnumValueElement *enum_values =
-            g_option_table[option_idx].enum_values;
+            GetDefinitions()[option_idx].enum_values;
         m_run_mode = (lldb::RunMode)Args::StringToOptionEnum(
             option_arg, enum_values, eOnlyDuringStepping, error);
       } break;
 
       case 'e': {
         if (strcmp(option_arg, "block") == 0) {
           m_end_line_is_block_end = 1;
           break;
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_avoid_regexp.clear();
       m_step_in_target.clear();
       m_class_name.clear();
       m_step_count = 1;
       m_end_line = LLDB_INVALID_LINE_NUMBER;
       m_end_line_is_block_end = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_step_scope_options;
+    }
 
     // Instance variables to hold the values for command options.
     LazyBool m_step_in_avoid_no_debug;
     LazyBool m_step_out_avoid_no_debug;
     RunMode m_run_mode;
     std::string m_avoid_regexp;
     std::string m_step_in_target;
     std::string m_class_name;
protected:
   }
 
 protected:
   StepType m_step_type;
   StepScope m_step_scope;
   CommandOptions m_options;
 };
 
-static OptionEnumValueElement g_tri_running_mode[] = {
-    {eOnlyThisThread, "this-thread", "Run only this thread"},
-    {eAllThreads, "all-threads", "Run all threads"},
-    {eOnlyDuringStepping, "while-stepping",
-     "Run only this thread while stepping"},
-    {0, nullptr, nullptr}};
-
-static OptionEnumValueElement g_duo_running_mode[] = {
-    {eOnlyThisThread, "this-thread", "Run only this thread"},
-    {eAllThreads, "all-threads", "Run all threads"},
-    {0, nullptr, nullptr}};
-
-OptionDefinition CommandObjectThreadStepWithTypeAndScope::CommandOptions::
-    g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "step-in-avoids-no-debug",   'a', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeBoolean,           "A boolean value that sets whether stepping into functions will step over functions with no debug information."},
-  {LLDB_OPT_SET_1, false, "step-out-avoids-no-debug",  'A', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeBoolean,           "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information."},
-  {LLDB_OPT_SET_1, false, "count",                     'c', OptionParser::eRequiredArgument, nullptr, nullptr,            1, eArgTypeCount,             "How many times to perform the stepping operation - currently only supported for step-inst and next-inst."},
-  {LLDB_OPT_SET_1, false, "end-linenumber",            'e', OptionParser::eRequiredArgument, nullptr, nullptr,            1, eArgTypeLineNum,           "The line at which to stop stepping - defaults to the next line and only supported for step-in and step-over.  You can also pass the string 'block' to step to the end of the current block.  This is particularly useful in conjunction with --step-target to step through a complex calling sequence."},
-  {LLDB_OPT_SET_1, false, "run-mode",                  'm', OptionParser::eRequiredArgument, nullptr, g_tri_running_mode, 0, eArgTypeRunMode,           "Determine how to run other threads while stepping the current thread."},
-  {LLDB_OPT_SET_1, false, "step-over-regexp",          'r', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeRegularExpression, "A regular expression that defines function names to not to stop at when stepping in."},
-  {LLDB_OPT_SET_1, false, "step-in-target",            't', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeFunctionName,      "The name of the directly called function step in should stop at when stepping into."},
-  {LLDB_OPT_SET_2, false, "python-class",              'C', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypePythonClass,       "The name of the class that will manage this step - only supported for Scripted Step."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectThreadContinue
 //-------------------------------------------------------------------------
 
 class CommandObjectThreadContinue : public CommandObjectParsed {
 public:
   CommandObjectThreadContinue(CommandInterpreter &interpreter)
       : CommandObjectParsed(
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadUntil
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_until_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "frame",   'f', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeFrameIndex,          "Frame index for until operation - defaults to 0" },
+  { LLDB_OPT_SET_1, false, "thread",  't', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeThreadIndex,         "Thread index for the thread for until operation" },
+  { LLDB_OPT_SET_1, false, "run-mode",'m', OptionParser::eRequiredArgument, nullptr, g_duo_running_mode, 0, eArgTypeRunMode,             "Determine how to run other threads while stepping this one" },
+  { LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeAddressOrExpression, "Run until we reach the specified address, or leave the function - can be specified multiple times." }
+    // clang-format on
+};
+
 class CommandObjectThreadUntil : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     uint32_t m_thread_idx;
     uint32_t m_frame_idx;
 
     CommandOptions()
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
             StringConvert::ToUInt32(option_arg, LLDB_INVALID_FRAME_ID);
         if (m_frame_idx == LLDB_INVALID_FRAME_ID) {
           error.SetErrorStringWithFormat("invalid frame index '%s'",
                                          option_arg);
         }
         break;
       case 'm': {
         OptionEnumValueElement *enum_values =
-            g_option_table[option_idx].enum_values;
+            GetDefinitions()[option_idx].enum_values;
         lldb::RunMode run_mode = (lldb::RunMode)Args::StringToOptionEnum(
             option_arg, enum_values, eOnlyDuringStepping, error);
 
         if (error.Success()) {
           if (run_mode == eAllThreads)
             m_stop_others = false;
           else
             m_stop_others = true;
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_thread_idx = LLDB_INVALID_THREAD_ID;
       m_frame_idx = 0;
       m_stop_others = false;
       m_until_addrs.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_until_options;
+    }
 
     uint32_t m_step_thread_idx;
     bool m_stop_others;
     std::vector<lldb::addr_t> m_until_addrs;
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
   };
 
   CommandObjectThreadUntil(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "thread until",
             "Continue until a line number or address is reached by the "
             "current or specified thread.  Stops when returning from "
if (process == nullptr) {
       }
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectThreadUntil::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_1, false, "frame",   'f', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeFrameIndex,          "Frame index for until operation - defaults to 0"},
-  {LLDB_OPT_SET_1, false, "thread",  't', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeThreadIndex,         "Thread index for the thread for until operation"},
-  {LLDB_OPT_SET_1, false, "run-mode",'m', OptionParser::eRequiredArgument, nullptr, g_duo_running_mode, 0, eArgTypeRunMode,             "Determine how to run other threads while stepping this one"},
-  {LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr,            0, eArgTypeAddressOrExpression, "Run until we reach the specified address, or leave the function - can be specified multiple times."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectThreadSelect
 //-------------------------------------------------------------------------
 
 class CommandObjectThreadSelect : public CommandObjectParsed {
 public:
   CommandObjectThreadSelect(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "thread select",
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadInfo
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_info_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "json",      'j', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display the thread info in JSON format." },
+  { LLDB_OPT_SET_ALL, false, "stop-info", 's', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display the extended stop info in JSON format." }
+    // clang-format on
+};
+
 class CommandObjectThreadInfo : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         break;
 
       default:
         return Error("invalid short option character '%c'", short_option);
       }
       return error;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_info_options;
+    }
 
     bool m_json_thread;
     bool m_json_stopinfo;
-
-    static OptionDefinition g_option_table[];
   };
 
   CommandObjectThreadInfo(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread info", "Show an extended summary of one or "
                                         "more threads.  Defaults to the "
                                         "current thread.",
             "thread info",
if (!thread->GetDescription(strm, eDescriptionLevelFull,
       return false;
     }
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectThreadInfo::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL, false, "json",      'j', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display the thread info in JSON format."},
-  {LLDB_OPT_SET_ALL, false, "stop-info", 's', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display the extended stop info in JSON format."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectThreadReturn
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_return_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Return from the innermost expression evaluation." }
+    // clang-format on
+};
+
 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
       // ()
       OptionParsingStarting(nullptr);
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_from_expression = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_return_options;
+    }
 
     bool m_from_expression;
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
   };
 
   CommandObjectThreadReturn(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "thread return",
                          "Prematurely return from a stack frame, "
                          "short-circuiting execution of newer frames "
                          "and optionally yielding a specified value.  Defaults "
bool DoExecute(const char *command, CommandReturnObject &result) override {
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectThreadReturn::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Return from the innermost expression evaluation."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectThreadJump
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_jump_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1,                                   false, "file",    'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "Specifies the source file to jump to." },
+  { LLDB_OPT_SET_1,                                   true,  "line",    'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "Specifies the line number to jump to." },
+  { LLDB_OPT_SET_2,                                   true,  "by",      'b', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeOffset,              "Jumps by a relative line offset from the current line." },
+  { LLDB_OPT_SET_3,                                   true,  "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Jumps to a specific address." },
+  { LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force",   'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Allows the PC to leave the current function." }
+    // clang-format on
+};
+
 class CommandObjectThreadJump : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() { OptionParsingStarting(nullptr); }
 
     ~CommandOptions() override = default;
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         m_force = true;
         break;
       default:
         return Error("invalid short option character '%c'", short_option);
       }
       return error;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_jump_options;
+    }
 
     FileSpecList m_filenames;
     uint32_t m_line_num;
     int32_t m_line_offset;
     lldb::addr_t m_load_addr;
     bool m_force;
-
-    static OptionDefinition g_option_table[];
   };
 
   CommandObjectThreadJump(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "thread jump",
             "Sets the program counter to a new address.", "thread jump",
             eCommandRequiresFrame | eCommandTryTargetAPILock |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
bool DoExecute(Args &args, CommandReturnObject &result) override {
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectThreadJump::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_1,                                   false, "file",    'f', OptionParser::eRequiredArgument, nullptr, nullptr, CommandCompletions::eSourceFileCompletion, eArgTypeFilename,            "Specifies the source file to jump to."},
-  {LLDB_OPT_SET_1,                                   true,  "line",    'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeLineNum,             "Specifies the line number to jump to."},
-  {LLDB_OPT_SET_2,                                   true,  "by",      'b', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeOffset,              "Jumps by a relative line offset from the current line."},
-  {LLDB_OPT_SET_3,                                   true,  "address", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0,                                         eArgTypeAddressOrExpression, "Jumps to a specific address."},
-  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force",   'r', OptionParser::eNoArgument,       nullptr, nullptr, 0,                                         eArgTypeNone,                "Allows the PC to leave the current function."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-    // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // Next are the subcommands of CommandObjectMultiwordThreadPlan
 //-------------------------------------------------------------------------
 
 //-------------------------------------------------------------------------
 // CommandObjectThreadPlanList
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_thread_plan_list_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "verbose",  'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display more information about the thread plans" },
+  { LLDB_OPT_SET_1, false, "internal", 'i', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display internal as well as user thread plans" }
+    // clang-format on
+};
+
 class CommandObjectThreadPlanList : public CommandObjectIterateOverThreads {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_verbose = false;
       m_internal = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_thread_plan_list_options;
+    }
 
     // Instance variables to hold the values for command options.
     bool m_verbose;
     bool m_internal;
   };
 
   CommandObjectThreadPlanList(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
 
     thread->DumpThreadPlans(&strm, desc_level, m_options.m_internal, true);
     return true;
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectThreadPlanList::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "verbose",  'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display more information about the thread plans"},
-  {LLDB_OPT_SET_1, false, "internal", 'i', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Display internal as well as user thread plans"},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 class CommandObjectThreadPlanDiscard : public CommandObjectParsed {
 public:
   CommandObjectThreadPlanDiscard(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "thread plan discard",
                             "Discards thread plans up to and including the "
                             "specified index (see 'thread plan list'.)  "
                             "Only user visible plans can be discarded.",
                             nullptr,

lldb/trunk/source/Commands/CommandObjectType.cpp

if (idx + 1 < command.GetArgumentCount()) {
           return true;
         }
       }
     }
   }
   return false;
 }
 
+static OptionDefinition g_type_summary_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL,                false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one." },
+  { LLDB_OPT_SET_ALL,                false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains." },
+  { LLDB_OPT_SET_ALL,                false, "no-value",        'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't show the value, just show the summary, for this type." },
+  { LLDB_OPT_SET_ALL,                false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects." },
+  { LLDB_OPT_SET_ALL,                false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects." },
+  { LLDB_OPT_SET_ALL,                false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions." },
+  { LLDB_OPT_SET_1,                  true,  "inline-children", 'c', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, inline all child values into summary string." },
+  { LLDB_OPT_SET_1,                  false, "omit-names",      'O', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, omit value names in the summary display." },
+  { LLDB_OPT_SET_2,                  true,  "summary-string",  's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSummaryString,  "Summary string used to display text and object contents." },
+  { LLDB_OPT_SET_3,                  false, "python-script",   'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonScript,   "Give a one-liner Python script as part of the command." },
+  { LLDB_OPT_SET_3,                  false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type." },
+  { LLDB_OPT_SET_3,                  false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Input Python code to use for this type manually." },
+  { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand",          'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Expand aggregate data types to show children on separate lines." },
+  { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "hide-empty",      'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Do not expand aggregate data types with no children." },
+  { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name",            'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "A name for this summary string." }
+    // clang-format on
+};
+
 class CommandObjectTypeSummaryAdd : public CommandObjectParsed,
                                     public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions(CommandInterpreter &interpreter) : Options() {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_summary_add_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     TypeSummaryImpl::Flags m_flags;
     bool m_regex;
     std::string m_format_string;
     ConstString m_name;
     std::string m_python_script;
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 OptionDefinition g_type_synth_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,     "If true, cascade through typedef chains." },
+  { LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for pointers-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for references-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,        "Add this to the given category instead of the default one." },
+  { LLDB_OPT_SET_2,   false, "python-class",    'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children." },
+  { LLDB_OPT_SET_3,   false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type Python code to generate a class that provides synthetic children." },
+  { LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type names are actually regular expressions." }
+    // clang-format on
+};
+
 class CommandObjectTypeSynthAdd : public CommandObjectParsed,
                                   public IOHandlerDelegateMultiline {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_skip_pointers = false;
       m_skip_references = false;
       m_category = "default";
       is_class_based = false;
       handwrite_python = false;
       m_regex = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_synth_add_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     bool m_cascade;
     bool m_skip_references;
     bool m_skip_pointers;
     std::string m_class_name;
     bool m_input_python;
static bool AddSynth(ConstString type_name, lldb::SyntheticChildrenSP entry,
                        SynthFormatType type, std::string category_name,
                        Error *error);
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectTypeFormatAdd
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_type_format_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Add this to the given category instead of the default one." },
+  { LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains." },
+  { LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for pointers-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for references-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Type names are actually regular expressions." },
+  { LLDB_OPT_SET_2,   false, "type",            't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Format variables as if they were of this type." }
+    // clang-format on
+};
+
 class CommandObjectTypeFormatAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions() : OptionGroup() {}
 
     ~CommandOptions() override = default;
 
-    uint32_t GetNumDefinitions() override;
-
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_format_add_options;
+    }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_cascade = true;
       m_skip_pointers = false;
       m_skip_references = false;
       m_regex = false;
       m_category.assign("default");
       m_custom_type_name.clear();
     }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override {
       Error error;
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option =
+          g_type_format_add_options[option_idx].short_option;
       bool success;
 
       switch (short_option) {
       case 'C':
         m_cascade = Args::StringToBoolean(
             llvm::StringRef::withNullAsEmpty(option_value), true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
Error SetOptionValue(uint32_t option_idx, const char *option_value,
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
 
     bool m_cascade;
     bool m_skip_references;
     bool m_skip_pointers;
     bool m_regex;
     std::string m_category;
     std::string m_custom_type_name;
for (size_t i = 0; i < argc; i++) {
       }
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition CommandObjectTypeFormatAdd::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Add this to the given category instead of the default one."},
-  {LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, cascade through typedef chains."},
-  {LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for pointers-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Don't use this format for references-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,    "Type names are actually regular expressions."},
-  {LLDB_OPT_SET_2,   false, "type",            't', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,    "Format variables as if they were of this type."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+static OptionDefinition g_type_formatter_delete_options[] = {
+  { LLDB_OPT_SET_1, false, "all",      'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Delete from every category." },
+  { LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,     "Delete from given category." },
+  { LLDB_OPT_SET_3, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Delete from given language's category." }
 };
 
-uint32_t CommandObjectTypeFormatAdd::CommandOptions::GetNumDefinitions() {
-  return sizeof(g_option_table) / sizeof(OptionDefinition);
-}
-
 class CommandObjectTypeFormatterDelete : public CommandObjectParsed {
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_delete_all = false;
       m_category = "default";
       m_language = lldb::eLanguageTypeUnknown;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_formatter_delete_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     bool m_delete_all;
     std::string m_category;
     lldb::LanguageType m_language;
   };
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else {
       result.AppendErrorWithFormat("no custom formatter for %s.\n", typeA);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
   }
 };
 
-OptionDefinition
-    CommandObjectTypeFormatterDelete::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "all",      'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Delete from every category."},
-  {LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,     "Delete from given category."},
-  {LLDB_OPT_SET_3, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Delete from given language's category."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+static OptionDefinition g_type_formatter_clear_options[] = {
+  { LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Clear every category." }
 };
 
 class CommandObjectTypeFormatterClear : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_delete_all = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_formatter_clear_options;
+    }
 
     // Instance variables to hold the values for command options.
     bool m_delete_all;
   };
 
   CommandOptions m_options;
   uint32_t m_formatter_kind_mask;
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     FormatterSpecificDeletion();
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition
-    CommandObjectTypeFormatterClear::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Clear every category."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeFormatDelete
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeFormatDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeFormatDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_category_regex.Clear();
       m_category_language.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override {
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       static OptionDefinition g_option_table[] = {
           // clang-format off
-              {LLDB_OPT_SET_1, false, "category-regex", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,     "Only show categories matching this filter."},
-              {LLDB_OPT_SET_2, false, "language",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Only show the category for a specific language."},
-              {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
+            {LLDB_OPT_SET_2, false, "language",       'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Only show the category for a specific language."}
           // clang-format on
       };
-
-      return g_option_table;
+      return llvm::ArrayRef<OptionDefinition>(g_option_table);
     }
 
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
-
     // Instance variables to hold the values for command options.
 
     OptionValueString m_category_regex;
     OptionValueLanguage m_category_language;
   };
 
   CommandOptions m_options;
 
if (type == eRegexSummary) {
     DataVisualization::NamedSummaryFormats::Add(type_name, entry);
     return true;
   } else {
     category->GetTypeSummariesContainer()->Add(type_name, entry);
     return true;
   }
 }
 
-OptionDefinition CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL,                false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one."},
-  {LLDB_OPT_SET_ALL,                false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains."},
-  {LLDB_OPT_SET_ALL,                false, "no-value",        'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't show the value, just show the summary, for this type."},
-  {LLDB_OPT_SET_ALL,                false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects."},
-  {LLDB_OPT_SET_ALL,                false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects."},
-  {LLDB_OPT_SET_ALL,                false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions."},
-  {LLDB_OPT_SET_1,                  true,  "inline-children", 'c', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, inline all child values into summary string."},
-  {LLDB_OPT_SET_1,                  false, "omit-names",      'O', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "If true, omit value names in the summary display."},
-  {LLDB_OPT_SET_2,                  true,  "summary-string",  's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeSummaryString,  "Summary string used to display text and object contents."},
-  {LLDB_OPT_SET_3,                  false, "python-script",   'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonScript,   "Give a one-liner Python script as part of the command."},
-  {LLDB_OPT_SET_3,                  false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type."},
-  {LLDB_OPT_SET_3,                  false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Input Python code to use for this type manually."},
-  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand",          'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Expand aggregate data types to show children on separate lines."},
-  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "hide-empty",      'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Do not expand aggregate data types with no children."},
-  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name",            'n', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "A name for this summary string."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeSummaryDelete
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeSummaryDelete : public CommandObjectTypeFormatterDelete {
 public:
   CommandObjectTypeSummaryDelete(CommandInterpreter &interpreter)
       : CommandObjectTypeFormatterDelete(
bool FormatterSpecificList(CommandReturnObject &result) override {
     return false;
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectTypeCategoryDefine
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_type_category_define_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "enabled",  'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "If specified, this category will be created enabled." },
+  { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Specify the language that this category is supported for." }
+    // clang-format on
+};
+
 class CommandObjectTypeCategoryDefine : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions()
         : Options(), m_define_enabled(false, false),
           m_cate_language(eLanguageTypeUnknown, eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_define_enabled.Clear();
       m_cate_language.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_category_define_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     OptionValueBoolean m_define_enabled;
     OptionValueLanguage m_cate_language;
   };
 
   CommandOptions m_options;
for (size_t i = 0; i < argc; i++) {
       }
     }
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition
-    CommandObjectTypeCategoryDefine::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "enabled",  'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "If specified, this category will be created enabled."},
-  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Specify the language that this category is supported for."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeCategoryEnable
 //-------------------------------------------------------------------------
 
+static OptionDefinition g_type_category_enable_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language." },
+    // clang-format on
+};
+
 class CommandObjectTypeCategoryEnable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_language = lldb::eLanguageTypeUnknown;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_category_enable_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     lldb::LanguageType m_language;
   };
 
   CommandOptions m_options;
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_options.m_language != lldb::eLanguageTypeUnknown)
       DataVisualization::Categories::Enable(m_options.m_language);
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition
-    CommandObjectTypeCategoryEnable::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeCategoryDelete
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeCategoryDelete : public CommandObjectParsed {
 public:
   CommandObjectTypeCategoryDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "type category delete",
bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectTypeCategoryDisable
 //-------------------------------------------------------------------------
 
+OptionDefinition g_type_category_disable_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language." }
+    // clang-format on
+};
+
 class CommandObjectTypeCategoryDisable : public CommandObjectParsed {
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_language = lldb::eLanguageTypeUnknown;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_category_disable_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     lldb::LanguageType m_language;
   };
 
   CommandOptions m_options;
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (m_options.m_language != lldb::eLanguageTypeUnknown)
       DataVisualization::Categories::Disable(m_options.m_language);
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition
-    CommandObjectTypeCategoryDisable::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Enable the category for this language."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectTypeCategoryList
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeCategoryList : public CommandObjectParsed {
 public:
   CommandObjectTypeCategoryList(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "type category list",
if (type == eRegexSynth) {
 
     return true;
   } else {
     category->GetTypeSyntheticsContainer()->Add(type_name, entry);
     return true;
   }
 }
 
-OptionDefinition CommandObjectTypeSynthAdd::CommandOptions::g_option_table[] = {
+#endif // LLDB_DISABLE_PYTHON
+
+static OptionDefinition g_type_filter_add_options[] = {
     // clang-format off
-  {LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,     "If true, cascade through typedef chains."},
-  {LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for pointers-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Don't use this format for references-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,        "Add this to the given category instead of the default one."},
-  {LLDB_OPT_SET_2,   false, "python-class",    'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children."},
-  {LLDB_OPT_SET_3,   false, "input-python",    'P', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type Python code to generate a class that provides synthetic children."},
-  {LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,        "Type names are actually regular expressions."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
+  { LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains." },
+  { LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects." },
+  { LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one." },
+  { LLDB_OPT_SET_ALL, false, "child",           'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpressionPath, "Include this expression path in the synthetic view." },
+  { LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions." }
     // clang-format on
 };
 
-#endif // LLDB_DISABLE_PYTHON
-
 class CommandObjectTypeFilterAdd : public CommandObjectParsed {
 private:
   class CommandOptions : public Options {
     typedef std::vector<std::string> option_vector;
 
   public:
     CommandOptions() : Options() {}
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_skip_pointers = false;
       m_skip_references = false;
       m_category = "default";
       m_expr_paths.clear();
       has_child_list = false;
       m_regex = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_filter_add_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     bool m_cascade;
     bool m_skip_references;
     bool m_skip_pointers;
     bool m_input_python;
     option_vector m_expr_paths;
for (size_t i = 0; i < argc; i++) {
       }
     }
 
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return result.Succeeded();
   }
 };
 
-OptionDefinition CommandObjectTypeFilterAdd::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "cascade",         'C', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,        "If true, cascade through typedef chains."},
-  {LLDB_OPT_SET_ALL, false, "skip-pointers",   'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for pointers-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Don't use this format for references-to-type objects."},
-  {LLDB_OPT_SET_ALL, false, "category",        'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeName,           "Add this to the given category instead of the default one."},
-  {LLDB_OPT_SET_ALL, false, "child",           'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpressionPath, "Include this expression path in the synthetic view."},
-  {LLDB_OPT_SET_ALL, false, "regex",           'x', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,           "Type names are actually regular expressions."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+//----------------------------------------------------------------------
+// "type lookup"
+//----------------------------------------------------------------------
+static OptionDefinition g_type_lookup_options[] = {
+  { LLDB_OPT_SET_ALL, false, "show-help", 'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Display available help for types" },
+  { LLDB_OPT_SET_ALL, false, "language",  'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Which language's types should the search scope be" }
 };
 
-//----------------------------------------------------------------------
-// "type lookup"
-//----------------------------------------------------------------------
 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;
protected:
 
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions()
         : OptionGroup(), m_show_help(false), m_language(eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
 
-    uint32_t GetNumDefinitions() override { return 3; }
-
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_type_lookup_options;
+    }
 
     Error SetOptionValue(uint32_t option_idx, const char *option_value,
                          ExecutionContext *execution_context) override {
       Error error;
 
-      const int short_option = g_option_table[option_idx].short_option;
+      const int short_option = g_type_lookup_options[option_idx].short_option;
 
       switch (short_option) {
       case 'h':
         m_show_help = true;
         break;
 
       case 'l':
         m_language = Language::GetLanguageTypeFromString(option_value);
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_help = false;
       m_language = eLanguageTypeUnknown;
     }
 
     // Options table: Required for subclasses of Options.
 
-    static OptionDefinition g_option_table[];
     bool m_show_help;
     lldb::LanguageType m_language;
   };
 
   OptionGroupOptions m_option_group;
   CommandOptions m_command_options;
 
 public:
if (!any_found)
                                      name_of_type);
 
     result.SetStatus(any_found ? lldb::eReturnStatusSuccessFinishResult
                                : lldb::eReturnStatusSuccessFinishNoResult);
     return true;
   }
 };
 
-OptionDefinition CommandObjectTypeLookup::CommandOptions::g_option_table[] = {
-    // clang-format off
-  {LLDB_OPT_SET_ALL, false, "show-help", 'h', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Display available help for types"},
-  {LLDB_OPT_SET_ALL, false, "language",  'l', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeLanguage, "Which language's types should the search scope be"},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-    // clang-format on
-};
-
 template <typename FormatterType>
 class CommandObjectFormatterInfo : public CommandObjectRaw {
 public:
   typedef std::function<typename FormatterType::SharedPointer(ValueObject &)>
       DiscoveryFunction;
   CommandObjectFormatterInfo(CommandInterpreter &interpreter,
                              const char *formatter_name,
                              DiscoveryFunction discovery_func)

lldb/trunk/source/Commands/CommandObjectWatchpoint.cpp

if (in_range)
     return false;
 
   return true; // Success!
 }
 
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointList
 //-------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------
+// CommandObjectWatchpointList::Options
+//-------------------------------------------------------------------------
+#pragma mark List::CommandOptions
+
+static OptionDefinition g_watchpoint_list_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1, false, "brief",   'b', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a brief description of the watchpoint (no location info)." },
+  { LLDB_OPT_SET_2, false, "full",    'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a full description of the watchpoint and its locations." },
+  { LLDB_OPT_SET_3, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Explain everything we know about the watchpoint (for debugging debugger bugs)." }
+    // clang-format on
+};
+
 #pragma mark List
 
 class CommandObjectWatchpointList : public CommandObjectParsed {
 public:
   CommandObjectWatchpointList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint list",
             "List all watchpoints at configurable levels of detail.", nullptr),
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_level = lldb::eDescriptionLevelFull;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_watchpoint_list_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     lldb::DescriptionLevel m_level;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
 //-------------------------------------------------------------------------
-// CommandObjectWatchpointList::Options
-//-------------------------------------------------------------------------
-#pragma mark List::CommandOptions
-
-OptionDefinition CommandObjectWatchpointList::CommandOptions::g_option_table[] =
-    {
-        // clang-format off
-  {LLDB_OPT_SET_1, false, "brief",   'b', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a brief description of the watchpoint (no location info)."},
-  {LLDB_OPT_SET_2, false, "full",    'f', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Give a full description of the watchpoint and its locations."},
-  {LLDB_OPT_SET_3, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Explain everything we know about the watchpoint (for debugging debugger bugs)."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
-//-------------------------------------------------------------------------
 // CommandObjectWatchpointEnable
 //-------------------------------------------------------------------------
 #pragma mark Enable
 
 class CommandObjectWatchpointEnable : public CommandObjectParsed {
 public:
   CommandObjectWatchpointEnable(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "enable",
bool DoExecute(Args &command, CommandReturnObject &result) override {
     return result.Succeeded();
   }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointIgnore
 //-------------------------------------------------------------------------
 
+#pragma mark Ignore::CommandOptions
+static OptionDefinition g_watchpoint_ignore_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_ALL, true, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount, "Set the number of times this watchpoint is skipped before stopping." }
+    // clang-format on
+};
+
 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),
         m_options() {
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_ignore_count = 0;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_watchpoint_ignore_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     uint32_t m_ignore_count;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Ignore::CommandOptions
+//-------------------------------------------------------------------------
+// CommandObjectWatchpointModify
+//-------------------------------------------------------------------------
+
+#pragma mark Modify::CommandOptions
 
-OptionDefinition
-    CommandObjectWatchpointIgnore::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, true, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount, "Set the number of times this watchpoint is skipped before stopping."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
+static OptionDefinition g_watchpoint_modify_options[] = {
+  { LLDB_OPT_SET_ALL, false, "condition", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpression, "The watchpoint stops only if this condition expression evaluates to true." }
 };
 
-//-------------------------------------------------------------------------
-// CommandObjectWatchpointModify
-//-------------------------------------------------------------------------
 #pragma mark Modify
 
 class CommandObjectWatchpointModify : public CommandObjectParsed {
 public:
   CommandObjectWatchpointModify(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "watchpoint modify",
             "Modify the options on a watchpoint or set of watchpoints in the "
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_condition.clear();
       m_condition_passed = false;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_watchpoint_modify_options;
+    }
 
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     bool m_condition_passed;
   };
 
 protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-#pragma mark Modify::CommandOptions
-
-OptionDefinition
-    CommandObjectWatchpointModify::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_ALL, false, "condition", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeExpression, "The watchpoint stops only if this condition expression evaluates to true."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointSetVariable
 //-------------------------------------------------------------------------
 #pragma mark SetVariable
 
 class CommandObjectWatchpointSetVariable : public CommandObjectParsed {
 public:
   CommandObjectWatchpointSetVariable(CommandInterpreter &interpreter)

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointCommandAdd
 //-------------------------------------------------------------------------
 
+// FIXME: "script-type" needs to have its contents determined dynamically, so
+// somebody can add a new scripting
+// language to lldb and have it pickable here without having to change this
+// enumeration by hand and rebuild lldb proper.
+
+static OptionEnumValueElement g_script_option_enumeration[4] = {
+    {eScriptLanguageNone, "command",
+     "Commands are in the lldb command interpreter language"},
+    {eScriptLanguagePython, "python", "Commands are in the Python language."},
+    {eSortOrderByName, "default-script",
+     "Commands are in the default scripting language."},
+    {0, nullptr, nullptr}};
+
+static OptionDefinition g_watchpoint_command_add_options[] = {
+    // clang-format off
+  { LLDB_OPT_SET_1,   false, "one-liner",       'o', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeOneLiner,       "Specify a one-line watchpoint command inline. Be sure to surround it with quotes." },
+  { LLDB_OPT_SET_ALL, false, "stop-on-error",   'e', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeBoolean,        "Specify whether watchpoint command execution should terminate on error." },
+  { LLDB_OPT_SET_ALL, false, "script-type",     's', OptionParser::eRequiredArgument, nullptr, g_script_option_enumeration, 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used." },
+  { LLDB_OPT_SET_2,   false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this watchpoint. Be sure to give a module name if appropriate." }
+    // clang-format on
+};
+
 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.",
                             nullptr),
Error SetOptionValue(uint32_t option_idx, const char *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)Args::StringToOptionEnum(
-            option_arg, g_option_table[option_idx].enum_values,
+            option_arg, GetDefinitions()[option_idx].enum_values,
             eScriptLanguageNone, error);
 
         m_use_script_language = (m_script_language == eScriptLanguagePython ||
                                  m_script_language == eScriptLanguageDefault);
         break;
 
       case 'e': {
         bool success = false;
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_script_language = eScriptLanguageNone;
 
       m_use_one_liner = false;
       m_stop_on_error = true;
       m_one_liner.clear();
       m_function_name.clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
-
-    // Options table: Required for subclasses of Options.
-
-    static OptionDefinition g_option_table[];
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_watchpoint_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;
 
     // Instance variables to hold the values for one_liner options.
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };
 
-// FIXME: "script-type" needs to have its contents determined dynamically, so
-// somebody can add a new scripting
-// language to lldb and have it pickable here without having to change this
-// enumeration by hand and rebuild lldb proper.
-
-static OptionEnumValueElement g_script_option_enumeration[4] = {
-    {eScriptLanguageNone, "command",
-     "Commands are in the lldb command interpreter language"},
-    {eScriptLanguagePython, "python", "Commands are in the Python language."},
-    {eSortOrderByName, "default-script",
-     "Commands are in the default scripting language."},
-    {0, nullptr, nullptr}};
-
-OptionDefinition
-    CommandObjectWatchpointCommandAdd::CommandOptions::g_option_table[] = {
-        // clang-format off
-  {LLDB_OPT_SET_1,   false, "one-liner",       'o', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeOneLiner,       "Specify a one-line watchpoint command inline. Be sure to surround it with quotes."},
-  {LLDB_OPT_SET_ALL, false, "stop-on-error",   'e', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypeBoolean,        "Specify whether watchpoint command execution should terminate on error."},
-  {LLDB_OPT_SET_ALL, false, "script-type",     's', OptionParser::eRequiredArgument, nullptr, g_script_option_enumeration, 0, eArgTypeNone,           "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
-  {LLDB_OPT_SET_2,   false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, nullptr,                     0, eArgTypePythonFunction, "Give the name of a Python function to run as command for this watchpoint. Be sure to give a module name if appropriate."},
-  {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
-        // clang-format on
-};
-
 //-------------------------------------------------------------------------
 // CommandObjectWatchpointCommandDelete
 //-------------------------------------------------------------------------
 
 class CommandObjectWatchpointCommandDelete : public CommandObjectParsed {
 public:
   CommandObjectWatchpointCommandDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "delete",

lldb/trunk/source/Interpreter/Args.cpp

for (int i = 0; long_options[i].definition != nullptr; ++i) {
     }
   }
 
   std::unique_lock<std::mutex> lock;
   OptionParser::Prepare(lock);
   OptionParser::EnableError(false);
 
   int val;
-  const OptionDefinition *opt_defs = options.GetDefinitions();
+  auto opt_defs = options.GetDefinitions();
 
   // Fooey... OptionParser::Parse permutes the GetArgumentVector to move the
   // options to the front.
   // So we have to build another Arg and pass that to OptionParser::Parse so it
   // doesn't
   // change the one we have.
 
   std::vector<const char *> dummy_vec(
if (long_options_index == -1) {
           break;
         }
       }
     }
 
     // See if the option takes an argument, and see if one was supplied.
     if (long_options_index >= 0) {
       int opt_defs_index = -1;
-      for (int i = 0;; i++) {
-        if (opt_defs[i].short_option == 0)
-          break;
-        else if (opt_defs[i].short_option == val) {
-          opt_defs_index = i;
-          break;
-        }
-      }
+      for (size_t i = 0; i < opt_defs.size(); i++) {
+        if (opt_defs[i].short_option != val)
+          continue;
 
       const OptionDefinition *def = long_options[long_options_index].definition;
       int has_arg =
           (def == nullptr) ? OptionParser::eNoArgument : def->option_has_arg;
       switch (has_arg) {
       case OptionParser::eNoArgument:
         option_element_vector.push_back(OptionArgElement(
             opt_defs_index, OptionParser::GetOptionIndex() - 1, 0));

lldb/trunk/source/Interpreter/OptionGroupArchitecture.cpp

 OptionGroupArchitecture::~OptionGroupArchitecture() {}
 
 static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "arch", 'a', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeArchitecture,
      "Specify the architecture for the target."},
 };
 
-uint32_t OptionGroupArchitecture::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
-
-const OptionDefinition *OptionGroupArchitecture::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupArchitecture::GetDefinitions() {
   return g_option_table;
 }
 
 bool OptionGroupArchitecture::GetArchitecture(Platform *platform,
                                               ArchSpec &arch) {
   if (m_arch_str.empty())
     arch.Clear();
   else

lldb/trunk/source/Interpreter/OptionGroupFormat.cpp

static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_3, false, "size", 's', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeByteSize,
      "The size in bytes to use when displaying with the selected format."},
     {LLDB_OPT_SET_4, false, "count", 'c', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeCount,
      "The number of total items to display."},
 };
 
-uint32_t OptionGroupFormat::GetNumDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupFormat::GetDefinitions() {
+  llvm::ArrayRef<OptionDefinition> result = g_option_table;
   if (m_byte_size.GetDefaultValue() < UINT64_MAX) {
     if (m_count.GetDefaultValue() < UINT64_MAX)
-      return 4;
+      return result;
     else
-      return 3;
+      return result.take_front(3);
   }
-  return 2;
-}
-
-const OptionDefinition *OptionGroupFormat::GetDefinitions() {
-  return g_option_table;
+  return result.take_front(2);
 }
 
 Error OptionGroupFormat::SetOptionValue(uint32_t option_idx,
                                         const char *option_arg,
                                         ExecutionContext *execution_context) {
   Error error;
   const int short_option = g_option_table[option_idx].short_option;
 

lldb/trunk/source/Interpreter/OptionGroupOutputFile.cpp

static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "outfile", 'o', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeFilename,
      "Specify a path for capturing command output."},
     {LLDB_OPT_SET_1, false, "append-outfile", SHORT_OPTION_APND,
      OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
      "Append to the file specified with '--outfile <path>'."},
 };
 
-uint32_t OptionGroupOutputFile::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
-
-const OptionDefinition *OptionGroupOutputFile::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() {
   return g_option_table;
 }
 
 Error OptionGroupOutputFile::SetOptionValue(
     uint32_t option_idx, const char *option_arg,
     ExecutionContext *execution_context) {
   Error error;
   const int short_option = g_option_table[option_idx].short_option;

lldb/trunk/source/Interpreter/OptionGroupPlatform.cpp

static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "build", 'b', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeNone,
      "Specify the initial SDK build number."},
     {LLDB_OPT_SET_ALL, false, "sysroot", 'S', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeFilename, "Specify the SDK root directory "
                                             "that contains a root of all "
                                             "remote system files."}};
 
-const OptionDefinition *OptionGroupPlatform::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupPlatform::GetDefinitions() {
+  llvm::ArrayRef<OptionDefinition> result(g_option_table);
   if (m_include_platform_option)
-    return g_option_table;
-  return g_option_table + 1;
-}
-
-uint32_t OptionGroupPlatform::GetNumDefinitions() {
-  if (m_include_platform_option)
-    return llvm::array_lengthof(g_option_table);
-  return llvm::array_lengthof(g_option_table) - 1;
+    return result;
+  return result.drop_front();
 }
 
 Error OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
                                           const char *option_arg,
                                           ExecutionContext *execution_context) {
   Error error;
   if (!m_include_platform_option)
     ++option_idx;

lldb/trunk/source/Interpreter/OptionGroupUUID.cpp

 
 OptionGroupUUID::~OptionGroupUUID() {}
 
 static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "uuid", 'u', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeNone, "A module UUID value."},
 };
 
-uint32_t OptionGroupUUID::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
-
-const OptionDefinition *OptionGroupUUID::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() {
   return g_option_table;
 }
 
 Error OptionGroupUUID::SetOptionValue(uint32_t option_idx,
                                       const char *option_arg,
                                       ExecutionContext *execution_context) {
   Error error;
   const int short_option = g_option_table[option_idx].short_option;

lldb/trunk/source/Interpreter/OptionGroupValueObjectDisplay.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 
+#include "llvm/ADT/ArrayRef.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupValueObjectDisplay::OptionGroupValueObjectDisplay() {}
 
 OptionGroupValueObjectDisplay::~OptionGroupValueObjectDisplay() {}
 
 static OptionDefinition g_option_table[] = {
static OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "show-all-children", 'A', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
      "Ignore the upper bound on the number of children to show."},
     {LLDB_OPT_SET_1, false, "validate", 'V', OptionParser::eRequiredArgument,
      nullptr, nullptr, 0, eArgTypeBoolean, "Show results of type validators."},
     {LLDB_OPT_SET_1, false, "element-count", 'Z',
      OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeCount,
      "Treat the result of the expression as if its type is an array of this "
-     "many values."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
-uint32_t OptionGroupValueObjectDisplay::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}
+     "many values."}};
 
-const OptionDefinition *OptionGroupValueObjectDisplay::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition>
+OptionGroupValueObjectDisplay::GetDefinitions() {
   return g_option_table;
 }
 
 Error OptionGroupValueObjectDisplay::SetOptionValue(
     uint32_t option_idx, const char *option_arg,
     ExecutionContext *execution_context) {
   Error error;
   const int short_option = g_option_table[option_idx].short_option;

lldb/trunk/source/Interpreter/OptionGroupVariable.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // if you add any options here, remember to update the counters in
 // OptionGroupVariable::GetNumDefinitions()
-static OptionDefinition g_option_table[] = {
+static OptionDefinition g_variable_options[] = {
     {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "no-args", 'a',
      OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
      "Omit function arguments."},
     {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "no-locals", 'l',
      OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
      "Omit local variables."},
     {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "show-globals", 'g',
      OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,

 OptionGroupVariable::~OptionGroupVariable() {}
 
 Error OptionGroupVariable::SetOptionValue(uint32_t option_idx,
                                           const char *option_arg,
                                           ExecutionContext *execution_context) {
   Error error;
   if (!include_frame_options)
     option_idx += 3;
-  const int short_option = g_option_table[option_idx].short_option;
+  const int short_option = g_variable_options[option_idx].short_option;
   switch (short_option) {
   case 'r':
     use_regex = true;
     break;
   case 'a':
     show_args = false;
     break;
   case 'l':
void OptionGroupVariable::OptionParsingStarting(
   use_regex = false;
   show_scope = false;
   summary.Clear();
   summary_string.Clear();
 }
 
 #define NUM_FRAME_OPTS 3
 
-const OptionDefinition *OptionGroupVariable::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupVariable::GetDefinitions() {
+  llvm::ArrayRef<OptionDefinition> result = g_variable_options;
   // Show the "--no-args", "--no-locals" and "--show-globals"
   // options if we are showing frame specific options
   if (include_frame_options)
-    return g_option_table;
+    return result;
 
   // Skip the "--no-args", "--no-locals" and "--show-globals"
   // options if we are not showing frame specific options (globals only)
-  return &g_option_table[NUM_FRAME_OPTS];
-}
-
-uint32_t OptionGroupVariable::GetNumDefinitions() {
-  // Count the "--no-args", "--no-locals" and "--show-globals"
-  // options if we are showing frame specific options.
-  if (include_frame_options)
-    return llvm::array_lengthof(g_option_table);
-  else
-    return llvm::array_lengthof(g_option_table) - NUM_FRAME_OPTS;
+  return result.drop_front(NUM_FRAME_OPTS);
 }

lldb/trunk/source/Interpreter/OptionGroupWatchpoint.cpp

 
 void OptionGroupWatchpoint::OptionParsingStarting(
     ExecutionContext *execution_context) {
   watch_type_specified = false;
   watch_type = eWatchInvalid;
   watch_size = 0;
 }
 
-const OptionDefinition *OptionGroupWatchpoint::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() {
   return g_option_table;
 }
-
-uint32_t OptionGroupWatchpoint::GetNumDefinitions() {
-  return llvm::array_lengthof(g_option_table);
-}

lldb/trunk/source/Interpreter/Options.cpp

void Options::BuildValidOptionSets() {
   if (m_required_options.size() != 0)
     return;
 
   // Check to see if there are any options.
   int num_options = NumCommandOptions();
   if (num_options == 0)
     return;
 
-  const OptionDefinition *opt_defs = GetDefinitions();
+  auto opt_defs = GetDefinitions();
   m_required_options.resize(1);
   m_optional_options.resize(1);
 
   // First count the number of option sets we've got.  Ignore
   // LLDB_ALL_OPTION_SETS...
 
   uint32_t num_option_sets = 0;
 
-  for (int i = 0; i < num_options; i++) {
-    uint32_t this_usage_mask = opt_defs[i].usage_mask;
+  for (const auto &def : opt_defs) {
+    uint32_t this_usage_mask = def.usage_mask;
     if (this_usage_mask == LLDB_OPT_SET_ALL) {
       if (num_option_sets == 0)
         num_option_sets = 1;
     } else {
       for (uint32_t j = 0; j < LLDB_MAX_NUM_OPTION_SETS; j++) {
         if (this_usage_mask & (1 << j)) {
           if (num_option_sets <= j)
             num_option_sets = j + 1;
         }
       }
     }
   }
 
   if (num_option_sets > 0) {
     m_required_options.resize(num_option_sets);
     m_optional_options.resize(num_option_sets);
 
-    for (int i = 0; i < num_options; ++i) {
+    for (const auto &def : opt_defs) {
       for (uint32_t j = 0; j < num_option_sets; j++) {
-        if (opt_defs[i].usage_mask & 1 << j) {
-          if (opt_defs[i].required)
-            m_required_options[j].insert(opt_defs[i].short_option);
+        if (def.usage_mask & 1 << j) {
+          if (def.required)
+            m_required_options[j].insert(def.short_option);
           else
-            m_optional_options[j].insert(opt_defs[i].short_option);
+            m_optional_options[j].insert(def.short_option);
         }
       }
     }
   }
 }
 
-uint32_t Options::NumCommandOptions() {
-  const OptionDefinition *opt_defs = GetDefinitions();
-  if (opt_defs == nullptr)
-    return 0;
-
-  int i = 0;
-
-  if (opt_defs != nullptr) {
-    while (opt_defs[i].long_option != nullptr)
-      ++i;
-  }
-
-  return i;
-}
+uint32_t Options::NumCommandOptions() { return GetDefinitions().size(); }
 
 Option *Options::GetLongOptions() {
   // Check to see if this has already been done.
   if (m_getopt_table.empty()) {
-    // Check to see if there are any options.
-    const uint32_t num_options = NumCommandOptions();
-    if (num_options == 0)
+    auto defs = GetDefinitions();
+    if (defs.empty())
       return nullptr;
 
-    uint32_t i;
-    const OptionDefinition *opt_defs = GetDefinitions();
-
     std::map<int, uint32_t> option_seen;
 
-    m_getopt_table.resize(num_options + 1);
-    for (i = 0; i < num_options; ++i) {
-      const int short_opt = opt_defs[i].short_option;
+    m_getopt_table.resize(defs.size() + 1);
+    for (size_t i = 0; i < defs.size(); ++i) {
+      const int short_opt = defs[i].short_option;
 
-      m_getopt_table[i].definition = &opt_defs[i];
+      m_getopt_table[i].definition = &defs[i];
       m_getopt_table[i].flag = nullptr;
       m_getopt_table[i].val = short_opt;
 
       if (option_seen.find(short_opt) == option_seen.end()) {
         option_seen[short_opt] = i;
       } else if (short_opt) {
         m_getopt_table[i].val = 0;
         std::map<int, uint32_t>::const_iterator pos =
             option_seen.find(short_opt);
         StreamString strm;
         if (isprint8(short_opt))
           Host::SystemLog(Host::eSystemLogError,
                           "option[%u] --%s has a short option -%c that "
                           "conflicts with option[%u] --%s, short option won't "
                           "be used for --%s\n",
-                          i, opt_defs[i].long_option, short_opt, pos->second,
+                          (int)i, defs[i].long_option, short_opt, pos->second,
                           m_getopt_table[pos->second].definition->long_option,
-                          opt_defs[i].long_option);
+                          defs[i].long_option);
         else
           Host::SystemLog(Host::eSystemLogError,
                           "option[%u] --%s has a short option 0x%x that "
                           "conflicts with option[%u] --%s, short option won't "
                           "be used for --%s\n",
-                          i, opt_defs[i].long_option, short_opt, pos->second,
+                          (int)i, defs[i].long_option, short_opt, pos->second,
                           m_getopt_table[pos->second].definition->long_option,
-                          opt_defs[i].long_option);
+                          defs[i].long_option);
       }
     }
 
     // getopt_long_only requires a NULL final entry in the table:
 
-    m_getopt_table[i].definition = nullptr;
-    m_getopt_table[i].flag = nullptr;
-    m_getopt_table[i].val = 0;
+    m_getopt_table.back().definition = nullptr;
+    m_getopt_table.back().flag = nullptr;
+    m_getopt_table.back().val = 0;
   }
 
   if (m_getopt_table.empty())
     return nullptr;
 
   return &m_getopt_table.front();
 }
 
while (end < final_end) {
       strm.Write(actual_text.c_str() + start, sub_len);
       start = end + 1;
     }
     strm.EOL();
   }
 }
 
 bool Options::SupportsLongOption(const char *long_option) {
-  if (long_option && long_option[0]) {
-    const OptionDefinition *opt_defs = GetDefinitions();
-    if (opt_defs) {
-      const char *long_option_name = long_option;
-      if (long_option[0] == '-' && long_option[1] == '-')
-        long_option_name += 2;
+  if (!long_option || !long_option[0])
+    return false;
+
+  auto opt_defs = GetDefinitions();
+  if (opt_defs.empty())
+    return false;
+
 
-      for (uint32_t i = 0; opt_defs[i].long_option; ++i) {
-        if (strcmp(opt_defs[i].long_option, long_option_name) == 0)
-          return true;
-      }
-    }
-  }
+  for (auto &def : opt_defs) {
+    if (!def.long_option)
+      continue;
+
+    if (strcmp(def.long_option, long_option_name) == 0)
+
   return false;
 }
 
 enum OptionDisplayType {
   eDisplayBestOption,
   eDisplayShortOption,
   eDisplayLongOption
 };
if (footer && footer[0])
     strm.PutCString(footer);
   return true;
 }
 
 void Options::GenerateOptionUsage(Stream &strm, CommandObject *cmd,
                                   uint32_t screen_width) {
   const bool only_print_args = cmd->IsDashDashCommand();
 
-  const OptionDefinition *opt_defs = GetDefinitions();
+  auto opt_defs = GetDefinitions();
   const uint32_t save_indent_level = strm.GetIndentLevel();
   const char *name;
 
   StreamString arguments_str;
 
   if (cmd) {
     name = cmd->GetCommandName();
     cmd->GetFormattedCommandArguments(arguments_str);
for (uint32_t opt_set = 0; opt_set < num_option_sets; ++opt_set) {
         cmd->GetFormattedCommandArguments(args_str, opt_set_mask);
 
       // First go through and print all options that take no arguments as
       // a single string. If a command has "-a" "-b" and "-c", this will show
       // up as [-abc]
 
       std::set<int> options;
       std::set<int>::const_iterator options_pos, options_end;
-      for (i = 0; i < num_options; ++i) {
-        if (opt_defs[i].usage_mask & opt_set_mask &&
-            isprint8(opt_defs[i].short_option)) {
+      for (auto &def : opt_defs) {
+        if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
           // Add current option to the end of out_stream.
 
-          if (opt_defs[i].required == true &&
-              opt_defs[i].option_has_arg == OptionParser::eNoArgument) {
-            options.insert(opt_defs[i].short_option);
+          if (def.required && def.option_has_arg == OptionParser::eNoArgument) {
+            options.insert(def.short_option);
           }
         }
       }
 
       if (options.empty() == false) {
         // We have some required options with no arguments
         strm.PutCString(" -");
         for (i = 0; i < 2; ++i)
           for (options_pos = options.begin(), options_end = options.end();
                options_pos != options_end; ++options_pos) {
             if (i == 0 && ::islower(*options_pos))
               continue;
             if (i == 1 && ::isupper(*options_pos))
               continue;
             strm << (char)*options_pos;
           }
       }
 
-      for (i = 0, options.clear(); i < num_options; ++i) {
-        if (opt_defs[i].usage_mask & opt_set_mask &&
-            isprint8(opt_defs[i].short_option)) {
+      options.clear();
+      for (auto &def : opt_defs) {
+        if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
           // Add current option to the end of out_stream.
 
-          if (opt_defs[i].required == false &&
-              opt_defs[i].option_has_arg == OptionParser::eNoArgument) {
-            options.insert(opt_defs[i].short_option);
+          if (def.required == false &&
+              def.option_has_arg == OptionParser::eNoArgument) {
+            options.insert(def.short_option);
           }
         }
       }
 
       if (options.empty() == false) {
         // We have some required options with no arguments
         strm.PutCString(" [-");
         for (i = 0; i < 2; ++i)
           for (options_pos = options.begin(), options_end = options.end();
                options_pos != options_end; ++options_pos) {
             if (i == 0 && ::islower(*options_pos))
               continue;
             if (i == 1 && ::isupper(*options_pos))
               continue;
             strm << (char)*options_pos;
           }
         strm.PutChar(']');
       }
 
       // First go through and print the required options (list them up front).
 
-      for (i = 0; i < num_options; ++i) {
-        if (opt_defs[i].usage_mask & opt_set_mask &&
-            isprint8(opt_defs[i].short_option)) {
-          if (opt_defs[i].required &&
-              opt_defs[i].option_has_arg != OptionParser::eNoArgument)
-            PrintOption(opt_defs[i], eDisplayBestOption, " ", nullptr, true,
-                        strm);
+      for (auto &def : opt_defs) {
+        if (def.usage_mask & opt_set_mask && isprint8(def.short_option)) {
+          if (def.required && def.option_has_arg != OptionParser::eNoArgument)
+            PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
         }
       }
 
       // Now go through again, and this time only print the optional options.
 
-      for (i = 0; i < num_options; ++i) {
-        if (opt_defs[i].usage_mask & opt_set_mask) {
+      for (auto &def : opt_defs) {
+        if (def.usage_mask & opt_set_mask) {
           // Add current option to the end of out_stream.
 
-          if (!opt_defs[i].required &&
-              opt_defs[i].option_has_arg != OptionParser::eNoArgument)
-            PrintOption(opt_defs[i], eDisplayBestOption, " ", nullptr, true,
-                        strm);
+          if (!def.required && def.option_has_arg != OptionParser::eNoArgument)
+            PrintOption(def, eDisplayBestOption, " ", nullptr, true, strm);
         }
       }
 
       if (args_str.GetSize() > 0) {
         if (cmd->WantsRawCommandString() && !only_print_args)
           strm.Printf(" --");
 
         strm.Printf(" %s", args_str.GetData());
if (!only_print_args) {
 
     std::multimap<int, uint32_t> options_seen;
     strm.IndentMore(5);
 
     // Put the unique command options in a vector & sort it, so we can output
     // them alphabetically (by short_option)
     // when writing out detailed help for each option.
 
-    for (i = 0; i < num_options; ++i)
-      options_seen.insert(std::make_pair(opt_defs[i].short_option, i));
+    i = 0;
+    for (auto &def : opt_defs)
+      options_seen.insert(std::make_pair(def.short_option, i++));
 
     // Go through the unique'd and alphabetically sorted vector of options, find
     // the table entry for each option
     // and write out the detailed help information for that option.
 
     bool first_option_printed = false;
-    ;
 
     for (auto pos : options_seen) {
       i = pos.second;
       // Print out the help information for this option.
 
       // Put a newline separation between arguments
       if (first_option_printed)
         strm.EOL();
bool Options::HandleOptionCompletion(
     CommandInterpreter &interpreter, bool &word_complete,
     lldb_private::StringList &matches) {
   word_complete = true;
 
   // For now we just scan the completions to see if the cursor position is in
   // an option or its argument.  Otherwise we'll call HandleArgumentCompletion.
   // In the future we can use completion to validate options as well if we want.
 
-  const OptionDefinition *opt_defs = GetDefinitions();
+  auto opt_defs = GetDefinitions();
 
   std::string cur_opt_std_str(input.GetArgumentAtIndex(cursor_index));
   cur_opt_std_str.erase(char_pos);
   const char *cur_opt_str = cur_opt_std_str.c_str();
 
   for (size_t i = 0; i < opt_element_vector.size(); i++) {
     int opt_pos = opt_element_vector[i].opt_pos;
     int opt_arg_pos = opt_element_vector[i].opt_arg_pos;
     int opt_defs_index = opt_element_vector[i].opt_defs_index;
     if (opt_pos == cursor_index) {
       // We're completing the option itself.
 
       if (opt_defs_index == OptionArgElement::eBareDash) {
         // We're completing a bare dash.  That means all options are open.
         // FIXME: We should scan the other options provided and only complete
         // options
         // within the option group they belong to.
         char opt_str[3] = {'-', 'a', '\0'};
 
-        for (int j = 0; opt_defs[j].short_option != 0; j++) {
-          opt_str[1] = opt_defs[j].short_option;
+        for (auto &def : opt_defs) {
+          if (!def.short_option)
+            continue;
+          opt_str[1] = def.short_option;
           matches.AppendString(opt_str);
         }
+
         return true;
       } else if (opt_defs_index == OptionArgElement::eBareDoubleDash) {
         std::string full_name("--");
-        for (int j = 0; opt_defs[j].short_option != 0; j++) {
+        for (auto &def : opt_defs) {
+          if (!def.short_option)
+            continue;
+
           full_name.erase(full_name.begin() + 2, full_name.end());
-          full_name.append(opt_defs[j].long_option);
+          full_name.append(def.long_option);
           matches.AppendString(full_name.c_str());
         }
         return true;
       } else if (opt_defs_index != OptionArgElement::eUnrecognizedArg) {
         // We recognized it, if it an incomplete long option, complete it anyway
         // (getopt_long_only is
         // happy with shortest unique string, but it's still a nice thing to
         // do.)  Otherwise return
if (opt_pos == cursor_index) {
         // I think we will only get in here if the long option table has two
         // elements
         // that are not unique up to this point.  getopt_long_only does shortest
         // unique match
         // for long options already.
 
         if (cur_opt_str && strlen(cur_opt_str) > 2 && cur_opt_str[0] == '-' &&
             cur_opt_str[1] == '-') {
-          for (int j = 0; opt_defs[j].short_option != 0; j++) {
-            if (strstr(opt_defs[j].long_option, cur_opt_str + 2) ==
-                opt_defs[j].long_option) {
+          for (auto &def : opt_defs) {
+            if (!def.long_option)
+              continue;
+
+            if (strstr(def.long_option, cur_opt_str + 2) == def.long_option) {
               std::string full_name("--");
-              full_name.append(opt_defs[j].long_option);
+              full_name.append(def.long_option);
               // The options definitions table has duplicates because of the
               // way the grouping information is stored, so only add once.
               bool duplicate = false;
               for (size_t k = 0; k < matches.GetSize(); k++) {
                 if (matches.GetStringAtIndex(k) == full_name) {
                   duplicate = true;
                   break;
                 }

 }
 
 bool Options::HandleOptionArgumentCompletion(
     Args &input, int cursor_index, int char_pos,
     OptionElementVector &opt_element_vector, int opt_element_index,
     int match_start_point, int max_return_elements,
     CommandInterpreter &interpreter, bool &word_complete,
     lldb_private::StringList &matches) {
-  const OptionDefinition *opt_defs = GetDefinitions();
+  auto opt_defs = GetDefinitions();
   std::unique_ptr<SearchFilter> filter_ap;
 
   int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
   int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
   // See if this is an enumeration type option, and if so complete it here:
 
   OptionEnumValueElement *enum_values = opt_defs[opt_defs_index].enum_values;
bool Options::HandleOptionArgumentCompletion(
 
   return CommandCompletions::InvokeCommonCompletionCallbacks(
       interpreter, completion_mask, input.GetArgumentAtIndex(opt_arg_pos),
       match_start_point, max_return_elements, filter_ap.get(), word_complete,
       matches);
 }
 
 void OptionGroupOptions::Append(OptionGroup *group) {
-  const OptionDefinition *group_option_defs = group->GetDefinitions();
-  const uint32_t group_option_count = group->GetNumDefinitions();
-  for (uint32_t i = 0; i < group_option_count; ++i) {
+  auto group_option_defs = group->GetDefinitions();
+  for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
     m_option_infos.push_back(OptionInfo(group, i));
     m_option_defs.push_back(group_option_defs[i]);
   }
 }
 
 const OptionGroup *OptionGroupOptions::GetGroupWithOption(char short_opt) {
   for (uint32_t i = 0; i < m_option_defs.size(); i++) {
     OptionDefinition opt_def = m_option_defs[i];
     if (opt_def.short_option == short_opt)
       return m_option_infos[i].option_group;
   }
   return nullptr;
 }
 
 void OptionGroupOptions::Append(OptionGroup *group, uint32_t src_mask,
                                 uint32_t dst_mask) {
-  const OptionDefinition *group_option_defs = group->GetDefinitions();
-  const uint32_t group_option_count = group->GetNumDefinitions();
-  for (uint32_t i = 0; i < group_option_count; ++i) {
+  auto group_option_defs = group->GetDefinitions();
+  for (uint32_t i = 0; i < group_option_defs.size(); ++i) {
     if (group_option_defs[i].usage_mask & src_mask) {
       m_option_infos.push_back(OptionInfo(group, i));
       m_option_defs.push_back(group_option_defs[i]);
       m_option_defs.back().usage_mask = dst_mask;
     }
   }
 }
 
 void OptionGroupOptions::Finalize() {
   m_did_finalize = true;
-  OptionDefinition empty_option_def = {
-      0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr};
-  m_option_defs.push_back(empty_option_def);
 }
 
 Error OptionGroupOptions::SetOptionValue(uint32_t option_idx,
                                          const char *option_value,
                                          ExecutionContext *execution_context) {
   // After calling OptionGroupOptions::Append(...), you must finalize the groups
   // by calling OptionGroupOptions::Finlize()
   assert(m_did_finalize);
-  assert(m_option_infos.size() + 1 == m_option_defs.size());
   Error error;
   if (option_idx < m_option_infos.size()) {
     error = m_option_infos[option_idx].option_group->SetOptionValue(
         m_option_infos[option_idx].option_index, option_value,
         execution_context);
 
   } else {
     error.SetErrorString("invalid option index"); // Shouldn't happen...

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
         ObjCRuntimeVersions::eAppleObjC_V2)
       return new AppleObjCRuntimeV2(process, objc_module_sp);
     else
       return NULL;
   } else
     return NULL;
 }
 
+static OptionDefinition g_objc_classtable_dump_options[] = {
+    {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Print ivar and method information in detail"}};
+
 class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_verbose(false, false) {}
 
     ~CommandOptions() override = default;
 
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_verbose.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_objc_classtable_dump_options;
+    }
 
     OptionValueBoolean m_verbose;
-    static OptionDefinition g_option_table[];
   };
 
   CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "dump", "Dump information on Objective-C classes "
                                  "known to the current process.",
             "language objc class-table dump",
             eCommandRequiresProcess | eCommandProcessMustBeLaunched |
if (objc_runtime) {
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
   }
 
   CommandOptions m_options;
 };
 
-OptionDefinition
-    CommandObjectObjC_ClassTable_Dump::CommandOptions::g_option_table[] = {
-        {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument,
-         nullptr, nullptr, 0, eArgTypeNone,
-         "Print ivar and method information in detail"},
-        {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
 class CommandObjectMultiwordObjC_TaggedPointer_Info
     : public CommandObjectParsed {
 public:
   CommandObjectMultiwordObjC_TaggedPointer_Info(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "info", "Dump information on a tagged pointer.",
             "language objc tagged-pointer info",
             eCommandRequiresProcess | eCommandProcessMustBeLaunched |

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

RenderScriptRuntime *runtime =
         (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript);
     runtime->DumpKernels(result.GetOutputStream());
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
+static OptionDefinition g_renderscript_kernel_bp_set_options[] = {
+    {LLDB_OPT_SET_1, false, "coordinate", 'c', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgTypeValue,
+     "Set a breakpoint on a single invocation of the kernel with specified "
+     "coordinate.\n"
+     "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
+     "integers representing kernel dimensions. "
+     "Any unset dimensions will be defaulted to zero."}};
+
 class CommandObjectRenderScriptRuntimeKernelBreakpointSet
     : public CommandObjectParsed {
 public:
   CommandObjectRenderScriptRuntimeKernelBreakpointSet(
       CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "renderscript kernel breakpoint set",
             "Sets a breakpoint on a renderscript kernel.",
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       // -1 means the -c option hasn't been set
       m_coord[0] = -1;
       m_coord[1] = -1;
       m_coord[2] = -1;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_renderscript_kernel_bp_set_options;
+    }
 
-    static OptionDefinition g_option_table[];
     std::array<int, 3> m_coord;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat(
           "'%s' takes 1 argument of kernel name, and an optional coordinate.",
bool DoExecute(Args &command, CommandReturnObject &result) override {
     result.AppendErrorWithFormat("Error: %s", error.AsCString());
     return false;
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectRenderScriptRuntimeKernelBreakpointSet::
-    CommandOptions::g_option_table[] = {
-        {LLDB_OPT_SET_1, false, "coordinate", 'c',
-         OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeValue,
-         "Set a breakpoint on a single invocation of the kernel with specified "
-         "coordinate.\n"
-         "Coordinate takes the form 'x[,y][,z] where x,y,z are positive "
-         "integers representing kernel dimensions. "
-         "Any unset dimensions will be defaulted to zero."},
-        {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
 class CommandObjectRenderScriptRuntimeKernelBreakpointAll
     : public CommandObjectParsed {
 public:
   CommandObjectRenderScriptRuntimeKernelBreakpointAll(
       CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "renderscript kernel breakpoint all",
             "Automatically sets a breakpoint on all renderscript kernels that "
RenderScriptRuntime *runtime =
         (RenderScriptRuntime *)m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript);
     runtime->DumpContexts(result.GetOutputStream());
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 };
 
+static OptionDefinition g_renderscript_runtime_alloc_dump_options[] = {
+    {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgTypeFilename,
+     "Print results to specified file instead of command line."}};
+
 class CommandObjectRenderScriptRuntimeContext : public CommandObjectMultiword {
 public:
   CommandObjectRenderScriptRuntimeContext(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "renderscript context",
                                "Commands that deal with RenderScript contexts.",
                                nullptr) {
     LoadSubCommand(
         "dump", CommandObjectSP(new CommandObjectRenderScriptRuntimeContextDump(
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_outfile.Clear();
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_renderscript_runtime_alloc_dump_options;
+    }
 
-    static OptionDefinition g_option_table[];
     FileSpec m_outfile;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat("'%s' takes 1 argument, an allocation ID. "
                                    "As well as an optional -f argument",
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     return true;
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectRenderScriptRuntimeAllocationDump::
-    CommandOptions::g_option_table[] = {
-        {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument,
-         nullptr, nullptr, 0, eArgTypeFilename,
-         "Print results to specified file instead of command line."},
-        {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
+static OptionDefinition g_renderscript_runtime_alloc_list_options[] = {
+    {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument, nullptr,
+     nullptr, 0, eArgTypeIndex,
+     "Only show details of a single allocation with specified id."}};
 
 class CommandObjectRenderScriptRuntimeAllocationList
     : public CommandObjectParsed {
 public:
   CommandObjectRenderScriptRuntimeAllocationList(
       CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "renderscript allocation list",
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_id = 0;
     }
 
-    const OptionDefinition *GetDefinitions() override { return g_option_table; }
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return g_renderscript_runtime_alloc_list_options;
+    }
 
-    static OptionDefinition g_option_table[];
     uint32_t m_id;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
     runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(),
                              m_options.m_id);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   CommandOptions m_options;
 };
 
-OptionDefinition CommandObjectRenderScriptRuntimeAllocationList::
-    CommandOptions::g_option_table[] = {
-        {LLDB_OPT_SET_1, false, "id", 'i', OptionParser::eRequiredArgument,
-         nullptr, nullptr, 0, eArgTypeIndex,
-         "Only show details of a single allocation with specified id."},
-        {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
 class CommandObjectRenderScriptRuntimeAllocationLoad
     : public CommandObjectParsed {
 public:
   CommandObjectRenderScriptRuntimeAllocationLoad(
       CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "renderscript allocation load",
             "Loads renderscript allocation contents from a file.",

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 // =========================================================================
 
 // -------------------------------------------------------------------------
 /// Provides the main on-off switch for enabling darwin logging.
 ///
 /// It is valid to run the enable command when logging is already enabled.
 /// This resets the logging with whatever settings are currently set.
 // -------------------------------------------------------------------------
+
+static OptionDefinition g_enable_option_table[] = {
+    // Source stream include/exclude options (the first-level filter).
+    // This one should be made as small as possible as everything that
+    // goes through here must be processed by the process monitor.
+    {LLDB_OPT_SET_ALL, false, "any-process", 'a', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Specifies log messages from other related processes should be "
+     "included."},
+    {LLDB_OPT_SET_ALL, false, "debug", 'd', OptionParser::eNoArgument, nullptr,
+     nullptr, 0, eArgTypeNone,
+     "Specifies debug-level log messages should be included.  Specifying"
+     " --debug implies --info."},
+    {LLDB_OPT_SET_ALL, false, "info", 'i', OptionParser::eNoArgument, nullptr,
+     nullptr, 0, eArgTypeNone,
+     "Specifies info-level log messages should be included."},
+    {LLDB_OPT_SET_ALL, false, "filter", 'f', OptionParser::eRequiredArgument,
+     nullptr, nullptr, 0, eArgRawInput,
+     // There doesn't appear to be a great way for me to have these
+     // multi-line, formatted tables in help.  This looks mostly right
+     // but there are extra linefeeds added at seemingly random spots,
+     // and indentation isn't handled properly on those lines.
+     "Appends a filter rule to the log message filter chain.  Multiple "
+     "rules may be added by specifying this option multiple times, "
+     "once per filter rule.  Filter rules are processed in the order "
+     "they are specified, with the --no-match-accepts setting used "
+     "for any message that doesn't match one of the rules.\n"
+     "\n"
+     "    Filter spec format:\n"
+     "\n"
+     "    --filter \"{action} {attribute} {op}\"\n"
+     "\n"
+     "    {action} :=\n"
+     "      accept |\n"
+     "      reject\n"
+     "\n"
+     "    {attribute} :=\n"
+     "       activity       |  // message's most-derived activity\n"
+     "       activity-chain |  // message's {parent}:{child} activity\n"
+     "       category       |  // message's category\n"
+     "       message        |  // message's expanded contents\n"
+     "       subsystem      |  // message's subsystem\n"
+     "\n"
+     "    {op} :=\n"
+     "      match {exact-match-text} |\n"
+     "      regex {search-regex}\n"
+     "\n"
+     "The regex flavor used is the C++ std::regex ECMAScript format.  "
+     "Prefer character classes like [[:digit:]] to \\d and the like, as "
+     "getting the backslashes escaped through properly is error-prone."},
+    {LLDB_OPT_SET_ALL, false, "live-stream", 'l',
+     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
+     "Specify whether logging events are live-streamed or buffered.  "
+     "True indicates live streaming, false indicates buffered.  The "
+     "default is true (live streaming).  Live streaming will deliver "
+     "log messages with less delay, but buffered capture mode has less "
+     "of an observer effect."},
+    {LLDB_OPT_SET_ALL, false, "no-match-accepts", 'n',
+     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
+     "Specify whether a log message that doesn't match any filter rule "
+     "is accepted or rejected, where true indicates accept.  The "
+     "default is true."},
+    {LLDB_OPT_SET_ALL, false, "echo-to-stderr", 'e',
+     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
+     "Specify whether os_log()/NSLog() messages are echoed to the "
+     "target program's stderr.  When DarwinLog is enabled, we shut off "
+     "the mirroring of os_log()/NSLog() to the program's stderr.  "
+     "Setting this flag to true will restore the stderr mirroring."
+     "The default is false."},
+    {LLDB_OPT_SET_ALL, false, "broadcast-events", 'b',
+     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
+     "Specify if the plugin should broadcast events.  Broadcasting "
+     "log events is a requirement for displaying the log entries in "
+     "LLDB command-line.  It is also required if LLDB clients want to "
+     "process log events.  The default is true."},
+    // Message formatting options
+    {LLDB_OPT_SET_ALL, false, "timestamp-relative", 'r',
+     OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+     "Include timestamp in the message header when printing a log "
+     "message.  The timestamp is relative to the first displayed "
+     "message."},
+    {LLDB_OPT_SET_ALL, false, "subsystem", 's', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Include the subsystem in the the message header when displaying "
+     "a log message."},
+    {LLDB_OPT_SET_ALL, false, "category", 'c', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Include the category in the the message header when displaying "
+     "a log message."},
+    {LLDB_OPT_SET_ALL, false, "activity-chain", 'C', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Include the activity parent-child chain in the the message header "
+     "when displaying a log message.  The activity hierarchy is "
+     "displayed as {grandparent-activity}:"
+     "{parent-activity}:{activity}[:...]."},
+    {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument,
+     nullptr, nullptr, 0, eArgTypeNone,
+     "Shortcut to specify that all header fields should be displayed."}};
+
 class EnableOptions : public Options {
 public:
   EnableOptions()
       : Options(), m_include_debug_level(false), m_include_info_level(false),
         m_include_any_process(false),
         m_filter_fall_through_accepts(DEFAULT_FILTER_FALLTHROUGH_ACCEPTS),
         m_echo_to_stderr(false), m_display_timestamp_relative(false),
         m_display_subsystem(false), m_display_category(false),
case 's':
       break;
 
     default:
       error.SetErrorStringWithFormat("unsupported option '%c'", short_option);
     }
     return error;
   }
 
-  const OptionDefinition *GetDefinitions() override {
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return g_enable_option_table;
   }
 
   StructuredData::DictionarySP BuildConfigurationData(bool enabled) {
     StructuredData::DictionarySP config_sp(new StructuredData::Dictionary());
 
     // Set the basic enabled state.
     config_sp->AddBooleanItem("enabled", enabled);
for (size_t i = 0; i < attribute_count; ++i) {
       if (attribute_name == s_filter_attributes[i])
         return static_cast<int>(i);
     }
 
     // We didn't match anything.
     return -1;
   }
 
-  static OptionDefinition g_enable_option_table[];
-
   bool m_include_debug_level;
   bool m_include_info_level;
   bool m_include_any_process;
   bool m_filter_fall_through_accepts;
   bool m_echo_to_stderr;
   bool m_display_timestamp_relative;
   bool m_display_subsystem;
   bool m_display_category;
   bool m_display_activity_chain;
   bool m_broadcast_events;
   bool m_live_stream;
   FilterRules m_filter_rules;
 };
 
-OptionDefinition EnableOptions::g_enable_option_table[] = {
-    // Source stream include/exclude options (the first-level filter).
-    // This one should be made as small as possible as everything that
-    // goes through here must be processed by the process monitor.
-    {LLDB_OPT_SET_ALL, false, "any-process", 'a', OptionParser::eNoArgument,
-     nullptr, nullptr, 0, eArgTypeNone,
-     "Specifies log messages from other related processes should be "
-     "included."},
-    {LLDB_OPT_SET_ALL, false, "debug", 'd', OptionParser::eNoArgument, nullptr,
-     nullptr, 0, eArgTypeNone,
-     "Specifies debug-level log messages should be included.  Specifying"
-     " --debug implies --info."},
-    {LLDB_OPT_SET_ALL, false, "info", 'i', OptionParser::eNoArgument, nullptr,
-     nullptr, 0, eArgTypeNone,
-     "Specifies info-level log messages should be included."},
-    {LLDB_OPT_SET_ALL, false, "filter", 'f', OptionParser::eRequiredArgument,
-     nullptr, nullptr, 0, eArgRawInput,
-     // There doesn't appear to be a great way for me to have these
-     // multi-line, formatted tables in help.  This looks mostly right
-     // but there are extra linefeeds added at seemingly random spots,
-     // and indentation isn't handled properly on those lines.
-     "Appends a filter rule to the log message filter chain.  Multiple "
-     "rules may be added by specifying this option multiple times, "
-     "once per filter rule.  Filter rules are processed in the order "
-     "they are specified, with the --no-match-accepts setting used "
-     "for any message that doesn't match one of the rules.\n"
-     "\n"
-     "    Filter spec format:\n"
-     "\n"
-     "    --filter \"{action} {attribute} {op}\"\n"
-     "\n"
-     "    {action} :=\n"
-     "      accept |\n"
-     "      reject\n"
-     "\n"
-     "    {attribute} :=\n"
-     "       activity       |  // message's most-derived activity\n"
-     "       activity-chain |  // message's {parent}:{child} activity\n"
-     "       category       |  // message's category\n"
-     "       message        |  // message's expanded contents\n"
-     "       subsystem      |  // message's subsystem\n"
-     "\n"
-     "    {op} :=\n"
-     "      match {exact-match-text} |\n"
-     "      regex {search-regex}\n"
-     "\n"
-     "The regex flavor used is the C++ std::regex ECMAScript format.  "
-     "Prefer character classes like [[:digit:]] to \\d and the like, as "
-     "getting the backslashes escaped through properly is error-prone."},
-    {LLDB_OPT_SET_ALL, false, "live-stream", 'l',
-     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
-     "Specify whether logging events are live-streamed or buffered.  "
-     "True indicates live streaming, false indicates buffered.  The "
-     "default is true (live streaming).  Live streaming will deliver "
-     "log messages with less delay, but buffered capture mode has less "
-     "of an observer effect."},
-    {LLDB_OPT_SET_ALL, false, "no-match-accepts", 'n',
-     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
-     "Specify whether a log message that doesn't match any filter rule "
-     "is accepted or rejected, where true indicates accept.  The "
-     "default is true."},
-    {LLDB_OPT_SET_ALL, false, "echo-to-stderr", 'e',
-     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
-     "Specify whether os_log()/NSLog() messages are echoed to the "
-     "target program's stderr.  When DarwinLog is enabled, we shut off "
-     "the mirroring of os_log()/NSLog() to the program's stderr.  "
-     "Setting this flag to true will restore the stderr mirroring."
-     "The default is false."},
-    {LLDB_OPT_SET_ALL, false, "broadcast-events", 'b',
-     OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
-     "Specify if the plugin should broadcast events.  Broadcasting "
-     "log events is a requirement for displaying the log entries in "
-     "LLDB command-line.  It is also required if LLDB clients want to "
-     "process log events.  The default is true."},
-    // Message formatting options
-    {LLDB_OPT_SET_ALL, false, "timestamp-relative", 'r',
-     OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
-     "Include timestamp in the message header when printing a log "
-     "message.  The timestamp is relative to the first displayed "
-     "message."},
-    {LLDB_OPT_SET_ALL, false, "subsystem", 's', OptionParser::eNoArgument,
-     nullptr, nullptr, 0, eArgTypeNone,
-     "Include the subsystem in the the message header when displaying "
-     "a log message."},
-    {LLDB_OPT_SET_ALL, false, "category", 'c', OptionParser::eNoArgument,
-     nullptr, nullptr, 0, eArgTypeNone,
-     "Include the category in the the message header when displaying "
-     "a log message."},
-    {LLDB_OPT_SET_ALL, false, "activity-chain", 'C', OptionParser::eNoArgument,
-     nullptr, nullptr, 0, eArgTypeNone,
-     "Include the activity parent-child chain in the the message header "
-     "when displaying a log message.  The activity hierarchy is "
-     "displayed as {grandparent-activity}:"
-     "{parent-activity}:{activity}[:...]."},
-    {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument,
-     nullptr, nullptr, 0, eArgTypeNone,
-     "Shortcut to specify that all header fields should be displayed."},
-
-    // Tail sentinel entry
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
-
 class EnableCommand : public CommandObjectParsed {
 public:
   EnableCommand(CommandInterpreter &interpreter, bool enable, const char *name,
                 const char *help, const char *syntax)
       : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable),
         m_options_sp(enable ? new EnableOptions() : nullptr) {}
 
 protected:

lldb/trunk/source/Target/Platform.cpp

 };
 
 static OptionDefinition g_caching_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
      OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePath,
      "Path in which to store local copies of files."},
 };
 
-const lldb_private::OptionDefinition *
-OptionGroupPlatformRSync::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
   return g_rsync_option_table;
 }
 
 void OptionGroupPlatformRSync::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_rsync = false;
   m_rsync_opts.clear();
   m_rsync_prefix.clear();
OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;
 }
 
-uint32_t OptionGroupPlatformRSync::GetNumDefinitions() {
-  return llvm::array_lengthof(g_rsync_option_table);
-}
-
 lldb::BreakpointSP
 Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
   return lldb::BreakpointSP();
 }
 
-const lldb_private::OptionDefinition *OptionGroupPlatformSSH::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
   return g_ssh_option_table;
 }
 
 void OptionGroupPlatformSSH::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_ssh = false;
   m_ssh_opts.clear();
 }
OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;
 }
 
-uint32_t OptionGroupPlatformSSH::GetNumDefinitions() {
-  return llvm::array_lengthof(g_ssh_option_table);
-}
-
-const lldb_private::OptionDefinition *
-OptionGroupPlatformCaching::GetDefinitions() {
+llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
   return g_caching_option_table;
 }
 
 void OptionGroupPlatformCaching::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_cache_dir.clear();
 }
 
lldb_private::Error OptionGroupPlatformCaching::SetOptionValue(
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;
 }
 
-uint32_t OptionGroupPlatformCaching::GetNumDefinitions() {
-  return llvm::array_lengthof(g_caching_option_table);
-}
-
 size_t Platform::GetEnvironment(StringList &environment) {
   environment.Clear();
   return false;
 }
 
 const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
   if (!m_calculated_trap_handlers) {
     std::lock_guard<std::mutex> guard(m_mutex);

lldb/trunk/source/Target/Process.cpp

Error ProcessLaunchCommandOptions::SetOptionValue(
   default:
     error.SetErrorStringWithFormat("unrecognized short option character '%c'",
                                    short_option);
     break;
   }
   return error;
 }
 
-OptionDefinition ProcessLaunchCommandOptions::g_option_table[] = {
+static OptionDefinition g_process_launch_options[] = {
     {LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
      "Stop at the entry point of the program when launching a process."},
     {LLDB_OPT_SET_ALL, false, "disable-aslr", 'A',
      OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
      "Set whether to disable address space layout randomization when launching "
      "a process."},
     {LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument,
static OptionDefinition g_process_launch_options[] = {
      "Start the process in a terminal (not supported on all platforms)."},
 
     {LLDB_OPT_SET_3, false, "no-stdio", 'n', OptionParser::eNoArgument, nullptr,
      nullptr, 0, eArgTypeNone,
      "Do not set up for terminal I/O to go to running process."},
     {LLDB_OPT_SET_4, false, "shell-expand-args", 'X',
      OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean,
      "Set whether to shell expand arguments to the process when launching."},
-    {0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr}};
+};
+
+llvm::ArrayRef<OptionDefinition> ProcessLaunchCommandOptions::GetDefinitions() {
+  return g_process_launch_options;
+}
 
 bool ProcessInstanceInfoMatch::NameMatches(const char *process_name) const {
   if (m_name_match_type == eNameMatchIgnore || process_name == nullptr)
     return true;
   const char *match_name = m_match_info.GetName();
   if (!match_name)
     return true;