Decoupled Options parsing from CommandInterpreter.

[tfiala]

Summary

Options used to store a reference to the CommandInterpreter
instance in the base Options class. This made it impossible
to parse options independent of a CommandInterpreter.

This change removes the reference from the base class.
Instead, it modifies the options-parsing-related methods
to take an ExecutionContext pointer, which the options
may inspect if they need to do so.

[tfiala]

source/Interpreter/Args.cpp

553–554

We can get rid of the new PlatformSP and require_validation arguments added here if/when we have OptionValidator take an ExecutionContext *and* we add Platform to ExecutionContext.

Otherwise, we don't have enough information to do the validation job that some of the validators do. So for now, we pass in the platform.

[clayborg]

I like that we have decoupled option parsing from the interpreter and debugger. It will make our option parsing classes more useful. If we run into problems, we can always add a Debugger to the ExecutionContext if needed.

[jingham]

That looks great.

I think it would make more sense to add the Platform to the Execution Context than the Debugger. The point of using the Execution Context was to get around having to ask for "currently selected" things from the Debugger, so from that standpoint adding the Platform makes more sense. Plus, that better matches the hierarchy of entities involved in getting something to run somewhere, which is what the ExecutionContext represents.

I actually think that would be a good change in itself, and would clean up the validator code after your patch. But that's another big change, and this one is fine to go in as is.

[tfiala]

I actually think that would be a good change in itself, and would clean up the validator code after your patch. But that's another big change, and this one is fine to go in as is.

Excellent, thanks Jim and Greg!

I can look at doing the Platform addition to the execution context later.

Committed as r278440.

include/lldb/Interpreter/Args.h

public:
     //------------------------------------------------------------------
     /// Parse the arguments in the contained arguments.
     ///
     /// The arguments that are consumed by the argument parsing process
     /// will be removed from the argument vector. The arguments that
     /// get processed start at the second argument. The first argument
     /// is assumed to be the command and will not be touched.
     ///
+    /// param[in] platform_sp
+    ///   The platform used for option validation.  This is necessary
+    ///   because an empty execution_context is not enough to get us
+    ///   to a reasonable platform.  If the platform isn't given,
+    ///   we'll try to get it from the execution context.  If we can't
+    ///   get it from the execution context, we'll skip validation.
+    ///
+    /// param[in] require_validation
+    ///   When true, it will fail option parsing if validation could
+    ///   not occur due to not having a platform.
+    ///
     /// @see class Options
     //------------------------------------------------------------------
     Error
-    ParseOptions (Options &options);
+    ParseOptions (Options &options, ExecutionContext *execution_context,
+                  lldb::PlatformSP platform_sp, bool require_validation);
     
     size_t
     FindArgumentIndexForOption (Option *long_options, int long_options_index);
     
     bool
     IsPositionalArgument (const char *arg);
 
     // The following works almost identically to ParseOptions, except that no option is required to have arguments,

include/lldb/Interpreter/OptionGroupArchitecture.h

public:
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     bool
     GetArchitecture (Platform *platform, ArchSpec &arch);
 
     bool
     ArchitectureWasSpecified () const
     {
         return !m_arch_str.empty();

include/lldb/Interpreter/OptionGroupBoolean.h

public:
         
         const OptionDefinition*
         GetDefinitions() override
         {
             return &m_option_definition;
         }
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-                       uint32_t option_idx,
-                       const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         OptionValueBoolean &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueBoolean &

include/lldb/Interpreter/OptionGroupFile.h

public:
     
     const OptionDefinition*
     GetDefinitions() override
     {
         return &m_option_definition;
     }
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     OptionValueFileSpec &
     GetOptionValue ()
     {
         return m_file;
     }
 
     const OptionValueFileSpec &
public:
     
     const OptionDefinition*
     GetDefinitions() override
     {
         return &m_option_definition;
     }
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
 
     OptionValueFileSpecList &
     GetOptionValue ()
     {
         return m_file_list;
     }
     
     const OptionValueFileSpecList &

include/lldb/Interpreter/OptionGroupFormat.h

public:
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     lldb::Format
     GetFormat () const
     {
         return m_format.GetCurrentValue();
     }
 
     OptionValueFormat &
public:
     {
         return m_format.OptionWasSet() ||
                m_byte_size.OptionWasSet() ||
                m_count.OptionWasSet();
     }
 
 protected:
     bool
-    ParserGDBFormatLetter (CommandInterpreter &interpreter,
+    ParserGDBFormatLetter (ExecutionContext *execution_context,
                            char format_letter,
                            lldb::Format &format,
                            uint32_t &byte_size);
 
     OptionValueFormat m_format;
     OptionValueUInt64 m_byte_size;
     OptionValueUInt64 m_count;
     char m_prev_gdb_format;
     char m_prev_gdb_size;
     bool m_has_gdb_format;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupFormat_h_

include/lldb/Interpreter/OptionGroupOutputFile.h

public:
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     const OptionValueFileSpec &
     GetFile ()
     {
         return m_file;
     }
 
     const OptionValueBoolean &

include/lldb/Interpreter/OptionGroupPlatform.h

public:
     
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     lldb::PlatformSP 
     CreatePlatformWithOptions (CommandInterpreter &interpreter,
                                const ArchSpec &arch,
                                bool make_selected, 
                                Error& error,
                                ArchSpec &platform_arch) const;
 

include/lldb/Interpreter/OptionGroupString.h

public:
         
         const OptionDefinition*
         GetDefinitions() override
         {
             return &m_option_definition;
         }
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-                       uint32_t option_idx,
-                       const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         OptionValueString &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueString &

include/lldb/Interpreter/OptionGroupUInt64.h

public:
         
         const OptionDefinition*
         GetDefinitions() override
         {
             return &m_option_definition;
         }
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-                       uint32_t option_idx,
-                       const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         OptionValueUInt64 &
         GetOptionValue ()
         {
             return m_value;
         }
         
         const OptionValueUInt64 &

include/lldb/Interpreter/OptionGroupUUID.h

public:
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     const OptionValueUUID &
     GetOptionValue () const
     {
         return m_uuid;
     }
 
 protected:
     OptionValueUUID m_uuid;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupUUID_h_

include/lldb/Interpreter/OptionGroupValueObjectDisplay.h

public:
 
     uint32_t
     GetNumDefinitions() override;
     
     const OptionDefinition*
     GetDefinitions() override;
     
     Error
-    SetOptionValue(CommandInterpreter &interpreter,
-                   uint32_t option_idx,
-                   const char *option_value) override;
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_value,
+                   ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting(CommandInterpreter &interpreter) override;
+    OptionParsingStarting(ExecutionContext *execution_context) override;
     
     bool
     AnyOptionWasSet () const
     {
         return show_types ||
                no_summary_depth != 0 ||
                show_location ||
                flat_output ||

include/lldb/Interpreter/OptionGroupVariable.h

public:
 
         uint32_t
         GetNumDefinitions() override;
         
         const OptionDefinition*
         GetDefinitions() override;
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-                       uint32_t option_idx,
-                       const char *option_arg) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_arg,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         bool include_frame_options:1,
              show_args:1,       // Frame option only (include_frame_options == true)
              show_locals:1,     // Frame option only (include_frame_options == true)
              show_globals:1,    // Frame option only (include_frame_options == true)
              use_regex:1,
              show_scope:1,
              show_decl:1;

include/lldb/Interpreter/OptionGroupWatchpoint.h

public:
 
         uint32_t
         GetNumDefinitions() override;
         
         const OptionDefinition*
         GetDefinitions() override;
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-                       uint32_t option_idx,
-                       const char *option_arg) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_arg,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         // Note:
         // eWatchRead == LLDB_WATCH_TYPE_READ; and
         // eWatchWrite == LLDB_WATCH_TYPE_WRITE
         typedef enum WatchType {
             eWatchInvalid = 0,
             eWatchRead,
             eWatchWrite,

include/lldb/Interpreter/Options.h

 ///             std::cout << "verbose is on" << std::endl;
 ///         }
 ///     }
 /// \endcode
 //----------------------------------------------------------------------
 class Options
 {
 public:
-    Options (CommandInterpreter &interpreter);
+    Options ();
 
     virtual
     ~Options ();
 
     void
     BuildGetoptTable ();
 
     void
public:
 
     void
     OutputFormattedUsageText (Stream &strm,
                               const OptionDefinition &option_def,
                               uint32_t output_max_columns);
 
     void
     GenerateOptionUsage (Stream &strm,
-                         CommandObject *cmd);
+                         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;
     }
 
     // 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 ();
+    NotifyOptionParsingStarting (ExecutionContext *execution_context);
     
     Error
-    NotifyOptionParsingFinished ();
+    NotifyOptionParsingFinished (ExecutionContext *execution_context);
 
     //------------------------------------------------------------------
     /// Set the value of an option.
     ///
     /// @param[in] option_idx
     ///     The index into the "struct option" array that was returned
     ///     by Options::GetLongOptions().
     ///
     /// @param[in] option_arg
     ///     The argument value for the option that the user entered, or
     ///     nullptr if there is no argument for the current option.
     ///
+    /// @param[in] execution_context
+    ///     The execution context to use for evaluating the option.
+    ///     May be nullptr if the option is to be evaluated outside any
+    ///     particular context.
     ///
     /// @see Args::ParseOptions (Options&)
     /// @see man getopt_long_only
     //------------------------------------------------------------------
     virtual Error
-    SetOptionValue (uint32_t option_idx, const char *option_arg) = 0;
+    SetOptionValue (uint32_t option_idx, const char *option_arg,
+                    ExecutionContext *execution_context) = 0;
 
     //------------------------------------------------------------------
     /// Handles the generic bits of figuring out whether we are in an 
     /// option, and if so completing it.
     ///
     /// @param[in] input
     ///    The command line parsed into words
     ///
public:
     //------------------------------------------------------------------
     bool
     HandleOptionCompletion (Args &input,
                             OptionElementVector &option_map,
                             int cursor_index,
                             int char_pos,
                             int match_start_point,
                             int max_return_elements,
+                            CommandInterpreter &interpreter,
                             bool &word_complete,
                             lldb_private::StringList &matches);
 
     //------------------------------------------------------------------
     /// Handles the generic bits of figuring out whether we are in an 
     /// option, and if so completing it.
     ///
     /// @param[in] interpreter
public:
     ///     The position in \a opt_element_vector of the word in \a 
     ///     input containing the cursor.
     ///
     /// @param[in] match_start_point
     /// @param[in] match_return_elements
     ///     See CommandObject::HandleCompletions for a description of 
     ///     how these work.
     ///
+    /// @param[in] interpreter
+    ///     The command interpreter in which we're doing completion.
+    ///
     /// @param[out] word_complete
     ///     \btrue if this is a complete option value (a space will 
     ///     be inserted after the completion.) \bfalse otherwise.
     ///
     /// @param[out] matches
     ///     The array of matches returned.
     ///
     /// FIXME: This is the wrong return value, since we also need to
     /// make a distinction between total number of matches, and the 
     /// window the user wants returned.
     ///
     /// @return
     ///     \btrue if we were in an option, \bfalse otherwise.
     //------------------------------------------------------------------
     virtual 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);
 
-    CommandInterpreter&
-    GetInterpreter()
-    {
-        return m_interpreter;
-    }
-    
 protected:
     // This is a set of options expressed as indexes into the options table for this Option.
     typedef std::set<int> OptionSet;
     typedef std::vector<OptionSet> OptionSetVector;
 
-    CommandInterpreter &m_interpreter;
     std::vector<Option> m_getopt_table;
     OptionSet m_seen_options;
     OptionSetVector m_required_options;
     OptionSetVector m_optional_options;
 
     OptionSetVector &GetRequiredOptions ()
     {
         BuildValidOptionSets();
protected:
 
     void
     OptionsSetUnion (const OptionSet &set_a, const OptionSet &set_b, OptionSet &union_set);
     
     // Subclasses must reset their option values prior to starting a new
     // option parse. Each subclass must override this function and revert
     // all option settings to default values.
     virtual void
-    OptionParsingStarting () = 0;
+    OptionParsingStarting (ExecutionContext *execution_context) = 0;
 
     virtual Error
-    OptionParsingFinished ()
+    OptionParsingFinished (ExecutionContext *execution_context)
     {
         // If subclasses need to know when the options are done being parsed
         // they can implement this function to do extra checking
         Error error;
         return error;
     }
 };
 
     class OptionGroup
     {
     public:
         OptionGroup() = default;
 
         virtual 
         ~OptionGroup() = default;
 
         virtual uint32_t
         GetNumDefinitions () = 0;
 
         virtual const OptionDefinition*
         GetDefinitions () = 0;
         
         virtual Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value) = 0;
+        SetOptionValue (uint32_t option_idx,
+                        const char *option_value,
+                        ExecutionContext *execution_context) = 0;
 
         virtual void
-        OptionParsingStarting (CommandInterpreter &interpreter) = 0;
+        OptionParsingStarting(ExecutionContext *execution_context) = 0;
         
         virtual Error
-        OptionParsingFinished (CommandInterpreter &interpreter)
+        OptionParsingFinished(ExecutionContext *execution_context)
         {
             // If subclasses need to know when the options are done being parsed
             // they can implement this function to do extra checking
             Error error;
             return error;
         }
     };
 
     class OptionGroupOptions : public Options
     {
     public:
-        OptionGroupOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        OptionGroupOptions () :
+            Options (),
             m_option_defs (),
             m_option_infos (),
             m_did_finalize (false)
         {
         }
         
         ~OptionGroupOptions() override = default;
 
public:
         bool
         DidFinalize ()
         {
             return m_did_finalize;
         }
         
         Error
         SetOptionValue(uint32_t option_idx, 
-                       const char *option_arg) override;
+                       const char *option_arg,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting() override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         Error
-        OptionParsingFinished() override;
+        OptionParsingFinished(ExecutionContext *execution_context) override;
         
         const OptionDefinition*
         GetDefinitions() override
         {
             assert (m_did_finalize);
             return &m_option_defs[0];
         }
         

include/lldb/Target/Platform.h

//                Error &error) = 0;
     class OptionGroupPlatformRSync : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformRSync() = default;
 
         ~OptionGroupPlatformRSync() override = default;
 
         lldb_private::Error
-        SetOptionValue(CommandInterpreter &interpreter,
-           uint32_t option_idx,
-           const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         const lldb_private::OptionDefinition*
         GetDefinitions() override;
         
         uint32_t
         GetNumDefinitions() override;
         
         // Options table: Required for subclasses of Options.
//                Error &error) = 0;
     class OptionGroupPlatformSSH : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformSSH() = default;
 
         ~OptionGroupPlatformSSH() override = default;
 
         lldb_private::Error
-        SetOptionValue(CommandInterpreter &interpreter,
-           uint32_t option_idx,
-           const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         uint32_t
         GetNumDefinitions() override;
         
         const lldb_private::OptionDefinition*
         GetDefinitions() override;
         
         // Options table: Required for subclasses of Options.
//                Error &error) = 0;
     class OptionGroupPlatformCaching : public lldb_private::OptionGroup
     {
     public:
         OptionGroupPlatformCaching() = default;
 
         ~OptionGroupPlatformCaching() override = default;
 
         lldb_private::Error
-        SetOptionValue(CommandInterpreter &interpreter,
-           uint32_t option_idx,
-           const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         uint32_t
         GetNumDefinitions() override;
         
         const lldb_private::OptionDefinition*
         GetDefinitions() override;
         
         // Options table: Required for subclasses of Options.

include/lldb/Target/Process.h

protected:
     bool m_continue_once_attached; // Supports the use-case scenario of immediately continuing the process once attached.
     bool m_detach_on_error;  // If we are debugging remotely, instruct the stub to detach rather than killing the target on error.
     bool m_async; // Use an async attach where we start the attach and return immediately (used by GUI programs with --waitfor so they can call SBProcess::Stop() to cancel attach)
 };
 
 class ProcessLaunchCommandOptions : public Options
 {
 public:
-    ProcessLaunchCommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter)
+    ProcessLaunchCommandOptions () :
+        Options()
     {
         // Keep default values of all options in one place: OptionParsingStarting ()
-        OptionParsingStarting ();
+        OptionParsingStarting (nullptr);
     }
 
     ~ProcessLaunchCommandOptions() override = default;
 
     Error
-    SetOptionValue (uint32_t option_idx, const char *option_arg) override;
+    SetOptionValue (uint32_t option_idx, const char *option_arg,
+                    ExecutionContext *execution_context) override;
     
     void
-    OptionParsingStarting() override
+    OptionParsingStarting(ExecutionContext *execution_context) override
     {
         launch_info.Clear();
         disable_aslr = eLazyBoolCalculate;
     }
     
     const OptionDefinition*
     GetDefinitions() override
     {

source/Commands/CommandObjectArgs.h

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

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.
 //
 
 CommandObjectArgs::CommandOptions::CommandOptions (CommandInterpreter &interpreter) :
-    Options(interpreter)
+    Options()
 {
     // Keep only one place to reset the values to their defaults
-    OptionParsingStarting();
+    OptionParsingStarting(nullptr);
 }
 
 CommandObjectArgs::CommandOptions::~CommandOptions() = default;
 
 Error
-CommandObjectArgs::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+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 ()
+CommandObjectArgs::CommandOptions::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
 }
 
 const OptionDefinition*
 CommandObjectArgs::CommandOptions::GetDefinitions ()
 {
     return g_option_table;
 }

source/Commands/CommandObjectBreakpoint.cpp

typedef enum BreakpointSetType
         eSetTypeException
     } BreakpointSetType;
 
     CommandObjectBreakpointSet (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "breakpoint set", 
                              "Sets a breakpoint or set of breakpoints in the executable.", 
                              "breakpoint set <cmd-options>"),
-        m_options (interpreter)
+        m_options ()
     {
     }
 
     ~CommandObjectBreakpointSet() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_condition (),
             m_filenames (),
             m_line_num (0),
             m_column (0),
             m_func_names (),
             m_func_name_type_mask (eFunctionNameTypeNone),
             m_func_regexp (),
             m_source_text_regexp(),
public:
             m_all_files (false),
             m_move_to_nearest_code (eLazyBoolCalculate)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                     {
-                        ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                        m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                        m_load_addr =
+                            Args::StringToAddress(execution_context, option_arg,
+                                                  LLDB_INVALID_ADDRESS, &error);
                     }
                     break;
 
                 case 'A':
                     m_all_files = true;
                     break;
 
                 case 'b':
public:
 
                 case 'N':
                     if (BreakpointID::StringIsBreakpointName(option_arg, error))
                         m_breakpoint_names.push_back (option_arg);
                     break;
 
                 case 'R':
                     {
-                        ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
                         lldb::addr_t tmp_offset_addr;
-                        tmp_offset_addr = Args::StringToAddress(&exe_ctx, option_arg, 0, &error);
+                        tmp_offset_addr =
+                            Args::StringToAddress(execution_context, option_arg,
+                                                  0, &error);
                         if (error.Success())
                             m_offset_addr = tmp_offset_addr;
                     }
                     break;
 
                 case 'o':
                     m_one_shot = true;
                     break;
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_condition.clear();
             m_filenames.Clear();
             m_line_num = 0;
             m_column = 0;
             m_func_names.clear();
             m_func_name_type_mask = eFunctionNameTypeNone;
             m_func_regexp.clear();

 public:
     CommandObjectBreakpointModify (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "breakpoint modify", 
                             "Modify the options on a breakpoint or set of breakpoints in the executable.  "
                             "If no breakpoint is specified, acts on the last created breakpoint.  "
                             "With the exception of -e, -d and -i, passing an empty argument clears the modification.", 
                             nullptr),
-        m_options (interpreter)
+        m_options ()
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
     ~CommandObjectBreakpointModify() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_ignore_count (0),
             m_thread_id(LLDB_INVALID_THREAD_ID),
             m_thread_id_passed(false),
             m_thread_index (UINT32_MAX),
             m_thread_index_passed(false),
             m_thread_name(),
             m_queue_name(),
             m_condition (),
             m_one_shot (false),
             m_enable_passed (false),
             m_enable_value (false),
             m_name_passed (false),
             m_queue_passed (false),
             m_condition_passed (false),
             m_one_shot_passed (false),
             m_use_dummy (false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'c':
                     if (option_arg != nullptr)
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_ignore_count = 0;
             m_thread_id = LLDB_INVALID_THREAD_ID;
             m_thread_id_passed = false;
             m_thread_index = UINT32_MAX;
             m_thread_index_passed = false;
             m_thread_name.clear();
             m_queue_name.clear();

 class CommandObjectBreakpointList : public CommandObjectParsed
 {
 public:
     CommandObjectBreakpointList (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter, 
                             "breakpoint list",
                             "List some or all breakpoints at configurable levels of detail.",
                             nullptr),
-        m_options (interpreter)
+        m_options ()
     {
         CommandArgumentEntry arg;
         CommandArgumentData bp_id_arg;
 
         // Define the first (and only) variant of this arg.
         bp_id_arg.arg_type = eArgTypeBreakpointID;
         bp_id_arg.arg_repetition = eArgRepeatOptional;
 
public:
     GetOptions () override
     {
         return &m_options;
     }
     
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_level (lldb::eDescriptionLevelBrief),
             m_use_dummy(false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'b':
                     m_level = lldb::eDescriptionLevelBrief;
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_level = lldb::eDescriptionLevelFull;
             m_internal = false;
             m_use_dummy = false;
         }
 
         const OptionDefinition *
         GetDefinitions () override
typedef enum BreakpointClearType
         eClearTypeInvalid,
         eClearTypeFileAndLine
     } BreakpointClearType;
 
     CommandObjectBreakpointClear(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "breakpoint clear",
                               "Delete or disable breakpoints matching the specified source file and line.",
                               "breakpoint clear <cmd-options>"),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectBreakpointClear() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_filename (),
             m_line_num (0)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'f':
                     m_filename.assign (option_arg);
                     break;
 
                 case 'l':
                     m_line_num = StringConvert::ToUInt32 (option_arg, 0);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_filename.clear();
             m_line_num = 0;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {

 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.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
     ~CommandObjectBreakpointDelete() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_use_dummy (false),
             m_force (false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'f':
                     m_force = true;
                     break;
 
                 case 'D':
                     m_use_dummy = true;
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_use_dummy = false;
             m_force = false;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
public:
 
     const OptionDefinition*
     GetDefinitions () override
     {
         return g_breakpoint_name_options;
     }
 
     Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_value) override
+    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;
       
         switch (short_option)
         {
         case 'N':
             if (BreakpointID::StringIsBreakpointName(option_value, error) && error.Success())
SetOptionValue (uint32_t option_idx,
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;
     }
 
     void
-    OptionParsingStarting (CommandInterpreter &interpreter) override
+    OptionParsingStarting (ExecutionContext *execution_context) override
     {
         m_name.Clear();
         m_breakpoint.Clear();
         m_use_dummy.Clear();
         m_use_dummy.SetDefaultValue(false);
     }
 
     OptionValueString m_name;
     OptionValueUInt64 m_breakpoint;
     OptionValueBoolean m_use_dummy;
 };
 
 class CommandObjectBreakpointNameAdd : public CommandObjectParsed
 {
 public:
     CommandObjectBreakpointNameAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "add",
                              "Add a name to the breakpoints provided.",
                              "breakpoint name add <command-options> <breakpoint-id-list>"),
         m_name_options(),
-        m_option_group(interpreter)
+        m_option_group()
         {
             // Create the first variant for the first (and only) argument for this command.
             CommandArgumentEntry arg1;
             CommandArgumentData id_arg;
             id_arg.arg_type = eArgTypeBreakpointID;
             id_arg.arg_repetition = eArgRepeatOptional;
             arg1.push_back(id_arg);
             m_arguments.push_back (arg1);

 {
 public:
     CommandObjectBreakpointNameDelete (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "delete",
                              "Delete a name from the breakpoints provided.",
                              "breakpoint name delete <command-options> <breakpoint-id-list>"),
         m_name_options(),
-        m_option_group(interpreter)
+        m_option_group()
     {
         // Create the first variant for the first (and only) argument for this command.
         CommandArgumentEntry arg1;
         CommandArgumentData id_arg;
         id_arg.arg_type = eArgTypeBreakpointID;
         id_arg.arg_repetition = eArgRepeatOptional;
         arg1.push_back(id_arg);
         m_arguments.push_back (arg1);

 {
 public:
     CommandObjectBreakpointNameList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "list",
                              "List either the names for a breakpoint or the breakpoints for a given name.",
                              "breakpoint name list <command-options>"),
         m_name_options(),
-        m_option_group(interpreter)
+        m_option_group()
     {
         m_option_group.Append (&m_name_options);
         m_option_group.Finalize();
     }
 
     ~CommandObjectBreakpointNameList() override = default;
 
     Options *

source/Commands/CommandObjectBreakpointCommand.cpp

 {
 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 commands to the last created breakpoint.",
                               nullptr),
           IOHandlerDelegateMultiline("DONE", IOHandlerDelegate::Completion::LLDBCommand),
-          m_options(interpreter)
+          m_options()
     {
         SetHelpLong (
 R"(
 General information about entering breakpoint commands
 ------------------------------------------------------
 
 )" "This command will prompt for commands to be executed when the specified \
 breakpoint is hit.  Each command is typed on its own line following the '> ' \
BreakpointOptionsCallbackFunction (void *baton,
            }
         }
         return ret_value;
     }    
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions () :
+            Options (),
             m_use_commands (false),
             m_use_script_language (false),
             m_script_language (eScriptLanguageNone),
             m_use_one_liner (false),
             m_one_liner(),
             m_function_name()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'o':
                 m_use_one_liner = true;
public:
 
             default:
                 break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_use_commands = true;
             m_use_script_language = false;
             m_script_language = eScriptLanguageNone;
 
             m_use_one_liner = false;
             m_stop_on_error = true;
             m_one_liner.clear();

 class CommandObjectBreakpointCommandDelete : public CommandObjectParsed
 {
 public:
     CommandObjectBreakpointCommandDelete (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "delete",
                             "Delete the set of commands from a breakpoint.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData bp_id_arg;
 
         // Define the first (and only) variant of this arg.
         bp_id_arg.arg_type = eArgTypeBreakpointID;
         bp_id_arg.arg_repetition = eArgRepeatPlain;
 
public:
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
-            m_use_dummy (false)
+        CommandOptions() :
+            Options(),
+            m_use_dummy(false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'D':
                     m_use_dummy = true;
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_use_dummy = false;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;

source/Commands/CommandObjectBugreport.cpp

 class CommandObjectBugreportUnwind : public CommandObjectParsed
 {
 public:
     CommandObjectBugreportUnwind(CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "bugreport unwind",
                             "Create a bugreport for a bug in the stack unwinding code.",
                             nullptr),
-        m_option_group(interpreter),
+        m_option_group(),
         m_outfile_options()
     {
         m_option_group.Append (&m_outfile_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
         m_option_group.Finalize();
     }
 
     ~CommandObjectBugreportUnwind() override
     {

source/Commands/CommandObjectCommands.cpp

 class CommandObjectCommandsHistory : public CommandObjectParsed
 {
 public:
     CommandObjectCommandsHistory(CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "command history",
                             "Dump the history of commands in this session.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectCommandsHistory() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_start_idx(0),
             m_stop_idx(0),
             m_count(0),
             m_clear(false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'c':
                     error = m_count.SetValueFromString(option_arg,eVarSetOperationAssign);
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_start_idx.Clear();
             m_stop_idx.Clear();
             m_count.Clear();
             m_clear.Clear();
         }
 
         const OptionDefinition*

 //-------------------------------------------------------------------------
 
 class CommandObjectCommandsSource : public CommandObjectParsed
 {
 public:
     CommandObjectCommandsSource(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "command source", "Read and execute LLDB commands from the file <filename>.",
                               nullptr),
-          m_options(interpreter)
+          m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData file_arg;
         
         // Define the first (and only) variant of this arg.
         file_arg.arg_type = eArgTypeFilename;
         file_arg.arg_repetition = eArgRepeatPlain;
         
HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
-        
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();
     }
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_stop_on_error (true),
             m_silent_run (false),
             m_stop_on_continue (true)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'e':
                     error = m_stop_on_error.SetValueFromString(option_arg);
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_stop_on_error.Clear();
             m_silent_run.Clear();
             m_stop_on_continue.Clear();
         }
 
         const OptionDefinition*
         GetDefinitions () override
public:
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value) override
+        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;
             
             switch (short_option)
             {
                 case 'h':
public:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter) override
+        OptionParsingStarting (ExecutionContext *execution_context) override
         {
             m_help.Clear();
             m_long_help.Clear();
         }
         
         // Options table: Required for subclasses of Options.
         
         static OptionDefinition g_option_table[];
public:
     GetOptions () override
     {
         return &m_option_group;
     }
 
     CommandObjectCommandsAlias(CommandInterpreter &interpreter)
         : CommandObjectRaw(interpreter, "command alias", "Define a custom command in terms of an existing command.",
                            nullptr),
-          m_option_group(interpreter),
+          m_option_group(),
           m_command_options()
     {
         m_option_group.Append(&m_command_options);
         m_option_group.Finalize();
 
         SetHelpLong(
 "'alias' allows the user to create a short-cut or abbreviation for long \
 commands, multi-word commands, and commands that take particular options.  \
protected:
     bool
     DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         if (!raw_command_line || !raw_command_line[0])
         {
             result.AppendError ("'command alias' requires at least two arguments");
             return false;
         }
-        
-        m_option_group.NotifyOptionParsingStarting();
+        ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
+        m_option_group.NotifyOptionParsingStarting(&exe_ctx);
         
         const char * remainder = nullptr;
         
         if (raw_command_line[0] == '-')
         {
             // We have some options and these options MUST end with --.
             const char *end_options = nullptr;
             const char *s = raw_command_line;
DoExecute (const char *raw_command_line, CommandReturnObject &result) override
             }
             
             if (end_options)
             {
                 Args args (llvm::StringRef(raw_command_line, end_options - raw_command_line));
                 if (!ParseOptions (args, result))
                     return false;
                 
-                Error error (m_option_group.NotifyOptionParsingFinished());
+                Error error (m_option_group.NotifyOptionParsingFinished(&exe_ctx));
                 if (error.Fail())
                 {
                     result.AppendError (error.AsCString());
                     result.SetStatus (eReturnStatusFailed);
                     return false;
                 }
             }
         }
class CommandObjectCommandsAddRegex :
     public IOHandlerDelegateMultiline
 {
 public:
     CommandObjectCommandsAddRegex(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "command regex",
                               "Define a custom command in terms of existing commands by matching regular expressions.",
                               "command regex <cmd-name> [s/<regex>/<subst>/ ...]"),
           IOHandlerDelegateMultiline("", IOHandlerDelegate::Completion::LLDBCommand),
-          m_options(interpreter)
+          m_options()
     {
         SetHelpLong(R"(
 )" "This command allows the user to create powerful regular expression commands \
 with substitutions. The regular expressions and substitutions are specified \
 using the regular expression substitution format of:" R"(
 
     s/<regex>/<subst>/
 
protected:
     }
 
 private:
     std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap;
 
      class CommandOptions : public Options
      {
      public:
-         CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+         CommandOptions() :
+            Options()
          {
          }
 
          ~CommandOptions() override = default;
 
          Error
-         SetOptionValue (uint32_t option_idx, const char *option_arg) override
+         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 'h':
                      m_help.assign (option_arg);
                      break;
                  case 's':
                      m_syntax.assign (option_arg);
                      break;
                  default:
                      error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                      break;
              }
              
              return error;
          }
          
          void
-         OptionParsingStarting () override
+         OptionParsingStarting (ExecutionContext *execution_context) override
          {
              m_help.clear();
              m_syntax.clear();
          }
          
          const OptionDefinition*
          GetDefinitions () override
          {

 class CommandObjectCommandsScriptImport : public CommandObjectParsed
 {
 public:
     CommandObjectCommandsScriptImport (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "command script import",
                             "Import a scripting module in LLDB.",
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentData cmd_arg;
         
         // Define the first (and only) variant of this arg.
         cmd_arg.arg_type = eArgTypeFilename;
         cmd_arg.arg_repetition = eArgRepeatPlus;
         
HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
-        
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();
     }
     
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'r':
                     m_allow_reload = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_allow_reload = true;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;

 {
 public:
     CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "command script add",
                             "Add a scripted function as an LLDB command.",
                             nullptr),
         IOHandlerDelegateMultiline ("DONE"),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentData cmd_arg;
         
         // Define the first (and only) variant of this arg.
         cmd_arg.arg_type = eArgTypeCommandName;
         cmd_arg.arg_repetition = eArgRepeatPlain;
         
public:
     {
         return &m_options;
     }
     
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_class_name(),
             m_funct_name(),
             m_short_help(),
             m_synchronicity(eScriptedCommandSynchronicitySynchronous)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'f':
                     if (option_arg)
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_class_name.clear();
             m_funct_name.clear();
             m_short_help.clear();
             m_synchronicity = eScriptedCommandSynchronicitySynchronous;
         }
         
         const OptionDefinition*

source/Commands/CommandObjectDisassemble.h

 //-------------------------------------------------------------------------
 
 class CommandObjectDisassemble : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter);
+        CommandOptions();
 
         ~CommandOptions() override;
 
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override;
+        SetOptionValue(uint32_t option_idx, const char *option_arg,
+                       ExecutionContext *execution_context) override;
 
         void
-        OptionParsingStarting() override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
 
         const 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;
             return flavor_string.c_str();
         }
         
         Error
-        OptionParsingFinished() override;
+        OptionParsingFinished(ExecutionContext *execution_context) override;
 
         bool show_mixed; // Show mixed source/assembly
         bool show_bytes;
         uint32_t num_lines_context;
         uint32_t num_instructions;
         bool raw;
         std::string func_name;
         bool current_function;

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;
 
-CommandObjectDisassemble::CommandOptions::CommandOptions (CommandInterpreter &interpreter) :
-    Options(interpreter),
+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();
+    OptionParsingStarting(nullptr);
 }
 
 CommandObjectDisassemble::CommandOptions::~CommandOptions() = default;
 
 Error
-CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+CommandObjectDisassemble::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;
 
     bool success;
     
     switch (short_option)
case 'c':
         break;
 
     case 'b':
         show_bytes = true;
         break;
 
     case 's':
         {
-            ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-            start_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+            start_addr = Args::StringToAddress(execution_context, option_arg,
+                                               LLDB_INVALID_ADDRESS, &error);
             if (start_addr != LLDB_INVALID_ADDRESS)
                 some_location_specified = true;
         }
         break;
     case 'e':
         {
-            ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-            end_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+            end_addr = Args::StringToAddress(execution_context, option_arg,
+                                             LLDB_INVALID_ADDRESS, &error);
             if (end_addr != LLDB_INVALID_ADDRESS)
                 some_location_specified = true;
         }
         break;
 
     case 'n':
         func_name.assign (option_arg);
         some_location_specified = true;
case 'l':
         break;
 
     case 'P':
         plugin_name.assign (option_arg);
         break;
 
     case 'F':
         {
-            Target *target = m_interpreter.GetExecutionContext().GetTargetPtr();
-            if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86
-                || target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64)
+            TargetSP target_sp = execution_context ?
+                execution_context->GetTargetSP() : TargetSP();
+            if (target_sp &&
+                (target_sp->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86
+                || target_sp->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64))
             {
                 flavor_string.assign (option_arg);
             }
             else
                 error.SetErrorStringWithFormat("Disassembler flavors are currently only supported for x86 and x86_64 targets.");
             break;
         }
 
     case 'r':
         raw = true;
         break;
 
     case 'f':
         current_function = true;
         some_location_specified = true;
         break;
 
     case 'A':
-        if (!arch.SetTriple (option_arg, m_interpreter.GetPlatform (true).get()))
+        if (execution_context)
+        {
+            auto target_sp = execution_context ?
+                execution_context->GetTargetSP() : TargetSP();
+            auto platform_sp =
+                target_sp ? target_sp->GetPlatform() : PlatformSP();
+            if (!arch.SetTriple (option_arg, platform_sp.get()))
                 arch.SetTriple (option_arg);
+        }
         break;
 
     case 'a':
         {
-            ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-            symbol_containing_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+            symbol_containing_addr =
+                Args::StringToAddress(execution_context,option_arg,
+                                      LLDB_INVALID_ADDRESS, &error);
             if (symbol_containing_addr != LLDB_INVALID_ADDRESS)
             {
                 some_location_specified = true;
             }
         }
         break;
 
     default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
         break;
     }
 
     return error;
 }
 
 void
-CommandObjectDisassemble::CommandOptions::OptionParsingStarting ()
+CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
     show_mixed = false;
     show_bytes = false;
     num_lines_context = 0;
     num_instructions = 0;
     func_name.clear();
     current_function = false;
     at_pc = false;
     frame_line = false;
     start_addr = LLDB_INVALID_ADDRESS;
     end_addr = LLDB_INVALID_ADDRESS;
     symbol_containing_addr = LLDB_INVALID_ADDRESS;
     raw = false;
     plugin_name.clear();
     
-    Target *target = m_interpreter.GetExecutionContext().GetTargetPtr();
+    Target *target =
+        execution_context ? execution_context->GetTargetPtr() : nullptr;
     
     // This is a hack till we get the ability to specify features based on architecture.  For now GetDisassemblyFlavor
     // is really only valid for x86 (and for the llvm assembler plugin, but I'm papering over that since that is the
     // only disassembler plugin we have...
     if (target)
     {
         if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86
             || target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64)
         {
             flavor_string.assign(target->GetDisassemblyFlavor());
         }
         else
             flavor_string.assign ("default");
         
     }
     else
         flavor_string.assign("default");
     
     arch.Clear();
     some_location_specified = false;
 }
 
 Error
-CommandObjectDisassemble::CommandOptions::OptionParsingFinished ()
+CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
+                                            ExecutionContext *execution_context)
 {
     if (!some_location_specified)
         current_function = true;
     return Error();
 }
 
 const OptionDefinition*
 CommandObjectDisassemble::CommandOptions::GetDefinitions ()

 // CommandObjectDisassemble
 //-------------------------------------------------------------------------
 
 CommandObjectDisassemble::CommandObjectDisassemble(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "disassemble", "Disassemble specified instructions in the current target.  "
                                                       "Defaults to the current function for the current thread and "
                                                       "stack frame.",
                           "disassemble [<cmd-options>]"),
-      m_options(interpreter)
+      m_options()
 {
 }
 
 CommandObjectDisassemble::~CommandObjectDisassemble() = default;
 
 bool
 CommandObjectDisassemble::DoExecute (Args& command, CommandReturnObject &result)
 {
CommandObjectDisassemble::DoExecute (Args& command, CommandReturnObject &result)
     else if (flavor_string != nullptr && !disassembler->FlavorValidForArchSpec(m_options.arch, flavor_string))
         result.AppendWarningWithFormat("invalid disassembler flavor \"%s\", using default.\n", flavor_string);
 
     result.SetStatus (eReturnStatusSuccessFinishResult);
 
     if (command.GetArgumentCount() != 0)
     {
         result.AppendErrorWithFormat ("\"disassemble\" arguments are specified as options.\n");
-        GetOptions()->GenerateOptionUsage (result.GetErrorStream(), this);
+        const int terminal_width =
+            GetCommandInterpreter().GetDebugger().GetTerminalWidth();
+        GetOptions()->GenerateOptionUsage(result.GetErrorStream(), this,
+                                          terminal_width);
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
     
     if (m_options.show_mixed && m_options.num_lines_context == 0)
         m_options.num_lines_context = 1;
 
     // Always show the PC in the disassembly

source/Commands/CommandObjectExpression.h

public:
 
         uint32_t
         GetNumDefinitions() override;
         
         const OptionDefinition*
         GetDefinitions() override;
         
         Error
-        SetOptionValue(CommandInterpreter &interpreter,
-           uint32_t option_idx,
-           const char *option_value) override;
+        SetOptionValue(uint32_t option_idx,
+                       const char *option_value,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting(CommandInterpreter &interpreter) override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
 
         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
         bool        top_level;
         bool        unwind_on_error;
         bool        ignore_breakpoints;
         bool        allow_jit;

source/Commands/CommandObjectExpression.cpp

 
 uint32_t
 CommandObjectExpression::CommandOptions::GetNumDefinitions ()
 {
     return llvm::array_lengthof(g_option_table);
 }
 
 Error
-CommandObjectExpression::CommandOptions::SetOptionValue (CommandInterpreter &interpreter,
-                                                         uint32_t option_idx,
-                                                         const char *option_arg)
+CommandObjectExpression::CommandOptions::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;
 
     switch (short_option)
     {
     case 'l':
default:
         error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
         break;
     }
 
     return error;
 }
 
 void
-CommandObjectExpression::CommandOptions::OptionParsingStarting (CommandInterpreter &interpreter)
+CommandObjectExpression::CommandOptions::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
-    Process *process = interpreter.GetExecutionContext().GetProcessPtr();
-    if (process != nullptr)
+    auto process_sp =
+        execution_context ? execution_context->GetProcessSP() : ProcessSP();
+    if (process_sp)
     {
-        ignore_breakpoints = process->GetIgnoreBreakpointsInExpressions();
-        unwind_on_error    = process->GetUnwindOnErrorInExpressions();
+        ignore_breakpoints = process_sp->GetIgnoreBreakpointsInExpressions();
+        unwind_on_error    = process_sp->GetUnwindOnErrorInExpressions();
     }
     else
     {
         ignore_breakpoints = true;
         unwind_on_error = true;
     }
     
     show_summary = true;

 }
 
 CommandObjectExpression::CommandObjectExpression(CommandInterpreter &interpreter)
     : CommandObjectRaw(
           interpreter, "expression",
           "Evaluate an expression on the current thread.  Displays any returned value with LLDB's default formatting.",
           nullptr, eCommandProcessMustBePaused | eCommandTryTargetAPILock),
       IOHandlerDelegate(IOHandlerDelegate::Completion::Expression),
-      m_option_group(interpreter),
+      m_option_group(),
       m_format_options(eFormatDefault),
       m_repl_option(LLDB_OPT_SET_1, false, "repl", 'r', "Drop into REPL", false, true),
       m_command_options(),
       m_expr_line_count(0),
       m_expr_lines()
 {
     SetHelpLong(
 R"(
CommandObjectExpression::GetMultilineExpression ()
     debugger.PushIOHandler(io_handler_sp);
 }
 
 bool
 CommandObjectExpression::DoExecute(const char *command,
                                    CommandReturnObject &result)
 {
     m_fixed_expression.clear();
-    m_option_group.NotifyOptionParsingStarting();
+    auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+    m_option_group.NotifyOptionParsingStarting(&exe_ctx);
 
     const char * expr = nullptr;
 
     if (command[0] == '\0')
     {
         GetMultilineExpression ();
         return result.Succeeded();
     }
if (command[0] == '-')
         }
 
         if (end_options)
         {
             Args args (llvm::StringRef(command, end_options - command));
             if (!ParseOptions (args, result))
                 return false;
             
-            Error error (m_option_group.NotifyOptionParsingFinished());
+            Error error (m_option_group.NotifyOptionParsingFinished(&exe_ctx));
             if (error.Fail())
             {
                 result.AppendError (error.AsCString());
                 result.SetStatus (eReturnStatusFailed);
                 return false;
             }
             
             if (m_repl_option.GetOptionValue().GetCurrentValue())

source/Commands/CommandObjectFrame.cpp

 //-------------------------------------------------------------------------
 
 class CommandObjectFrameSelect : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue(uint32_t option_idx, const char *option_arg,
+                       ExecutionContext *execution_context) override
         {
             Error error;
             bool success = false;
             const int short_option = m_getopt_table[option_idx].val;
             switch (short_option)
             {
             case 'r':   
                 relative_frame_offset = StringConvert::ToSInt32 (option_arg, INT32_MIN, 0, &success);
                 if (!success)
                     error.SetErrorStringWithFormat ("invalid frame offset argument '%s'", option_arg);
                 break;
 
             default:
                 error.SetErrorStringWithFormat ("invalid short option character '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        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.
 
         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'.)",
               nullptr, eCommandRequiresThread | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
                            eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData index_arg;
 
         // Define the first (and only) variant of this arg.
         index_arg.arg_type = eArgTypeFrameIndex;
         index_arg.arg_repetition = eArgRepeatOptional;
 
DoExecute (Args& command, CommandReturnObject &result) override
                 {
                     frame_idx = 0;
                 }
             }
             else
             {
                 result.AppendErrorWithFormat ("too many arguments; expected frame-index, saw '%s'.\n",
                                               command.GetArgumentAtIndex(0));
-                m_options.GenerateOptionUsage (result.GetErrorStream(), this);
+                m_options.GenerateOptionUsage(result.GetErrorStream(), this,
+                                              GetCommandInterpreter()
+                                                .GetDebugger()
+                                                .GetTerminalWidth());
                 return false;
             }
         }
 
         bool success = thread->SetSelectedFrameByIndexNoisily (frame_idx, result.GetOutputStream());
         if (success)
         {
             m_exe_ctx.SetFrameSP(thread->GetSelectedFrame ());
CommandObjectFrameVariable(CommandInterpreter &interpreter)
         : CommandObjectParsed(
               interpreter, "frame variable", "Show variables for the current stack frame. Defaults to all "
                                              "arguments and local variables in scope. Names of argument, "
                                              "local, file static and file global variables can be specified. "
                                              "Children of aggregate variables can be specified such as "
                                              "'var->child.x'.",
               nullptr, eCommandRequiresFrame | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
                            eCommandProcessMustBePaused | eCommandRequiresProcess),
-          m_option_group(interpreter),
+          m_option_group(),
           m_option_variable(true), // Include the frame specific options by passing "true"
           m_option_format(eFormatDefault),
           m_varobj_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData var_name_arg;
         
         // Define the first (and only) variant of this arg.
HandleArgumentCompletion (Args &input,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         // Arguments are the standard source file completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
-        
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eVariablePathCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

source/Commands/CommandObjectHelp.h

GenerateAdditionalHelpAvenuesMessage (Stream *s,
                                           const char* subcommand = nullptr,
                                           bool include_apropos = true,
                                           bool include_type_lookup = true);
     
     class CommandOptions : public Options
     {
     public:
         
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
         
         ~CommandOptions() override {}
         
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
+        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 'a':
                     m_show_aliases = false;
                     break;
                 case 'u':
                     m_show_user_defined = false;
                     break;
                 case 'h':
                     m_show_hidden = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting() override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_show_aliases = true;
             m_show_user_defined = true;
             m_show_hidden = false;
         }
         
         const OptionDefinition*
         GetDefinitions() override

source/Commands/CommandObjectHelp.cpp

s->Printf("Try '%sapropos %s' for a list of related commands.\n",
         }
     }
 }
 
 CommandObjectHelp::CommandObjectHelp(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "help",
                           "Show a list of all debugger commands, or give details about a specific command.",
                           "help [<cmd-name>]"),
-      m_options(interpreter)
+      m_options()
 {
     CommandArgumentEntry arg;
     CommandArgumentData command_arg;
 
     // Define the first (and only) variant of this arg.
     command_arg.arg_type = eArgTypeCommandName;
     command_arg.arg_repetition = eArgRepeatStar;
 

source/Commands/CommandObjectLog.cpp

public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     CommandObjectLogEnable(CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "log enable",
                             "Enable logging for a single log channel.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentEntry arg2;
         CommandArgumentData channel_arg;
         CommandArgumentData category_arg;
         
         // Define the first (and only) variant of this arg.
         channel_arg.arg_type = eArgTypeLogChannel;

 //        }
 //        return matches.GetSize();
 //    }
 //
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
-            log_file (),
-            log_options (0)
+        CommandOptions() :
+            Options(),
+            log_file(),
+            log_options(0)
         {
         }
 
         ~CommandOptions () override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'f':  log_file.SetFile(option_arg, true);                    break;
             case 't':  log_options |= LLDB_LOG_OPTION_THREADSAFE;             break;
public:
                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             log_file.Clear();
             log_options = 0;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {

source/Commands/CommandObjectMemory.cpp

public:
     
     const OptionDefinition*
     GetDefinitions () override
     {
         return g_option_table;
     }
     
     Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_arg) override
+    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;
         
         switch (short_option)
         {
             case 'l':
                 error = m_num_per_line.SetValueFromString (option_arg);
SetOptionValue (uint32_t option_idx,
             default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
         }
         return error;
     }
     
     void
-    OptionParsingStarting (CommandInterpreter &interpreter) override
+    OptionParsingStarting(ExecutionContext *execution_context) override
     {
         m_num_per_line.Clear();
         m_output_as_binary = false;
         m_view_as_type.Clear();
         m_force = false;
         m_offset.Clear();
     }
     

 // Read memory from the inferior process
 //----------------------------------------------------------------------
 class CommandObjectMemoryRead : public CommandObjectParsed
 {
 public:
     CommandObjectMemoryRead(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "memory read", "Read from the memory of the current target process.",
                               nullptr, eCommandRequiresTarget | eCommandProcessMustBePaused),
-          m_option_group(interpreter),
+          m_option_group(),
           m_format_options(eFormatBytesWithASCII, 1, 8),
           m_memory_options(),
           m_outfile_options(),
           m_varobj_options(),
           m_next_addr(LLDB_INVALID_ADDRESS),
           m_prev_byte_size(0),
           m_prev_format_options(eFormatBytesWithASCII, 1, 8),
           m_prev_memory_options(),
public:
     
     const OptionDefinition*
     GetDefinitions () override
     {
       return g_memory_find_option_table;
     }
     
     Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_arg) override
+    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;
       
         switch (short_option)
         {
         case 'e':
               m_expr.SetValueFromString(option_arg);
SetOptionValue (uint32_t option_idx,
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;
     }
     
     void
-    OptionParsingStarting (CommandInterpreter &interpreter) override
+    OptionParsingStarting(ExecutionContext *execution_context) override
     {
         m_expr.Clear();
         m_string.Clear();
         m_count.Clear();
     }
     
       OptionValueString m_expr;
       OptionValueString m_string;
       OptionValueUInt64 m_count;
       OptionValueUInt64 m_offset;
   };
 
   CommandObjectMemoryFind(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "memory find", "Find a value in the memory of the current target process.",
                             nullptr, eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-        m_option_group(interpreter),
+        m_option_group(),
         m_memory_options()
   {
     CommandArgumentEntry arg1;
     CommandArgumentEntry arg2;
     CommandArgumentData addr_arg;
     CommandArgumentData value_arg;
     
     // Define the first (and only) variant of this arg.
public:
       
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_memory_write_option_table;
         }
       
         Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_arg) override
+        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;
           
             switch (short_option)
             {
                 case 'i':
                     m_infile.SetFile (option_arg, true);
public:
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
             return error;
         }
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter) override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_infile.Clear();
             m_infile_offset = 0;
         }
 
         FileSpec m_infile;
         off_t m_infile_offset;
     };
 
     CommandObjectMemoryWrite(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "memory write", "Write to the memory of the current target process.",
                               nullptr, eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-          m_option_group(interpreter),
+          m_option_group(),
           m_format_options(eFormatBytes, 1, UINT64_MAX),
           m_memory_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentEntry arg2;
         CommandArgumentData addr_arg;
         CommandArgumentData value_arg;
         

source/Commands/CommandObjectPlatform.cpp

 public:
     OptionPermissions ()
     {
     }
 
     ~OptionPermissions() override = default;
 
     lldb_private::Error
-    SetOptionValue (CommandInterpreter &interpreter,
-                    uint32_t option_idx,
-                    const char *option_arg) override
+    SetOptionValue(uint32_t option_idx,
+                   const char *option_arg,
+                   ExecutionContext *execution_context) override
     {
         Error error;
         char short_option = (char) GetDefinitions()[option_idx].short_option;
         switch (short_option)
         {
             case 'v':
             {
                 bool ok;
SetOptionValue(uint32_t option_idx,
                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                 break;
         }
         
         return error;
     }
     
     void
-    OptionParsingStarting (CommandInterpreter &interpreter) override
+    OptionParsingStarting(ExecutionContext *execution_context) override
     {
         m_permissions = 0;
     }
     
     uint32_t
     GetNumDefinitions () override
     {
         return llvm::array_lengthof(g_permissions_options);

 {
 public:
     CommandObjectPlatformSelect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter, 
                              "platform select",
                              "Create a platform if needed and select it as the current platform.",
                              "platform select <platform-name>",
                              0),
-        m_option_group (interpreter),
+        m_option_group (),
         m_platform_options (false) // Don't include the "--platform" option by passing false
     {
         m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, 1);
         m_option_group.Finalize();
     }
 
     ~CommandObjectPlatformSelect() override = default;
 
     int
     HandleCompletion (Args &input,
                       int &cursor_index,
                       int &cursor_char_position,
                       int match_start_point,
                       int max_return_elements,
                       bool &word_complete,
                       StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
         
-        CommandCompletions::PlatformPluginNames(m_interpreter,
+        CommandCompletions::PlatformPluginNames(GetCommandInterpreter(),
                                                 completion_str.c_str(),
                                                 match_start_point,
                                                 max_return_elements,
                                                 nullptr,
                                                 word_complete,
                                                 matches);
         return matches.GetSize();
     }

 {
 public:
     CommandObjectPlatformSettings (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "platform settings",
                              "Set settings for the current target's platform, or for a platform by name.",
                              "platform settings",
                              0),
-        m_options (interpreter),
+        m_options(),
         m_option_working_dir (LLDB_OPT_SET_1, false, "working-dir", 'w', 0, eArgTypePath, "The working directory for the platform.")
     {
         m_options.Append (&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     }
 
     ~CommandObjectPlatformSettings() override = default;
 
 protected:

 {
 public:
     CommandObjectPlatformMkDir (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "platform mkdir",
                             "Make a new directory on the remote end.",
                             nullptr,
                             0),
-        m_options(interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformMkDir() override = default;
 
     bool
     DoExecute (Args& args, CommandReturnObject &result) override
     {

 {
 public:
     CommandObjectPlatformFOpen (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "platform file open",
                             "Open a file on the remote end.",
                             nullptr,
                             0),
-        m_options(interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformFOpen() override = default;
 
     bool
     DoExecute (Args& args, CommandReturnObject &result) override
     {

 {
 public:
     CommandObjectPlatformFRead (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "platform file read",
                             "Read data from a file on the remote end.",
                             nullptr,
                             0),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformFRead() override = default;
 
     bool
     DoExecute (Args& args, CommandReturnObject &result) override
     {
public:
     {
         return &m_options;
     }
     
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue (uint32_t option_idx, const char *option_arg,
+                        ExecutionContext *execution_context) override
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_offset = 0;
             m_count = 1;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {

 {
 public:
     CommandObjectPlatformFWrite (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "platform file write",
                             "Write data to a file on the remote end.",
                             nullptr,
                             0),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformFWrite() override = default;
 
     bool
     DoExecute (Args& args, CommandReturnObject &result) override
     {
public:
     {
         return &m_options;
     }
     
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue (uint32_t option_idx, const char *option_arg,
+                        ExecutionContext *execution_context) override
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             
             switch (short_option)
             {
                 case 'o':
                     m_offset = StringConvert::ToUInt32(option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid offset: '%s'", option_arg);
                     break;
                 case 'd':
                     m_data.assign(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_offset = 0;
             m_data.clear();
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {

 {
 public:
     CommandObjectPlatformProcessLaunch (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "platform process launch",
                              "Launch a new process on a remote platform.",
                              "platform process launch program",
                              eCommandRequiresTarget | eCommandTryTargetAPILock),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformProcessLaunch() override = default;
 
     Options *
     GetOptions () override
     {

 {
 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 (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectPlatformProcessList() override = default;
 
     Options *
     GetOptions () override
     {
DoExecute (Args& args, CommandReturnObject &result) override
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
     
     class CommandOptions : public Options
     {
     public:
-        CommandOptions(CommandInterpreter &interpreter) :
-            Options(interpreter),
+        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)
public:
                     }
                 }
             });
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 = false;
 
             switch (short_option)
             {
                 case 'p':
public:
 
                 case 'G':
                     match_info.GetProcessInfo().SetEffectiveGroupID (StringConvert::ToUInt32 (option_arg, UINT32_MAX, 0, &success));
                     if (!success)
                         error.SetErrorStringWithFormat("invalid effective group ID string: '%s'", option_arg);
                     break;
 
                 case 'a':
-                    match_info.GetProcessInfo().GetArchitecture().SetTriple (option_arg, m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform().get());
+                    {
+                        TargetSP target_sp = execution_context ?
+                        execution_context->GetTargetSP() : TargetSP();
+                        DebuggerSP debugger_sp = target_sp ?
+                            target_sp->GetDebugger().shared_from_this() :
+                            DebuggerSP();
+                        PlatformSP platform_sp = debugger_sp ?
+                            debugger_sp->GetPlatformList().GetSelectedPlatform() :
+                            PlatformSP();
+                        match_info.GetProcessInfo().GetArchitecture().SetTriple(
+                                            option_arg, platform_sp.get());
+                    }
                     break;
 
                 case 'n':
                     match_info.GetProcessInfo().GetExecutableFile().SetFile (option_arg, false);
                     match_info.SetNameMatchType (eNameMatchEquals);
                     break;
 
                 case 'e':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             match_info.Clear();
             show_args = false;
             verbose = false;
         }
         
         const OptionDefinition*
         GetDefinitions () override

 };
 
 class CommandObjectPlatformProcessAttach : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter)
+        CommandOptions() :
+        Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue (uint32_t option_idx, const char *option_arg,
+                        ExecutionContext *execution_context) override
         {
             Error error;
             char short_option = (char) m_getopt_table[option_idx].val;
             bool success = false;
             switch (short_option)
             {
                 case 'p':   
                 {
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             attach_info.Clear();
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         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')
             {
                 // 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);
                 
-                PlatformSP platform_sp (m_interpreter.GetPlatform (true));
+                PlatformSP platform_sp(interpreter.GetPlatform(true));
                 if (platform_sp)
                 {
                     ProcessInstanceInfoList process_infos;
                     ProcessInstanceInfoMatch match_info;
                     if (partial_name)
                     {
                         match_info.GetProcessInfo().GetExecutableFile().SetFile(partial_name, false);
                         match_info.SetNameMatchType(eNameMatchStartsWith);
public:
         ProcessAttachInfo attach_info;
     };
     
     CommandObjectPlatformProcessAttach (CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "platform process attach",
                          "Attach to a process.",
                          "platform process attach <cmd-options>"),
-    m_options (interpreter)
+    m_options()
     {
     }
 
     ~CommandObjectPlatformProcessAttach() override = default;
 
     bool
     DoExecute (Args& command,
              CommandReturnObject &result) override

 // "platform shell"
 //----------------------------------------------------------------------
 class CommandObjectPlatformShell : public CommandObjectRaw
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter),
+        CommandOptions() :
+        Options(),
         timeout(10)
         {
         }
 
         ~CommandOptions() override = default;
 
         virtual uint32_t
         GetNumDefinitions ()
         {
             return 1;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         Error
         SetOptionValue (uint32_t option_idx,
-                        const char *option_value) override
+                        const char *option_value,
+                        ExecutionContext *execution_context) override
         {
             Error error;
             
             const char short_option = (char) g_option_table[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 () override
+        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(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectPlatformShell() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
     
     bool
     DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
-        m_options.NotifyOptionParsingStarting();
+        ExecutionContext exe_ctx =
+            GetCommandInterpreter().GetExecutionContext();
+        m_options.NotifyOptionParsingStarting(&exe_ctx);
         
         const char* expr = nullptr;
 
         // Print out an usage syntax on an empty command line.
         if (raw_command_line[0] == '\0')
         {
             result.GetOutputStream().Printf("%s\n", this->GetSyntax());
             return true;

source/Commands/CommandObjectPlugin.cpp

HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
-        
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

source/Commands/CommandObjectProcess.cpp

 public:
     CommandObjectProcessLaunch (CommandInterpreter &interpreter) :
         CommandObjectProcessLaunchOrAttach(interpreter,
                                            "process launch",
                                            "Launch the executable in the debugger.",
                                            nullptr,
                                            eCommandRequiresTarget,
                                            "restart"),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData run_args_arg;
         
         // Define the first (and only) variant of this arg.
         run_args_arg.arg_type = eArgTypeRunArgs;
         run_args_arg.arg_repetition = eArgRepeatOptional;
         
HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
-        
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, 
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

 //-------------------------------------------------------------------------
 #pragma mark CommandObjectProcessAttach
 class CommandObjectProcessAttach : public CommandObjectProcessLaunchOrAttach
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 = false;
             switch (short_option)
             {
                 case 'c':
                     attach_info.SetContinueOnceAttached(true);
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             attach_info.Clear();
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
 
         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')
             {
                 // 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);
 
-                PlatformSP platform_sp (m_interpreter.GetPlatform (true));
+                PlatformSP platform_sp(interpreter.GetPlatform(true));
                 if (platform_sp)
                 {
                     ProcessInstanceInfoList process_infos;
                     ProcessInstanceInfoMatch match_info;
                     if (partial_name)
                     {
                         match_info.GetProcessInfo().GetExecutableFile().SetFile(partial_name, false);
                         match_info.SetNameMatchType(eNameMatchStartsWith);
public:
 
     CommandObjectProcessAttach (CommandInterpreter &interpreter) :
         CommandObjectProcessLaunchOrAttach (interpreter,
                                             "process attach",
                                             "Attach to a process.",
                                             "process attach <cmd-options>",
                                             0,
                                             "attach"),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectProcessAttach() override = default;
 
     Options *
     GetOptions () override
     {
CommandObjectProcessContinue (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process continue",
                              "Continue execution of all threads in the current process.",
                              "process continue",
                              eCommandRequiresProcess       |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
-        m_options(interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectProcessContinue() override = default;
 
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 = false;
             switch (short_option)
             {
                 case 'i':
                     m_ignore = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("invalid value for ignore option: \"%s\", should be a number.", option_arg);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_ignore = 0;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;

 #pragma mark CommandObjectProcessDetach
 
 class CommandObjectProcessDetach : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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':
                     bool tmp_result;
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        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[];
 
         // 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.",
                               "process detach",
                               eCommandRequiresProcess | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectProcessDetach() override = default;
 
     Options *
     GetOptions () override
     {

 #pragma mark CommandObjectProcessConnect
 
 class CommandObjectProcessConnect : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'p':   
                 plugin_name.assign (option_arg);    
                 break;
 
             default:
                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                 break;
             }
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             plugin_name.clear();
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
public:
     };
 
     CommandObjectProcessConnect (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process connect",
                              "Connect to a remote debug service.",
                              "process connect <remote-url>",
                              0),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectProcessConnect() override = default;
 
     Options *
     GetOptions () override
     {

 #pragma mark CommandObjectProcessLoad
 
 class CommandObjectProcessLoad : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'i':
                 do_install = true;
                 if (option_arg && option_arg[0])
                     install_path.SetFile(option_arg, false);
                 break;
             default:
                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                 break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             do_install = false;
             install_path.Clear();
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
CommandObjectProcessLoad (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process load",
                              "Load a shared library into the current process.",
                              "process load <filename> [<filename> ...]",
                              eCommandRequiresProcess       |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectProcessLoad() override = default;
 
     Options *
     GetOptions () override
     {

 #pragma mark CommandObjectProcessHandle
 
 class CommandObjectProcessHandle : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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':
                     stop = option_arg;
                     break;
                 case 'n':
                     notify = option_arg;
                     break;
                 case 'p':
                     pass = option_arg;
                     break;
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             stop.clear();
             notify.clear();
             pass.clear();
         }
 
         const OptionDefinition*
         GetDefinitions () override
public:
         std::string pass;
     };
 
     CommandObjectProcessHandle(CommandInterpreter &interpreter)
         : CommandObjectParsed(
               interpreter, "process handle",
               "Manage LLDB handling of OS signals for the current target process.  Defaults to showing current policy.",
               nullptr),
-          m_options(interpreter)
+          m_options()
     {
         SetHelpLong ("\nIf no signals are specified, update them all.  If no update "
                      "option is specified, list the current values.");
         CommandArgumentEntry arg;
         CommandArgumentData signal_arg;
 
         signal_arg.arg_type = eArgTypeUnixSignal;
         signal_arg.arg_repetition = eArgRepeatStar;

source/Commands/CommandObjectRegister.cpp

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,
                             eCommandRequiresFrame         |
                             eCommandRequiresRegContext    |
                             eCommandProcessMustBeLaunched |
                             eCommandProcessMustBePaused   ),
-        m_option_group (interpreter),
+        m_option_group(),
         m_format_options (eFormatDefault),
         m_command_options ()
     {
         CommandArgumentEntry arg;
         CommandArgumentData register_arg;
         
         // Define the first (and only) variant of this arg.
         register_arg.arg_type = eArgTypeRegisterName;
public:
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter) override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             set_indexes.Clear();
             dump_all_sets.Clear();
             alternate_name.Clear();
         }
 
         Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value) override
+        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;
             switch (short_option)
             {
                 case 's':
                     {
                         OptionValueSP value_sp (OptionValueUInt64::Create (option_value, error));

source/Commands/CommandObjectSettings.cpp

 // CommandObjectSettingsSet
 //-------------------------------------------------------------------------
 
 class CommandObjectSettingsSet : public CommandObjectRaw
 {
 public:
     CommandObjectSettingsSet(CommandInterpreter &interpreter)
         : CommandObjectRaw(interpreter, "settings set", "Set the value of the specified debugger setting.", nullptr),
-          m_options(interpreter)
+          m_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentEntry arg2;
         CommandArgumentData var_name_arg;
         CommandArgumentData value_arg;
 
         // Define the first (and only) variant of this arg.
         var_name_arg.arg_type = eArgTypeSettingVariableName;
insert-before or insert-after."
     GetOptions () override
     {
         return &m_options;
     }
     
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
-            m_global (false)
+        CommandOptions() :
+            Options(),
+            m_global(false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'g':
                     m_global = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized options '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_global = false;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
HandleArgumentCompletion (Args &input,
         {
             arg = input.GetArgumentAtIndex(setting_var_idx);
             if (arg && arg[0] != '-')
                 break; // We found our setting variable name index
         }
         if (cursor_index == setting_var_idx)
         {
             // Attempting to complete setting variable name
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
         }
HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eSettingsNameCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();
HandleArgumentCompletion (Args &input,
                               OptionElementVector &opt_element_vector,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eSettingsNameCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
-
         return matches.GetSize();
     }
 
 protected:
     bool
     DoExecute (const char *command, CommandReturnObject &result) override
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
 
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
 
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
 
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
 
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
 
         // Attempting to complete variable name
         if (cursor_index < 2)
-            CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+            CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                                 CommandCompletions::eSettingsNameCompletion,
                                                                 completion_str.c_str(),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 nullptr,
                                                                 word_complete,
                                                                 matches);
 

source/Commands/CommandObjectSource.cpp

 // CommandObjectSourceInfo - debug line entries dumping command
 //----------------------------------------------------------------------
 
 class CommandObjectSourceInfo : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) : Options(interpreter) {}
+        CommandOptions() : Options() {}
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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;
             switch (short_option)
             {
                 case 'l':
                     start_line = StringConvert::ToUInt32(option_arg, 0);
                     if (start_line == 0)
public:
                     break;
 
                 case 'n':
                     symbol_name = option_arg;
                     break;
 
                 case 'a':
                 {
-                    ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
-                    address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                    address = Args::StringToAddress(execution_context,
+                                                    option_arg,
+                                                    LLDB_INVALID_ADDRESS,
+                                                    &error);
                 }
                 break;
                 case 's':
                     modules.push_back(std::string(option_arg));
                     break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             file_spec.Clear();
             file_name.clear();
             symbol_name.clear();
             address = LLDB_INVALID_ADDRESS;
             start_line = 0;
             end_line = 0;
             num_lines = 0;
class CommandObjectSourceInfo : public CommandObjectParsed
     };
 
 public:
     CommandObjectSourceInfo(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "source info", "Display source line information for the current target "
                                                           "process.  Defaults to instruction pointer in current stack "
                                                           "frame.",
                               nullptr, eCommandRequiresTarget),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectSourceInfo() override = default;
 
     Options *
     GetOptions () override
     {

 // CommandObjectSourceList
 //-------------------------------------------------------------------------
 
 class CommandObjectSourceList : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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;
             switch (short_option)
             {
             case 'l':
                 start_line = StringConvert::ToUInt32 (option_arg, 0);
                 if (start_line == 0)
public:
                 break;
                 
             case 'n':
                 symbol_name = option_arg;
                 break;
 
             case 'a':
                 {
-                    ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                    address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                    address = Args::StringToAddress(execution_context,
+                                                    option_arg,
+                                                    LLDB_INVALID_ADDRESS,
+                                                    &error);
                 }
                 break;
             case 's':
                 modules.push_back (std::string (option_arg));
                 break;
             
             case 'b':
                 show_bp_locs = true;
                 break;
             case 'r':
                 reverse = true;
                 break;
            default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             file_spec.Clear();
             file_name.clear();
             symbol_name.clear();
             address = LLDB_INVALID_ADDRESS;
             start_line = 0;
             num_lines = 0;
             show_bp_locs = false;
public:
         bool reverse;
     };
 
 public:
     CommandObjectSourceList(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "source list",
                               "Display source code for the current target process as specified by options.", nullptr,
                               eCommandRequiresTarget),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectSourceList() override = default;
 
     Options *
     GetOptions () override
     {

source/Commands/CommandObjectTarget.cpp

 class CommandObjectTargetCreate : public CommandObjectParsed
 {
 public:
     CommandObjectTargetCreate(CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "target create",
                             "Create a target using the argument as the main executable.",
                             nullptr),
-        m_option_group (interpreter),
+        m_option_group (),
         m_arch_option (),
         m_core_file (LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename, "Fullpath to a core file to use for this target."),
         m_platform_path (LLDB_OPT_SET_1, false, "platform-path", 'P', 0, eArgTypePath, "Path to the remote file to use for this target."),
         m_symbol_file (LLDB_OPT_SET_1, false, "symfile", 's', 0, eArgTypeFilename, "Fullpath to a stand alone debug symbols file for when debug symbols are not in the executable."),
         m_remote_file (LLDB_OPT_SET_1, false, "remote-file", 'r', 0, eArgTypeFilename, "Fullpath to the file on the remote host if debugging remotely."),
         m_add_dependents (LLDB_OPT_SET_1, false, "no-dependents", 'd', "Don't load dependent files when creating the target, just add the specified executable.", true, true)
     {
         CommandArgumentEntry arg;
HandleArgumentCompletion (Args &input,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

 class CommandObjectTargetDelete : public CommandObjectParsed
 {
 public:
     CommandObjectTargetDelete (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "target delete",
                             "Delete one or more targets by target index.",
                             nullptr),
-        m_option_group(interpreter),
+        m_option_group(),
         m_all_option(LLDB_OPT_SET_1, false, "all", 'a', "Delete all targets.", false, true),
         m_cleanup_option(
             LLDB_OPT_SET_1,
             false,
             "clean", 'c',
             "Perform extra cleanup to minimize memory consumption after deleting the target.  "
             "By default, LLDB will keep in memory any modules previously loaded by the target as well "
             "as all of its debug info.  Specifying --clean will unload all of these shared modules and "
class CommandObjectTargetVariable : public CommandObjectParsed
     static const uint32_t SHORT_OPTION_FILE = 0x66696c65;   // 'file'
     static const uint32_t SHORT_OPTION_SHLB = 0x73686c62;   // 'shlb'
 
 public:
     CommandObjectTargetVariable(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "target variable",
                               "Read global variables for the current target, before or while running a process.",
                               nullptr, eCommandRequiresTarget),
-          m_option_group(interpreter),
+          m_option_group(),
           m_option_variable(false), // Don't include frame options
           m_option_format(eFormatDefault),
           m_option_compile_units(LLDB_OPT_SET_1, false, "file", SHORT_OPTION_FILE, 0, eArgTypeFilename,
                                  "A basename or fullpath to a file that contains global variables. This option can be "
                                  "specified multiple times."),
           m_option_shared_libraries(LLDB_OPT_SET_1, false, "shlib", SHORT_OPTION_SHLB, 0, eArgTypeFilename,
                                     "A basename or fullpath to a shared library to use in the search for global "
                                     "variables. This option can be specified multiple times."),
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         // Arguments are the standard module completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eModuleCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();
HandleArgumentCompletion (Args &input,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         // Arguments are the standard source file completer.
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eSourceFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

 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(interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectTargetModulesDumpSymtab() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter),
-        m_sort_order (eSortOrderNone)
+        CommandOptions() :
+        Options(),
+        m_sort_order(eSortOrderNone)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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);
                     break;
 
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_sort_order = eSortOrderNone;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;

 class CommandObjectTargetModulesAdd : public CommandObjectParsed
 {
 public:
     CommandObjectTargetModulesAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules add",
                              "Add a new module to the current target's modules.",
                              "target modules add [<module>]"),
-        m_option_group (interpreter),
+        m_option_group(),
         m_symbol_file (LLDB_OPT_SET_1, false, "symfile", 's', 0, eArgTypeFilename, "Fullpath to a stand alone debug symbols file for when debug symbols are not in the executable.")
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_symbol_file, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
 
     ~CommandObjectTargetModulesAdd() override = default;
HandleArgumentCompletion (Args &input,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

 class CommandObjectTargetModulesLoad : public CommandObjectTargetModulesModuleAutoComplete
 {
 public:
     CommandObjectTargetModulesLoad (CommandInterpreter &interpreter) : 
         CommandObjectTargetModulesModuleAutoComplete (interpreter,
                                                       "target modules load",
                                                       "Set the load addresses for one or more sections in a target module.",
                                                       "target modules load [--file <module> --uuid <uuid>] <sect-name> <address> [<sect-name> <address> ....]"),
-        m_option_group (interpreter),
+        m_option_group(),
         m_file_option (LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName, "Fullpath or basename for module to load.", ""),
         m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, "Set the load address for all sections to be the virtual address in the file plus the offset.", 0)
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 
         m_option_group.Finalize();
     }

 // List images with associated information
 //----------------------------------------------------------------------
 class CommandObjectTargetModulesList : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter),
+        CommandOptions() :
+            Options(),
             m_format_array(),
             m_use_global_module_list (false),
             m_module_addr (LLDB_INVALID_ADDRESS)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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;
             if (short_option == 'g')
             {
                 m_use_global_module_list = true;
             }
             else if (short_option == 'a')
             {
-                ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                m_module_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                m_module_addr = Args::StringToAddress(execution_context,
+                                                      option_arg,
+                                                      LLDB_INVALID_ADDRESS,
+                                                      &error);
             }
             else
             {
                 unsigned long width = 0;
                 if (option_arg)
                     width = strtoul(option_arg, nullptr, 0);
                 m_format_array.push_back(std::make_pair(short_option, width));
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        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
public:
         lldb::addr_t m_module_addr;
     };
 
     CommandObjectTargetModulesList (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target modules list",
                              "List current executable and dependent shared library images.",
                              "target modules list [<cmd-options>]"),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectTargetModulesList() override = default;
 
     Options *
     GetOptions () override
     {
enum
         eLookupTypeFunction,
         eLookupTypeFunctionOrSymbol,
         kNumLookupTypes
     };
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter),
+        CommandOptions() :
+            Options(),
             m_type(eLookupTypeInvalid),
             m_str(),
             m_addr(LLDB_INVALID_ADDRESS)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                 {
-                    ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
                     m_str = option_arg;
                     m_type = eLookupTypeAddress;
-                    m_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                    m_addr = Args::StringToAddress(execution_context,
+                                                   option_arg,
+                                                   LLDB_INVALID_ADDRESS,
+                                                   &error);
                     if (m_addr == LLDB_INVALID_ADDRESS)
                         error.SetErrorStringWithFormat ("invalid address string '%s'", option_arg);
                     break;
                 }
 
                 case 'n':
                     m_str = option_arg;
                     m_type = eLookupTypeFunctionOrSymbol;
                     break;
 
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option %c.", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_type = eLookupTypeInvalid;
             m_str.clear();
             m_addr = LLDB_INVALID_ADDRESS;
         }
 
         const OptionDefinition*
         GetDefinitions () override
CommandObjectTargetModulesShowUnwind (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "target modules show-unwind",
                             "Show synthesized unwind instructions for a function.",
                             nullptr,
                             eCommandRequiresTarget        |
                             eCommandRequiresProcess       |
                             eCommandProcessMustBeLaunched |
                             eCommandProcessMustBePaused   ),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectTargetModulesShowUnwind() override = default;
 
     Options *
     GetOptions () override
     {
enum
         eLookupTypeFunctionOrSymbol,
         eLookupTypeType,
         kNumLookupTypes
     };
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                     {
                         m_type = eLookupTypeAddress;
-                        ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                        m_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                        m_addr = Args::StringToAddress(execution_context,
+                                                       option_arg,
+                                                       LLDB_INVALID_ADDRESS,
+                                                       &error);
                     }
                     break;
 
                 case 'o':
                     m_offset = StringConvert::ToUInt64(option_arg, LLDB_INVALID_ADDRESS);
                     if (m_offset == LLDB_INVALID_ADDRESS)
                         error.SetErrorStringWithFormat ("invalid offset string '%s'", option_arg);
                     break;
public:
                     m_use_regex = true;
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_type = eLookupTypeInvalid;
             m_str.clear();
             m_file.Clear();
             m_addr = LLDB_INVALID_ADDRESS;
             m_offset = 0;
             m_line_number = 0;
             m_use_regex = false;
public:
     };
 
     CommandObjectTargetModulesLookup (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "target modules lookup",
                             "Look up information within executable and dependent shared library images.",
                             nullptr,
                             eCommandRequiresTarget),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData file_arg;
 
         // Define the first (and only) variant of this arg.
         file_arg.arg_type = eArgTypeFilename;
         file_arg.arg_repetition = eArgRepeatStar;
 
LookupInModule (CommandInterpreter &interpreter, Module *module, CommandReturnObject &result, bool &syntax_error)
                     {
                         result.SetStatus(eReturnStatusSuccessFinishResult);
                         return true;
                     }
                 }
                 break;
 
             default:
-                m_options.GenerateOptionUsage (result.GetErrorStream(), this);
+                m_options.GenerateOptionUsage(result.GetErrorStream(), this,
+                                              GetCommandInterpreter()
+                                                .GetDebugger()
+                                                .GetTerminalWidth());
                 syntax_error = true;
                 break;
         }
 
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
 

 class CommandObjectTargetSymbolsAdd : public CommandObjectParsed
 {
 public:
     CommandObjectTargetSymbolsAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target symbols add",
                              "Add a debug symbol file to one of the target's current modules by specifying a path to a debug symbols file, or using the options to specify a module to download symbols for.",
                              "target symbols add [<symfile>]", eCommandRequiresTarget),
-        m_option_group (interpreter),
+        m_option_group(),
         m_file_option (LLDB_OPT_SET_1, false, "shlib", 's', CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Fullpath or basename for module to find debug symbols for."),
         m_current_frame_option (LLDB_OPT_SET_2, false, "frame", 'F', "Locate the debug symbols the currently selected frame.", false, true)
 
     {
         m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_current_frame_option, LLDB_OPT_SET_2, LLDB_OPT_SET_2);
         m_option_group.Finalize();
HandleArgumentCompletion (Args &input,
                               int match_start_point,
                               int max_return_elements,
                               bool &word_complete,
                               StringList &matches) override
     {
         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
         completion_str.erase (cursor_char_position);
 
-        CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
                                                             CommandCompletions::eDiskFileCompletion,
                                                             completion_str.c_str(),
                                                             match_start_point,
                                                             max_return_elements,
                                                             nullptr,
                                                             word_complete,
                                                             matches);
         return matches.GetSize();

 class CommandObjectTargetStopHookAdd :
     public CommandObjectParsed,
     public IOHandlerDelegateMultiline
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter),
+        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;
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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)
             {
                 case 'c':
public:
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option %c.", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_class_name.clear();
             m_function_name.clear();
             m_line_start = 0;
             m_line_end = UINT_MAX;
             m_file_name.clear();
             m_module_name.clear();
             m_func_name_type_mask = eFunctionNameTypeAuto;
public:
     };
 
     CommandObjectTargetStopHookAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "target stop-hook add",
                              "Add a hook to be executed when the target stops.",
                              "target stop-hook add"),
         IOHandlerDelegateMultiline ("DONE", IOHandlerDelegate::Completion::LLDBCommand),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectTargetStopHookAdd() override = default;
 
     Options *
     GetOptions () override
     {

source/Commands/CommandObjectThread.cpp

 //-------------------------------------------------------------------------
 
 class CommandObjectThreadBacktrace : public CommandObjectIterateOverThreads
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'c':
                 {
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_count = UINT32_MAX;
             m_start = 0;
             m_extended_backtrace = false;
         }
 
         const OptionDefinition*
         GetDefinitions () override
public:
 
     CommandObjectThreadBacktrace(CommandInterpreter &interpreter)
         : CommandObjectIterateOverThreads(
               interpreter, "thread backtrace", "Show thread call stacks.  Defaults to the current thread, thread "
                                                "indexes can be specified as arguments.  Use the thread-index \"all\" "
                                                "to see all threads.",
               nullptr, eCommandRequiresProcess | eCommandRequiresThread | eCommandTryTargetAPILock |
                            eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectThreadBacktrace() override = default;
 
     Options *
     GetOptions () override
     {

 };
 
 class CommandObjectThreadStepWithTypeAndScope : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                 {
public:
             default:
                 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                 break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_step_in_avoid_no_debug = eLazyBoolCalculate;
             m_step_out_avoid_no_debug = eLazyBoolCalculate;
             m_run_mode = eOnlyDuringStepping;
 
             // Check if we are in Non-Stop mode
-            lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
+            TargetSP target_sp =
+                execution_context ? execution_context->GetTargetSP() :
+                TargetSP();
             if (target_sp && target_sp->GetNonStopModeEnabled())
                 m_run_mode = eOnlyThisThread;
 
             m_avoid_regexp.clear();
             m_step_in_target.clear();
             m_class_name.clear();
             m_step_count = 1;
             m_end_line = LLDB_INVALID_LINE_NUMBER;
CommandObjectThreadStepWithTypeAndScope (CommandInterpreter &interpreter,
         CommandObjectParsed (interpreter, name, help, syntax,
                              eCommandRequiresProcess       |
                              eCommandRequiresThread        |
                              eCommandTryTargetAPILock      |
                              eCommandProcessMustBeLaunched |
                              eCommandProcessMustBePaused   ),
         m_step_type (step_type),
         m_step_scope (step_scope),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData thread_id_arg;
         
         // Define the first (and only) variant of this arg.
         thread_id_arg.arg_type = eArgTypeThreadID;
         thread_id_arg.arg_repetition = eArgRepeatOptional;
         

 {
 public:
     class CommandOptions : public Options
     {
     public:
         uint32_t m_thread_idx;
         uint32_t m_frame_idx;
 
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_thread_idx(LLDB_INVALID_THREAD_ID),
             m_frame_idx(LLDB_INVALID_FRAME_ID)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                 {
-                    ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                    lldb::addr_t tmp_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+                    lldb::addr_t tmp_addr =
+                        Args::StringToAddress(execution_context, option_arg,
+                                              LLDB_INVALID_ADDRESS, &error);
                     if (error.Success())
                         m_until_addrs.push_back(tmp_addr);
                 }
                 break;
                 case 't':
                     m_thread_idx = StringConvert::ToUInt32 (option_arg, LLDB_INVALID_INDEX32);
                     if (m_thread_idx == LLDB_INVALID_INDEX32)
                     {
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        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*
public:
     };
 
     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 "
                                                            "the current function as a safety measure.",
                               nullptr, eCommandRequiresThread | eCommandTryTargetAPILock |
                                            eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData line_num_arg;
         
         // Define the first (and only) variant of this arg.
         line_num_arg.arg_type = eArgTypeLineNum;
         line_num_arg.arg_repetition = eArgRepeatPlain;
         

 //-------------------------------------------------------------------------
 
 class CommandObjectThreadInfo : public CommandObjectIterateOverThreads
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_json_thread = false;
             m_json_stopinfo = false;
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue(uint32_t option_idx, const char *option_arg,
+                       ExecutionContext *execution_context) override
         {
             const int short_option = m_getopt_table[option_idx].val;
             Error error;
 
             switch (short_option)
             {
                 case 'j':
                     m_json_thread = true;
public:
     };
 
     CommandObjectThreadInfo(CommandInterpreter &interpreter)
         : CommandObjectIterateOverThreads(
               interpreter, "thread info",
               "Show an extended summary of one or more threads.  Defaults to the current thread.", "thread info",
               eCommandRequiresProcess | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
                   eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
         m_add_return = false;
     }
 
     ~CommandObjectThreadInfo() override = default;
 
     Options *
     GetOptions () override

 //-------------------------------------------------------------------------
 
 class CommandObjectThreadReturn : public CommandObjectRaw
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
-            m_from_expression (false)
+        CommandOptions() :
+            Options(),
+            m_from_expression(false)
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'x':
                 {
public:
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_from_expression = false;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
public:
 
     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 to the exiting the current stack "
                            "frame.",
                            "thread return", eCommandRequiresFrame | eCommandTryTargetAPILock |
                                                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData expression_arg;
 
         // Define the first (and only) variant of this arg.
         expression_arg.arg_type = eArgTypeExpression;
         expression_arg.arg_repetition = eArgRepeatOptional;
 

 //-------------------------------------------------------------------------
 
 class CommandObjectThreadJump : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_filenames.Clear();
             m_line_num = 0;
             m_line_offset = 0;
             m_load_addr = LLDB_INVALID_ADDRESS;
             m_force = false;
         }
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        SetOptionValue(uint32_t option_idx, const char *option_arg,
+                       ExecutionContext *execution_context) override
         {
             bool success;
             const int short_option = m_getopt_table[option_idx].val;
             Error error;
 
             switch (short_option)
             {
                 case 'f':
                     m_filenames.AppendIfUnique (FileSpec(option_arg, false));
                     if (m_filenames.GetSize() > 1)
                         return Error("only one source file expected.");
                     break;
                 case 'l':
                     m_line_num = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success || m_line_num == 0)
                         return Error("invalid line number: '%s'.", option_arg);
                     break;
                 case 'b':
                     m_line_offset = StringConvert::ToSInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         return Error("invalid line offset: '%s'.", option_arg);
                     break;
                 case 'a':
-                    {
-                        ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
-                        m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
-                    }
+                    m_load_addr = Args::StringToAddress(execution_context,
+                                                        option_arg,
+                                                        LLDB_INVALID_ADDRESS,
+                                                        &error);
                     break;
                 case 'r':
                     m_force = true;
                     break;
                  default:
                     return Error("invalid short option character '%c'", short_option);
             }
             return error;
CommandObjectThreadJump (CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                           "thread jump",
                           "Sets the program counter to a new address.",
                           "thread jump",
                           eCommandRequiresFrame         |
                           eCommandTryTargetAPILock      |
                           eCommandProcessMustBeLaunched |
                           eCommandProcessMustBePaused   ),
-        m_options (interpreter)
+        m_options()
     {
     }
 
     ~CommandObjectThreadJump() override = default;
 
     Options *
     GetOptions() override
     {

 //-------------------------------------------------------------------------
 
 class CommandObjectThreadPlanList : public CommandObjectIterateOverThreads
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter)
+        CommandOptions() :
+            Options()
         {
             // Keep default values of all options in one place: OptionParsingStarting ()
-            OptionParsingStarting ();
+            OptionParsingStarting(nullptr);
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'i':
                     m_internal = true;
                     break;
                 case 'v':
                     m_verbose = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_verbose = false;
             m_internal = false;
         }
 
         const OptionDefinition*
         GetDefinitions () override
         {
public:
 
     CommandObjectThreadPlanList(CommandInterpreter &interpreter)
         : CommandObjectIterateOverThreads(
               interpreter, "thread plan list",
               "Show thread plans for one or more threads.  If no threads are specified, show the "
               "current thread.  Use the thread-index \"all\" to see all threads.",
               nullptr, eCommandRequiresProcess | eCommandRequiresThread | eCommandTryTargetAPILock |
                            eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectThreadPlanList() override = default;
 
     Options *
     GetOptions () override
     {

source/Commands/CommandObjectType.cpp

class CommandObjectTypeSummaryAdd :
     public CommandObjectParsed,
     public IOHandlerDelegateMultiline
 {
 private:
     class CommandOptions : public Options
     {
     public:
         CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override;
+        SetOptionValue(uint32_t option_idx, const char *option_arg,
+                       ExecutionContext *execution_context) override;
         
         void
-        OptionParsingStarting () override;
+        OptionParsingStarting(ExecutionContext *execution_context) override;
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         // Options table: Required for subclasses of Options.

 class CommandObjectTypeSynthAdd :
     public CommandObjectParsed,
     public IOHandlerDelegateMultiline
 {
 private:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter)
+        CommandOptions() :
+            Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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)
             {
                 case 'C':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_cascade = true;
             m_class_name = "";
             m_skip_pointers = false;
             m_skip_references = false;
             m_category = "default";
             is_class_based = false;
             handwrite_python = false;
public:
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter) override
+        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 (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value) override
+        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;
             bool success;
             
             switch (short_option)
             {
                 case 'C':
private:
     }
     
 public:
     CommandObjectTypeFormatAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "type format add",
                             "Add a new formatting style for a type.",
                             nullptr),
-        m_option_group (interpreter),
-        m_format_options (eFormatInvalid),
-        m_command_options ()
+        m_option_group(),
+        m_format_options(eFormatInvalid),
+        m_command_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);

 }
 
 class CommandObjectTypeFormatterDelete : public CommandObjectParsed
 {
 protected:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                     m_delete_all = true;
                     break;
                 case 'w':
                     m_category = std::string(option_arg);
                     break;
                 case 'l':
                     m_language = Language::GetLanguageTypeFromString(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_delete_all = false;
             m_category = "default";
             m_language = lldb::eLanguageTypeUnknown;
         }
         
         const OptionDefinition*
         GetDefinitions () override
public:
     CommandObjectTypeFormatterDelete (CommandInterpreter &interpreter,
                                       uint32_t formatter_kind_mask,
                                       const char* name,
                                       const char* help) :
         CommandObjectParsed(interpreter,
                             name,
                             help,
                             nullptr),
-        m_options(interpreter),
+        m_options(),
         m_formatter_kind_mask(formatter_kind_mask)
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlain;
         

 };
 
 class CommandObjectTypeFormatterClear : public CommandObjectParsed
 {
 private:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'a':
                     m_delete_all = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_delete_all = false;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
public:
     CommandObjectTypeFormatterClear (CommandInterpreter &interpreter,
                                      uint32_t formatter_kind_mask,
                                      const char* name,
                                      const char* help) :
         CommandObjectParsed(interpreter,
                             name,
                             help,
                             nullptr),
-        m_options(interpreter),
+        m_options(),
         m_formatter_kind_mask(formatter_kind_mask)
     {
     }
 
     ~CommandObjectTypeFormatterClear() override = default;
 
 protected:
     virtual void

 template <typename FormatterType>
 class CommandObjectTypeFormatterList : public CommandObjectParsed
 {
     typedef typename FormatterType::SharedPointer FormatterSharedPointer;
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter),
+        CommandOptions() :
+        Options(),
         m_category_regex("",""),
         m_category_language(lldb::eLanguageTypeUnknown, lldb::eLanguageTypeUnknown)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'w':
                     m_category_regex.SetCurrentValue(option_arg);
                     m_category_regex.SetOptionWasSet();
                     break;
                 case 'l':
                     error = m_category_language.SetValueFromString(option_arg);
                     if (error.Success())
                         m_category_language.SetOptionWasSet();
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_category_regex.Clear();
             m_category_language.Clear();
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {

 public:
     CommandObjectTypeFormatterList (CommandInterpreter &interpreter,
                                     const char* name,
                                     const char* help) :
         CommandObjectParsed(interpreter,
                             name,
                             help,
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatOptional;
         
         type_arg.push_back (type_style_arg);

 
 //-------------------------------------------------------------------------
 // CommandObjectTypeSummaryAdd
 //-------------------------------------------------------------------------
 
 #endif // LLDB_DISABLE_PYTHON
 
 Error
-CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+CommandObjectTypeSummaryAdd::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;
     bool success;
     
     switch (short_option)
     {
         case 'C':
switch (short_option)
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
     
     return error;
 }
 
 void
-CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting ()
+CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
     m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
     m_flags.SetShowMembersOneLiner(false).SetSkipPointers(false).SetSkipReferences(false).SetHideItemNames(false);
 
     m_regex = false;
     m_name.Clear();
     m_python_script = "";
     m_python_function = "";

 // CommandObjectTypeCategoryDefine
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeCategoryDefine : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter),
+        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) override
+        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 'e':
                     m_define_enabled.SetValueFromString("true");
                     break;
                 case 'l':
                     error = m_cate_language.SetValueFromString(option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_define_enabled.Clear();
             m_cate_language.Clear();
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
class CommandObjectTypeCategoryDefine : public CommandObjectParsed
     }
 
 public:
     CommandObjectTypeCategoryDefine (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "type category define",
                             "Define a new category as a source of formatters.",
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);

 // CommandObjectTypeCategoryEnable
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeCategoryEnable : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'l':
                     if (option_arg)
                     {
                         m_language = Language::GetLanguageTypeFromString(option_arg);
                         if (m_language == lldb::eLanguageTypeUnknown)
                             error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg);
                     }
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_language = lldb::eLanguageTypeUnknown;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
class CommandObjectTypeCategoryEnable : public CommandObjectParsed
     }
     
 public:
     CommandObjectTypeCategoryEnable (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "type category enable",
                             "Enable a category as a source of formatters.",
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);

 // CommandObjectTypeCategoryDisable
 //-------------------------------------------------------------------------
 
 class CommandObjectTypeCategoryDisable : public CommandObjectParsed
 {
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'l':
                     if (option_arg)
                     {
                         m_language = Language::GetLanguageTypeFromString(option_arg);
                         if (m_language == lldb::eLanguageTypeUnknown)
                             error.SetErrorStringWithFormat ("unrecognized language '%s'", option_arg);
                     }
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_language = lldb::eLanguageTypeUnknown;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
class CommandObjectTypeCategoryDisable : public CommandObjectParsed
     }
 
 public:
     CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "type category disable",
                             "Disable a category as a source of formatters.",
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);

 }
     
 CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd (CommandInterpreter &interpreter) :
     CommandObjectParsed(interpreter,
                         "type synthetic add",
                         "Add a new synthetic provider for a type.",
                         nullptr),
     IOHandlerDelegateMultiline ("DONE"),
-    m_options (interpreter)
+    m_options()
 {
     CommandArgumentEntry type_arg;
     CommandArgumentData type_style_arg;
     
     type_style_arg.arg_type = eArgTypeName;
     type_style_arg.arg_repetition = eArgRepeatPlus;
     
     type_arg.push_back (type_style_arg);

 class CommandObjectTypeFilterAdd : public CommandObjectParsed
 {
 private:
     class CommandOptions : public Options
     {
         typedef std::vector<std::string> option_vector;
 
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options (interpreter)
+        CommandOptions() :
+        Options()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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)
             {
                 case 'C':
public:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_cascade = true;
             m_skip_pointers = false;
             m_skip_references = false;
             m_category = "default";
             m_expr_paths.clear();
             has_child_list = false;
             m_regex = false;
private:
     }
 
 public:
     CommandObjectTypeFilterAdd (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "type filter add",
                             "Add a new filter for a type.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry type_arg;
         CommandArgumentData type_style_arg;
         
         type_style_arg.arg_type = eArgTypeName;
         type_style_arg.arg_repetition = eArgRepeatPlus;
         
         type_arg.push_back (type_style_arg);
public:
         
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_option_table;
         }
         
         Error
-        SetOptionValue (CommandInterpreter &interpreter,
-                        uint32_t option_idx,
-                        const char *option_value) override
+        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;
             
             switch (short_option)
             {
                 case 'h':
                     m_show_help = true;
                     break;
                     
                 case 'l':
                     m_language = Language::GetLanguageTypeFromString(option_value);
                     break;
                     
                 default:
                     error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting (CommandInterpreter &interpreter) override
+        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:
     CommandObjectTypeLookup (CommandInterpreter &interpreter) :
     CommandObjectRaw (interpreter,
                       "type lookup",
                       "Lookup types and declarations in the current target, following language-specific naming conventions.",
                       "type lookup <type-specifier>",
                       eCommandRequiresTarget),
-    m_option_group(interpreter),
+    m_option_group(),
     m_command_options()
     {
         m_option_group.Append(&m_command_options);
         m_option_group.Finalize();
     }
 
     ~CommandObjectTypeLookup() override = default;
 
public:
     bool
     DoExecute (const char *raw_command_line, CommandReturnObject &result) override
     {
         if (!raw_command_line || !raw_command_line[0])
         {
             result.SetError("type lookup cannot be invoked without a type name as argument");
             return false;
         }
-        
-        m_option_group.NotifyOptionParsingStarting();
+        auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+        m_option_group.NotifyOptionParsingStarting(&exe_ctx);
         
         const char * name_of_type = nullptr;
         
         if (raw_command_line[0] == '-')
         {
             // We have some options and these options MUST end with --.
             const char *end_options = nullptr;
             const char *s = raw_command_line;
DoExecute (const char *raw_command_line, CommandReturnObject &result) override
             }
             
             if (end_options)
             {
                 Args args (llvm::StringRef(raw_command_line, end_options - raw_command_line));
                 if (!ParseOptions (args, result))
                     return false;
                 
-                Error error (m_option_group.NotifyOptionParsingFinished());
+                Error error(m_option_group.NotifyOptionParsingFinished(
+                                                                     &exe_ctx));
                 if (error.Fail())
                 {
                     result.AppendError (error.AsCString());
                     result.SetStatus (eReturnStatusFailed);
                     return false;
                 }
             }
         }
         if (nullptr == name_of_type)
             name_of_type = raw_command_line;
         
-        TargetSP target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
-        const bool fill_all_in = true;
-        ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
+        // TargetSP target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
+        // const bool fill_all_in = true;
+        // ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
         ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();
         
         bool any_found = false;
         
         std::vector<Language*> languages;
         
         bool is_global_search = false;
 

source/Commands/CommandObjectWatchpoint.cpp

 class CommandObjectWatchpointList : public CommandObjectParsed
 {
 public:
     CommandObjectWatchpointList (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "watchpoint list",
                             "List all watchpoints at configurable levels of detail.",
                             nullptr),
-        m_options(interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
     ~CommandObjectWatchpointList() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options(interpreter),
+        CommandOptions() :
+            Options(),
             m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to brief descriptions
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'b':
                     m_level = lldb::eDescriptionLevelBrief;
                     break;
                 case 'f':
                     m_level = lldb::eDescriptionLevelFull;
                     break;
                 case 'v':
                     m_level = lldb::eDescriptionLevelVerbose;
                     break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_level = lldb::eDescriptionLevelFull;
         }
 
         const OptionDefinition *
         GetDefinitions () override
         {
             return g_option_table;

 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 (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back(arg);
     }
 
     ~CommandObjectWatchpointIgnore() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_ignore_count (0)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'i':
                     m_ignore_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0);
                     if (m_ignore_count == UINT32_MAX)
                        error.SetErrorStringWithFormat ("invalid ignore count '%s'", option_arg);
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_ignore_count = 0;
         }
 
         const OptionDefinition *
         GetDefinitions () override
         {
             return g_option_table;

 public:
     CommandObjectWatchpointModify (CommandInterpreter &interpreter) :
         CommandObjectParsed(interpreter,
                             "watchpoint modify",
                             "Modify the options on a watchpoint or set of watchpoints in the executable.  "
                             "If no watchpoint is specified, act on the last created watchpoint.  "
                             "Passing an empty argument clears the modification.",
                             nullptr),
-        m_options (interpreter)
+        m_options()
     {
         CommandArgumentEntry arg;
         CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
         // Add the entry for the first argument for this command to the object's arguments vector.
         m_arguments.push_back (arg);   
     }
 
     ~CommandObjectWatchpointModify() override = default;
 
     Options *
     GetOptions () override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_condition (),
             m_condition_passed (false)
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'c':
                     if (option_arg != nullptr)
                         m_condition.assign (option_arg);
                     else
                         m_condition.clear();
                     m_condition_passed = true;
                     break;
                 default:
                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
                     break;
             }
 
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_condition.clear();
             m_condition_passed = false;
         }
         
         const OptionDefinition*
         GetDefinitions () override
         {
CommandObjectWatchpointSetVariable (CommandInterpreter &interpreter) :
                             "Note that there are limited hardware resources for watchpoints. "
                             "If watchpoint setting fails, consider disable/delete existing ones "
                             "to free up resources.",
                             nullptr,
                             eCommandRequiresFrame         |
                             eCommandTryTargetAPILock      |
                             eCommandProcessMustBeLaunched |
                             eCommandProcessMustBePaused   ),
-        m_option_group (interpreter),
+        m_option_group(),
         m_option_watchpoint ()
     {
         SetHelpLong(
 R"(
 Examples:
 
 (lldb) watchpoint set variable -w read_write my_global_var
 
CommandObjectWatchpointSetExpression (CommandInterpreter &interpreter) :
                          "Note that there are limited hardware resources for watchpoints. "
                          "If watchpoint setting fails, consider disable/delete existing ones "
                          "to free up resources.",
                          nullptr,
                          eCommandRequiresFrame         |
                          eCommandTryTargetAPILock      |
                          eCommandProcessMustBeLaunched |
                          eCommandProcessMustBePaused   ),
-        m_option_group (interpreter),
+        m_option_group(),
         m_option_watchpoint ()
     {
         SetHelpLong(
 R"(
 Examples:
 
 (lldb) watchpoint set expression -w write -s 1 -- foo + 32
 
(lldb) watchpoint set expression -w write -s 1 -- foo + 32
     {
         return &m_option_group;
     }
 
 protected:
     bool
     DoExecute (const char *raw_command, CommandReturnObject &result) override
     {
-        m_option_group.NotifyOptionParsingStarting(); // This is a raw command, so notify the option group
+        auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+        m_option_group.NotifyOptionParsingStarting(&exe_ctx); // This is a raw command, so notify the option group
         
         Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
         StackFrame *frame = m_exe_ctx.GetFramePtr();
 
         Args command(raw_command);
         const char *expr = nullptr;
         if (raw_command[0] == '-')
         {
DoExecute (const char *raw_command, CommandReturnObject &result) override
             }
             
             if (end_options)
             {
                 Args args (llvm::StringRef(raw_command, end_options - raw_command));
                 if (!ParseOptions (args, result))
                     return false;
                 
-                Error error (m_option_group.NotifyOptionParsingFinished());
+                Error error(m_option_group.NotifyOptionParsingFinished(
+                                                                     &exe_ctx));
                 if (error.Fail())
                 {
                     result.AppendError (error.AsCString());
                     result.SetStatus (eReturnStatusFailed);
                     return false;
                 }
             }
         }

source/Commands/CommandObjectWatchpointCommand.cpp

class CommandObjectWatchpointCommandAdd :
     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),
           IOHandlerDelegateMultiline("DONE", IOHandlerDelegate::Completion::LLDBCommand),
-          m_options(interpreter)
+          m_options()
     {
         SetHelpLong (
 R"(
 General information about entering watchpoint commands
 ------------------------------------------------------
 
 )" "This command will prompt for commands to be executed when the specified \
 watchpoint is hit.  Each command is typed on its own line following the '> ' \
WatchpointOptionsCallbackFunction (void *baton,
            }
         }
         return ret_value;
     }    
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-            Options (interpreter),
+        CommandOptions() :
+            Options(),
             m_use_commands (false),
             m_use_script_language (false),
             m_script_language (eScriptLanguageNone),
             m_use_one_liner (false),
             m_one_liner(),
             m_function_name()
         {
         }
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue (uint32_t option_idx, const char *option_arg) override
+        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 'o':
                 m_use_one_liner = true;
public:
 
             default:
                 break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting () override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_use_commands = true;
             m_use_script_language = false;
             m_script_language = eScriptLanguageNone;
 
             m_use_one_liner = false;
             m_stop_on_error = true;
             m_one_liner.clear();

source/Expression/REPL.cpp

 using namespace lldb_private;
 
 REPL::REPL(LLVMCastKind kind, Target &target) :
     m_target(target),
     m_kind(kind)
 {
     // Make sure all option values have sane defaults
     Debugger &debugger = m_target.GetDebugger();
-    CommandInterpreter &ci = debugger.GetCommandInterpreter();
-    m_format_options.OptionParsingStarting(ci);
-    m_varobj_options.OptionParsingStarting(ci);
-    m_command_options.OptionParsingStarting(ci);
+    auto exe_ctx = debugger.GetCommandInterpreter().GetExecutionContext();
+    m_format_options.OptionParsingStarting(&exe_ctx);
+    m_varobj_options.OptionParsingStarting(&exe_ctx);
+    m_command_options.OptionParsingStarting(&exe_ctx);
     
     // Default certain settings for REPL regardless of the global settings.
     m_command_options.unwind_on_error = false;
     m_command_options.ignore_breakpoints = false;
     m_command_options.debug = false;
 }
 
 REPL::~REPL() = default;

source/Interpreter/Args.cpp

if (argv)
         }
     }
     
     UpdateArgvFromArgs();
 }
 
 
 Error
-Args::ParseOptions (Options &options)
+Args::ParseOptions (Options &options, ExecutionContext *execution_context,
+                    PlatformSP platform_sp, bool require_validation)
 {
     StreamString sstr;
     Error error;
     Option *long_options = options.GetLongOptions();
     if (long_options == nullptr)
     {
         error.SetErrorStringWithFormat("invalid long options");
         return error;
while (1)
                     break;
                 }
             }
         }
         // Call the callback with the option
         if (long_options_index >= 0 && long_options[long_options_index].definition)
         {
             const OptionDefinition *def = long_options[long_options_index].definition;
-            CommandInterpreter &interpreter = options.GetInterpreter();
+
+            if (!platform_sp)
+            {
+                // User did not pass in an explicit platform.  Try to grab
+                // from the execution context.
+                TargetSP target_sp = execution_context ?
+                    execution_context->GetTargetSP() : TargetSP();
+                platform_sp = target_sp ?
+                    target_sp->GetPlatform() : PlatformSP();
+            }
             OptionValidator *validator = def->validator;
-            if (validator && !validator->IsValid(*interpreter.GetPlatform(true), interpreter.GetExecutionContext()))
+
+            if (!platform_sp && require_validation)
             {
-                error.SetErrorStringWithFormat("Option \"%s\" invalid.  %s", def->long_option, def->validator->LongConditionString());
+                // Caller requires validation but we cannot validate as we
+                // don't have the mandatory platform against which to
+                // validate.
+                error.SetErrorString("cannot validate options: "
+                                     "no platform available");
+                return error;
             }
-            else
+
+            bool validation_failed = false;
+            if (platform_sp)
             {
-                error = options.SetOptionValue(long_options_index,
-                                               (def->option_has_arg == OptionParser::eNoArgument) ? nullptr : OptionParser::GetOptionArgument());
+                // Ensure we have an execution context, empty or not.
+                ExecutionContext dummy_context;
+                ExecutionContext *exe_ctx_p =
+                    execution_context ? execution_context : &dummy_context;
+                if (validator && !validator->IsValid(*platform_sp, *exe_ctx_p))
+                {
+                    validation_failed = true;
+                    error.SetErrorStringWithFormat("Option \"%s\" invalid.  %s", def->long_option, def->validator->LongConditionString());
                 }
             }
+
+            // As long as validation didn't fail, we set the option value.
+            if (!validation_failed)
+                error = options.SetOptionValue(long_options_index,
+                                                       (def->option_has_arg == OptionParser::eNoArgument) ? nullptr : OptionParser::GetOptionArgument(),
+                                                       execution_context);
+        }
         else
         {
             error.SetErrorStringWithFormat("invalid option with value '%i'", val);
         }
         if (error.Fail())
             break;
     }
 

source/Interpreter/CommandAlias.cpp

 //===-- CommandAlias.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/CommandAlias.h"
 
 #include "llvm/Support/ErrorHandling.h"
 
 #include "lldb/Core/StreamString.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static bool
ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp,
     std::string options_string (options_args);
     Args args (options_args);
     CommandReturnObject result;
     // Check to see if the command being aliased can take any command options.
     Options *options = cmd_obj_sp->GetOptions ();
     if (options)
     {
         // See if any options were specified as part of the alias;  if so, handle them appropriately.
-        options->NotifyOptionParsingStarting ();
+        ExecutionContext exe_ctx =
+            cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
+        options->NotifyOptionParsingStarting(&exe_ctx);
         args.Unshift ("dummy_arg");
         args.ParseAliasOptions (*options, result, option_arg_vector, options_string);
         args.Shift ();
         if (result.Succeeded())
             options->VerifyPartialOptions (result);
         if (!result.Succeeded() && result.GetStatus() != lldb::eReturnStatusStarted)
         {
             result.AppendError ("Unable to create requested alias.\n");

source/Interpreter/CommandObject.cpp

(
     CommandReturnObject &result
 )
 {
     // See if the subclass has options?
     Options *options = GetOptions();
     if (options != nullptr)
     {
         Error error;
-        options->NotifyOptionParsingStarting();
+
+        auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+        options->NotifyOptionParsingStarting(&exe_ctx);
 
         // ParseOptions calls getopt_long_only, which always skips the zero'th item in the array and starts at position 1,
         // so we need to push a dummy value into position zero.
         args.Unshift("dummy_string");
-        error = args.ParseOptions (*options);
+        const bool require_validation = true;
+        error = args.ParseOptions(*options, &exe_ctx,
+                                  GetCommandInterpreter().GetPlatform(true),
+                                  require_validation);
 
         // The "dummy_string" will have already been removed by ParseOptions,
         // so no need to remove it.
 
         if (error.Success())
-            error = options->NotifyOptionParsingFinished();
+            error = options->NotifyOptionParsingFinished(&exe_ctx);
 
         if (error.Success())
         {
             if (options->VerifyOptions (result))
                 return true;
         }
         else
         {
             const char *error_cstr = error.AsCString();
             if (error_cstr)
             {
                 // We got an error string, lets use that
                 result.AppendError(error_cstr);
             }
             else
             {
                 // No error string, output the usage information into result
-                options->GenerateOptionUsage (result.GetErrorStream(), this);
+                options->GenerateOptionUsage(result.GetErrorStream(), this,
+                                             GetCommandInterpreter()
+                                                .GetDebugger()
+                                                .GetTerminalWidth());
             }
         }
         result.SetStatus (eReturnStatusFailed);
         return false;
     }
     return true;
 }
 
else
 
             bool handled_by_options;
             handled_by_options = cur_options->HandleOptionCompletion (input,
                                                                       opt_element_vector,
                                                                       cursor_index,
                                                                       cursor_char_position,
                                                                       match_start_point,
                                                                       max_return_elements,
+                                                                      GetCommandInterpreter(),
                                                                       word_complete,
                                                                       matches);
             if (handled_by_options)
                 return matches.GetSize();
         }
 
         // If we got here, the last word is not an option or an option argument.
         return HandleArgumentCompletion (input,
CommandObject::HelpTextContainsWord (const char *search_word,
     else if (search_syntax && syntax_help && strcasestr (syntax_help, search_word))
         found_word = true;
 
     if (!found_word
         && search_options
         && GetOptions() != nullptr)
     {
         StreamString usage_help;
-        GetOptions()->GenerateOptionUsage (usage_help, this);
+        GetOptions()->GenerateOptionUsage(usage_help, this,
+                                          GetCommandInterpreter()
+                                            .GetDebugger().GetTerminalWidth());
         if (usage_help.GetSize() > 0)
         {
             const char *usage_text = usage_help.GetData();
             if (strcasestr (usage_text, search_word))
               found_word = true;
         }
     }
 
if (WantsRawCommandString())
         interpreter.OutputFormattedHelpText(output_strm, "", "", help_text.c_str(), 1);
     }
     else
         interpreter.OutputFormattedHelpText(output_strm, "", "", GetHelp(), 1);
     output_strm.Printf("\nSyntax: %s\n", GetSyntax());
     Options *options = GetOptions();
     if (options != nullptr)
     {
-        options->GenerateOptionUsage(output_strm, this);
+        options->GenerateOptionUsage(output_strm, this,
+                                     GetCommandInterpreter()
+                                        .GetDebugger().GetTerminalWidth());
     }
     const char *long_help = GetHelpLong();
     if ((long_help != nullptr) && (strlen(long_help) > 0))
     {
         FormatLongHelpText(output_strm, long_help);
     }
     if (!IsDashDashCommand() && options && options->NumCommandOptions() > 0)
     {

source/Interpreter/CommandObjectRegexCommand.cpp

CommandObjectRegexCommand::HandleCompletion (Args &input,
                                              int match_start_point,
                                              int max_return_elements,
                                              bool &word_complete,
                                              StringList &matches)
 {
     if (m_completion_type_mask)
     {
         std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
-        CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+        CommandCompletions::InvokeCommonCompletionCallbacks (GetCommandInterpreter(),
                                                              m_completion_type_mask,
                                                              completion_str.c_str(),
                                                              match_start_point,
                                                              max_return_elements,
                                                              nullptr,
                                                              word_complete,
                                                              matches);
         return matches.GetSize();
     }
     else
     {
         matches.Clear();
         word_complete = false;
     }
     return 0;
 }

source/Interpreter/OptionGroupArchitecture.cpp

if (m_arch_str.empty())
         arch.Clear();
     else
         arch.SetTriple(m_arch_str.c_str(), platform);
     return arch.IsValid();
 }
 
 
 Error
-OptionGroupArchitecture::SetOptionValue (CommandInterpreter &interpreter,
-                                 uint32_t option_idx,
-                                 const char *option_arg)
+OptionGroupArchitecture::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;
 
     switch (short_option)
     {
         case 'a':
             m_arch_str.assign (option_arg);
             break;
 
         default:
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
 
     return error;
 }
 
 void
-OptionGroupArchitecture::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupArchitecture::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
     m_arch_str.clear();
 }
 

source/Interpreter/OptionGroupBoolean.cpp

OptionGroupBoolean::OptionGroupBoolean (uint32_t usage_mask,
     m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupBoolean::~OptionGroupBoolean ()
 {
 }
 
 Error
-OptionGroupBoolean::SetOptionValue (CommandInterpreter &interpreter,
-                                    uint32_t option_idx,
-                                    const char *option_arg)
+OptionGroupBoolean::SetOptionValue(uint32_t option_idx,
+                                   const char *option_arg,
+                                   ExecutionContext *execution_context)
 {
     Error error;
     if (m_option_definition.option_has_arg == OptionParser::eNoArgument)
     {
         // Not argument, toggle the default value and mark the option as having been set
         m_value.SetCurrentValue (!m_value.GetDefaultValue());
         m_value.SetOptionWasSet ();
     }
     else
     {
         error = m_value.SetValueFromString (option_arg);
     }
     return error;
 }
 
 void
-OptionGroupBoolean::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupBoolean::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_value.Clear();
 }

source/Interpreter/OptionGroupFile.cpp

OptionGroupFile::OptionGroupFile (uint32_t usage_mask,
     m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupFile::~OptionGroupFile ()
 {
 }
 
 Error
-OptionGroupFile::SetOptionValue (CommandInterpreter &interpreter,
-                                 uint32_t option_idx,
-                                 const char *option_arg)
+OptionGroupFile::SetOptionValue(uint32_t option_idx,
+                                const char *option_arg,
+                                ExecutionContext *execution_context)
 {
     Error error (m_file.SetValueFromString (option_arg));
     return error;
 }
 
 void
-OptionGroupFile::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFile::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_file.Clear();
 }
 
 
 OptionGroupFileList::OptionGroupFileList (uint32_t usage_mask,
                                           bool required,
                                           const char *long_option, 
OptionGroupFileList::OptionGroupFileList (uint32_t usage_mask,
     m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupFileList::~OptionGroupFileList ()
 {
 }
 
 Error
-OptionGroupFileList::SetOptionValue (CommandInterpreter &interpreter,
-                                     uint32_t option_idx,
-                                     const char *option_arg)
+OptionGroupFileList::SetOptionValue(uint32_t option_idx,
+                                    const char *option_arg,
+                                    ExecutionContext *execution_context)
 {
     Error error (m_file_list.SetValueFromString (option_arg));
     return error;
 }
 
 void
-OptionGroupFileList::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFileList::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_file_list.Clear();
 }

source/Interpreter/OptionGroupFormat.cpp

 
 const OptionDefinition *
 OptionGroupFormat::GetDefinitions ()
 {
     return g_option_table;
 }
 
 Error
-OptionGroupFormat::SetOptionValue (CommandInterpreter &interpreter,
-                                   uint32_t option_idx,
-                                   const char *option_arg)
+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;
 
     switch (short_option)
     {
         case 'f':
             error = m_format.SetValueFromString (option_arg);
switch (short_option)
                         gdb_format_cstr = end;  // We have a valid count, advance the string position
                     else
                         count = 0;
                 }
 
                 Format format = eFormatDefault;
                 uint32_t byte_size = 0;
                 
-                while (ParserGDBFormatLetter (interpreter, gdb_format_cstr[0], format, byte_size))
+                while (ParserGDBFormatLetter (execution_context,
+                                              gdb_format_cstr[0], format,
+                                              byte_size))
                 {
                     ++gdb_format_cstr;
                 }
                 
                 // We the first character of the "gdb_format_cstr" is not the 
                 // NULL terminator, we didn't consume the entire string and 
                 // something is wrong. Also, if none of the format, size or count
                 // was specified correctly, then abort.
                 if (gdb_format_cstr[0] || (format == eFormatInvalid && byte_size == 0 && count == 0))
                 {
                     // Nothing got set correctly
                     error.SetErrorStringWithFormat ("invalid gdb format string '%s'", option_arg);
                     return error;
                 }
 
                 // At least one of the format, size or count was set correctly.
                 // Anything that wasn't set correctly should be set to the
                 // previous default
                 if (format == eFormatInvalid)
-                    ParserGDBFormatLetter (interpreter, m_prev_gdb_format, format, byte_size);
+                    ParserGDBFormatLetter (execution_context, m_prev_gdb_format,
+                                           format, byte_size);
                 
                 const bool byte_size_enabled = m_byte_size.GetDefaultValue() < UINT64_MAX;
                 const bool count_enabled = m_count.GetDefaultValue() < UINT64_MAX;
                 if (byte_size_enabled)
                 {
                     // Byte size is enabled
                     if (byte_size == 0)
-                        ParserGDBFormatLetter (interpreter, m_prev_gdb_size, format, byte_size);
+                        ParserGDBFormatLetter (execution_context, m_prev_gdb_size, format, byte_size);
                 }
                 else
                 {
                     // Byte size is disabled, make sure it wasn't specified
                     // but if this is an address, it's actually necessary to
                     // specify one so don't error out
                     if (byte_size > 0 && format != lldb::eFormatAddressInfo)
                     {
switch (short_option)
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
 
     return error;
 }
 
 bool
-OptionGroupFormat::ParserGDBFormatLetter (CommandInterpreter &interpreter, char format_letter, Format &format, uint32_t &byte_size)
+OptionGroupFormat::ParserGDBFormatLetter(ExecutionContext *execution_context,
+                                         char format_letter, Format &format,
+                                         uint32_t &byte_size)
 {
     m_has_gdb_format = true;
     switch (format_letter)
     {
         case 'o': format = eFormatOctal;        m_prev_gdb_format = format_letter; return true; 
         case 'x': format = eFormatHex;          m_prev_gdb_format = format_letter; return true;
         case 'd': format = eFormatDecimal;      m_prev_gdb_format = format_letter; return true;
         case 'u': format = eFormatUnsigned;     m_prev_gdb_format = format_letter; return true;
         case 't': format = eFormatBinary;       m_prev_gdb_format = format_letter; return true;
         case 'f': format = eFormatFloat;        m_prev_gdb_format = format_letter; return true;
         case 'a': format = eFormatAddressInfo;
         {
-            ExecutionContext exe_ctx(interpreter.GetExecutionContext());
-            Target *target = exe_ctx.GetTargetPtr();
-            if (target)
-                byte_size = target->GetArchitecture().GetAddressByteSize();
+            TargetSP target_sp = execution_context ?
+                execution_context->GetTargetSP() : TargetSP();
+            if (target_sp)
+                byte_size = target_sp->GetArchitecture().GetAddressByteSize();
             m_prev_gdb_format = format_letter;
             return true;
         }
         case 'i': format = eFormatInstruction;  m_prev_gdb_format = format_letter; return true;
         case 'c': format = eFormatChar;         m_prev_gdb_format = format_letter; return true;
         case 's': format = eFormatCString;      m_prev_gdb_format = format_letter; return true;
         case 'T': format = eFormatOSType;       m_prev_gdb_format = format_letter; return true;
         case 'A': format = eFormatHexFloat;     m_prev_gdb_format = format_letter; return true;
switch (format_letter)
             
             break; 
         default:  break;
     }
     return false;
 }
 
 void
-OptionGroupFormat::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFormat::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_format.Clear();
     m_byte_size.Clear();
     m_count.Clear();
     m_has_gdb_format = false;
 }

source/Interpreter/OptionGroupOutputFile.cpp

 
 const OptionDefinition *
 OptionGroupOutputFile::GetDefinitions ()
 {
     return g_option_table;
 }
 
 Error
-OptionGroupOutputFile::SetOptionValue (CommandInterpreter &interpreter,
-                                       uint32_t option_idx,
-                                       const char *option_arg)
+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;
 
     switch (short_option)
     {
         case 'o':
             error = m_file.SetValueFromString (option_arg);
             break;
 
         case SHORT_OPTION_APND:
             m_append.SetCurrentValue(true);
             break;
 
         default:
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
 
     return error;
 }
 
 void
-OptionGroupOutputFile::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupOutputFile::OptionParsingStarting(
+                                            ExecutionContext *execution_context)
 {
     m_file.Clear();
     m_append.Clear();
 }

source/Interpreter/OptionGroupPlatform.cpp

if (platform_sp)
         if (m_sdk_build)
             platform_sp->SetSDKBuild (m_sdk_build);
     }
 
     return platform_sp;
 }
 
 void
-OptionGroupPlatform::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatform::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_platform_name.clear();
     m_sdk_sysroot.Clear();
     m_sdk_build.Clear();
     m_os_version_major = UINT32_MAX;
     m_os_version_minor = UINT32_MAX;
     m_os_version_update = UINT32_MAX;
 }

 {
     if (m_include_platform_option)
         return llvm::array_lengthof(g_option_table);
     return llvm::array_lengthof(g_option_table) - 1;
 }
 
 
 Error
-OptionGroupPlatform::SetOptionValue (CommandInterpreter &interpreter,
-                                     uint32_t option_idx,
-                                     const char *option_arg)
+OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
+                                    const char *option_arg,
+                                    ExecutionContext *execution_context)
 {
     Error error;
     if (!m_include_platform_option)
         ++option_idx;
     
     const int short_option = g_option_table[option_idx].short_option;
     
     switch (short_option)

source/Interpreter/OptionGroupString.cpp

OptionGroupString::OptionGroupString (uint32_t usage_mask,
     m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupString::~OptionGroupString ()
 {
 }
 
 Error
-OptionGroupString::SetOptionValue (CommandInterpreter &interpreter,
-                                   uint32_t option_idx,
-                                   const char *option_arg)
+OptionGroupString::SetOptionValue(uint32_t option_idx,
+                                  const char *option_arg,
+                                  ExecutionContext *execution_context)
 {
     Error error (m_value.SetValueFromString (option_arg));
     return error;
 }
 
 void
-OptionGroupString::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupString::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_value.Clear();
 }

source/Interpreter/OptionGroupUInt64.cpp

OptionGroupUInt64::OptionGroupUInt64 (uint32_t usage_mask,
     m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupUInt64::~OptionGroupUInt64 ()
 {
 }
 
 Error
-OptionGroupUInt64::SetOptionValue (CommandInterpreter &interpreter,
-                                   uint32_t option_idx,
-                                   const char *option_arg)
+OptionGroupUInt64::SetOptionValue(uint32_t option_idx,
+                                   const char *option_arg,
+                                  ExecutionContext *execution_context)
 {
     Error error (m_value.SetValueFromString (option_arg));
     return error;
 }
 
 void
-OptionGroupUInt64::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupUInt64::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_value.Clear();
 }

source/Interpreter/OptionGroupUUID.cpp

 
 const OptionDefinition *
 OptionGroupUUID::GetDefinitions ()
 {
     return g_option_table;
 }
 
 Error
-OptionGroupUUID::SetOptionValue (CommandInterpreter &interpreter,
-                                 uint32_t option_idx,
-                                 const char *option_arg)
+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;
 
     switch (short_option)
     {
         case 'u':
             error = m_uuid.SetValueFromString (option_arg);
             if (error.Success())
                 m_uuid.SetOptionWasSet();
             break;
 
         default:
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
 
     return error;
 }
 
 void
-OptionGroupUUID::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupUUID::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_uuid.Clear();
 }

source/Interpreter/OptionGroupValueObjectDisplay.cpp

 const OptionDefinition *
 OptionGroupValueObjectDisplay::GetDefinitions ()
 {
     return g_option_table;
 }
 
 
 Error
-OptionGroupValueObjectDisplay::SetOptionValue (CommandInterpreter &interpreter,
-                                               uint32_t option_idx,
-                                               const char *option_arg)
+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;
     bool success = false;
 
     switch (short_option)
     {
         case 'd':
switch (short_option)
             error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
             break;
     }
 
     return error;
 }
 
 void
-OptionGroupValueObjectDisplay::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupValueObjectDisplay::OptionParsingStarting(ExecutionContext
+                                                     *execution_context)
 {
     // If these defaults change, be sure to modify AnyOptionWasSet().
     show_types        = false;
     no_summary_depth  = 0;
     show_location     = false;
     flat_output       = false;
     use_objc          = false;
     max_depth         = UINT32_MAX;
     ptr_depth         = 0;
     elem_count        = 0;
     use_synth         = true;
     be_raw            = false;
     ignore_cap        = false;
     run_validator     = false;
-    
-    Target *target = interpreter.GetExecutionContext().GetTargetPtr();
-    if (target != nullptr)
-        use_dynamic = target->GetPreferDynamicValue();
+    TargetSP target_sp =
+        execution_context ? execution_context->GetTargetSP() : TargetSP();
+    if (target_sp)
+        use_dynamic = target_sp->GetPreferDynamicValue();
     else
     {
         // If we don't have any targets, then dynamic values won't do us much good.
         use_dynamic = lldb::eNoDynamicValues;
     }
 }
 
 DumpValueObjectOptions

source/Interpreter/OptionGroupVariable.cpp

 {
 }
 
 OptionGroupVariable::~OptionGroupVariable ()
 {
 }
 
 Error
-OptionGroupVariable::SetOptionValue (CommandInterpreter &interpreter,
-                                     uint32_t option_idx, 
-                                     const char *option_arg)
+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;
     switch (short_option)
     {
         case 'r':   use_regex    = true;  break;
switch (short_option)
             error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
             break;
     }
     
     return error;
 }
 
 void
-OptionGroupVariable::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupVariable::OptionParsingStarting(ExecutionContext *execution_context)
 {
     show_args     = true;   // Frame option only
     show_locals   = true;   // Frame option only
     show_globals  = false;  // Frame option only
     show_decl     = false;
     use_regex     = false;
     show_scope    = false;
     summary.Clear();

source/Interpreter/OptionGroupWatchpoint.cpp

 {
 }
 
 OptionGroupWatchpoint::~OptionGroupWatchpoint ()
 {
 }
 
 Error
-OptionGroupWatchpoint::SetOptionValue (CommandInterpreter &interpreter,
-                                       uint32_t option_idx, 
-                                       const char *option_arg)
+OptionGroupWatchpoint::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;
     switch (short_option)
     {
         case 'w':
         {
             WatchType tmp_watch_type;
switch (short_option)
             error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
             break;
     }
     
     return error;
 }
 
 void
-OptionGroupWatchpoint::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupWatchpoint::OptionParsingStarting(ExecutionContext
+                                             *execution_context)
 {
     watch_type_specified = false;
     watch_type = eWatchInvalid;
     watch_size = 0;
 }
 
 
 const OptionDefinition*

source/Interpreter/OptionValueArch.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 OptionValueArch::DumpValue (const ExecutionContext *exe_ctx, Stream &strm, uint32_t dump_mask)
 {
     if (dump_mask & eDumpOptionType)

source/Interpreter/OptionValueFileSpec.cpp

 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/State.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
 OptionValueFileSpec::OptionValueFileSpec (bool resolve) :
     OptionValue(),
     m_current_value (),

source/Interpreter/Options.cpp

 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //-------------------------------------------------------------------------
 // Options
 //-------------------------------------------------------------------------
-Options::Options (CommandInterpreter &interpreter) :
-    m_interpreter (interpreter),
+Options::Options () :
     m_getopt_table ()
 {
     BuildValidOptionSets();
 }
 
 Options::~Options ()
 {
 }
 
 void
-Options::NotifyOptionParsingStarting ()
+Options::NotifyOptionParsingStarting(ExecutionContext *execution_context)
 {
     m_seen_options.clear();
     // Let the subclass reset its option values
-    OptionParsingStarting ();
+    OptionParsingStarting(execution_context);
 }
 
 Error
-Options::NotifyOptionParsingFinished ()
+Options::NotifyOptionParsingFinished(ExecutionContext *execution_context)
 {
-    return OptionParsingFinished ();
+    return OptionParsingFinished(execution_context);
 }
 
 void
 Options::OptionSeen (int option_idx)
 {
     m_seen_options.insert (option_idx);
 }
 
if (footer && footer[0])
         strm.PutCString(footer);
     return true;
 }
 
 void
 Options::GenerateOptionUsage
 (
     Stream &strm,
-    CommandObject *cmd
+    CommandObject *cmd,
+    uint32_t screen_width
 )
 {
     const bool only_print_args = cmd->IsDashDashCommand();
-    const uint32_t screen_width = m_interpreter.GetDebugger().GetTerminalWidth();
 
     const OptionDefinition *opt_defs = GetDefinitions();
     const uint32_t save_indent_level = strm.GetIndentLevel();
     const char *name;
 
     StreamString arguments_str;
 
     if (cmd)

 Options::HandleOptionCompletion
 (
     Args &input,
     OptionElementVector &opt_element_vector,
     int cursor_index,
     int char_pos,
     int match_start_point,
     int max_return_elements,
+    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.
for (size_t i = 0; i < opt_element_vector.size(); i++)
             {
                 HandleOptionArgumentCompletion (input,
                                                 cursor_index,
                                                 strlen (input.GetArgumentAtIndex(cursor_index)),
                                                 opt_element_vector,
                                                 i,
                                                 match_start_point,
                                                 max_return_elements,
+                                                interpreter,
                                                 word_complete,
                                                 matches);
                 return true;
             }
             else
             {
                 // No completion callback means no completions...
                 return true;

 (
     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();
     std::unique_ptr<SearchFilter> filter_ap;
 
     int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
if (completion_mask & CommandCompletions::eSourceFileCompletion
             // If this is the "shlib" option and there was an argument provided,
             // restrict it to that shared library.
             if (cur_opt_name && strcmp(cur_opt_name, "shlib") == 0 && cur_arg_pos != -1)
             {
                 const char *module_name = input.GetArgumentAtIndex(cur_arg_pos);
                 if (module_name)
                 {
                     FileSpec module_spec(module_name, false);
-                    lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
+                    lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
                     // Search filters require a target...
                     if (target_sp)
                         filter_ap.reset (new SearchFilterByModule (target_sp, module_spec));
                 }
                 break;
             }
         }
     }
 
-    return CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+    return CommandCompletions::InvokeCommonCompletionCallbacks (interpreter,
                                                                 completion_mask,
                                                                 input.GetArgumentAtIndex (opt_arg_pos),
                                                                 match_start_point,
                                                                 max_return_elements,
                                                                 filter_ap.get(),
                                                                 word_complete,
                                                                 matches);
     

 {
     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)
+                                    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_interpreter, 
-                                                                         m_option_infos[option_idx].option_index,
-                                                                         option_value);
+        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...
     }
     return error;
 }
 
 void
-OptionGroupOptions::OptionParsingStarting ()
+OptionGroupOptions::OptionParsingStarting (ExecutionContext *execution_context)
 {
     std::set<OptionGroup*> group_set;
     OptionInfos::iterator pos, end = m_option_infos.end();
     for (pos = m_option_infos.begin(); pos != end; ++pos)
     {
         OptionGroup* group = pos->option_group;
         if (group_set.find(group) == group_set.end())
         {
-            group->OptionParsingStarting (m_interpreter);
+            group->OptionParsingStarting(execution_context);
             group_set.insert(group);
         }
     }
 }
 Error
-OptionGroupOptions::OptionParsingFinished ()
+OptionGroupOptions::OptionParsingFinished (ExecutionContext *execution_context)
 {
     std::set<OptionGroup*> group_set;
     Error error;
     OptionInfos::iterator pos, end = m_option_infos.end();
     for (pos = m_option_infos.begin(); pos != end; ++pos)
     {
         OptionGroup* group = pos->option_group;
         if (group_set.find(group) == group_set.end())
         {
-            error = group->OptionParsingFinished (m_interpreter);
+            error = group->OptionParsingFinished (execution_context);
             group_set.insert(group);
             if (error.Fail())
                 return error;
         }
     }
     return error;
 }

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

 }
 
 class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed
 {
 public:
     class CommandOptions : public Options
     {
     public:
-        CommandOptions (CommandInterpreter &interpreter) :
-        Options(interpreter),
+        CommandOptions() :
+        Options(),
         m_verbose(false,false)
         {}
         
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
+        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 'v':
                     m_verbose.SetCurrentValue(true);
                     m_verbose.SetOptionWasSet();
                     break;
                     
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
             
             return error;
         }
         
         void
-        OptionParsingStarting() override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_verbose.Clear();
         }
         
         const OptionDefinition*
         GetDefinitions() override
         {
             return g_option_table;
         }
 
         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 |
                          eCommandProcessMustBePaused   ),
-    m_options(interpreter)
+    m_options()
     {
         CommandArgumentEntry arg;
         CommandArgumentData index_arg;
         
         // Define the first (and only) variant of this arg.
         index_arg.arg_type = eArgTypeRegularExpression;
         index_arg.arg_repetition = eArgRepeatOptional;
         

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

 class CommandObjectRenderScriptRuntimeKernelBreakpointSet : public CommandObjectParsed
 {
 public:
     CommandObjectRenderScriptRuntimeKernelBreakpointSet(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "renderscript kernel breakpoint set",
                               "Sets a breakpoint on a renderscript kernel.",
                               "renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
                               eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectRenderScriptRuntimeKernelBreakpointSet() override = default;
 
     Options *
     GetOptions() override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
+        CommandOptions() : Options() {}
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
+        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 'c':
                     if (!ParseCoordinate(option_arg))
public:
                     m_coord[i] = (uint32_t)strtoul(group.c_str(), nullptr, 0);
                 else
                     m_coord[i] = 0;
             }
             return matched;
         }
 
         void
-        OptionParsingStarting() override
+        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 *

 
 class CommandObjectRenderScriptRuntimeAllocationDump : public CommandObjectParsed
 {
 public:
     CommandObjectRenderScriptRuntimeAllocationDump(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "renderscript allocation dump",
                               "Displays the contents of a particular allocation", "renderscript allocation dump <ID>",
                               eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectRenderScriptRuntimeAllocationDump() override = default;
 
     Options *
     GetOptions() override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
+        CommandOptions() : Options() {}
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
+        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 'f':
                     m_outfile.SetFile(option_arg, true);
                     if (m_outfile.Exists())
                     {
                         m_outfile.Clear();
                         error.SetErrorStringWithFormat("file already exists: '%s'", option_arg);
                     }
                     break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting() override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_outfile.Clear();
         }
 
         const OptionDefinition *
         GetDefinitions() override
         {
             return g_option_table;

 
 class CommandObjectRenderScriptRuntimeAllocationList : public CommandObjectParsed
 {
 public:
     CommandObjectRenderScriptRuntimeAllocationList(CommandInterpreter &interpreter)
         : CommandObjectParsed(interpreter, "renderscript allocation list",
                               "List renderscript allocations and their information.", "renderscript allocation list",
                               eCommandRequiresProcess | eCommandProcessMustBeLaunched),
-          m_options(interpreter)
+          m_options()
     {
     }
 
     ~CommandObjectRenderScriptRuntimeAllocationList() override = default;
 
     Options *
     GetOptions() override
     {
         return &m_options;
     }
 
     class CommandOptions : public Options
     {
     public:
-        CommandOptions(CommandInterpreter &interpreter) : Options(interpreter), m_id(0) {}
+        CommandOptions() : Options(), m_id(0) {}
 
         ~CommandOptions() override = default;
 
         Error
-        SetOptionValue(uint32_t option_idx, const char *option_arg) override
+        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 'i':
                     bool success;
                     m_id = StringConvert::ToUInt32(option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat("invalid integer value for option '%c'", short_option);
                     break;
                 default:
                     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
                     break;
             }
             return error;
         }
 
         void
-        OptionParsingStarting() override
+        OptionParsingStarting(ExecutionContext *execution_context) override
         {
             m_id = 0;
         }
 
         const OptionDefinition *
         GetDefinitions() override
         {
             return g_option_table;

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 }
 
 lldb_private::OptionGroupOptions*
 PlatformPOSIX::GetConnectionOptions (lldb_private::CommandInterpreter& interpreter)
 {
     auto iter = m_options.find(&interpreter), end = m_options.end();
     if (iter == end)
     {
-        std::unique_ptr<lldb_private::OptionGroupOptions> options(new OptionGroupOptions(interpreter));
+        std::unique_ptr<lldb_private::OptionGroupOptions> options(new OptionGroupOptions());
         options->Append(m_option_group_platform_rsync.get());
         options->Append(m_option_group_platform_ssh.get());
         options->Append(m_option_group_platform_caching.get());
         m_options[&interpreter] = std::move(options);
     }
     
     return m_options.at(&interpreter).get();
 }

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

     
 
 public:
     CommandObjectProcessKDPPacketSend(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process plugin packet send",
                              "Send a custom packet through the KDP protocol by specifying the command byte and the packet payload data. A packet will be sent with a correct header and payload, and the raw result bytes will be displayed as a string value. ",
                              NULL),
-        m_option_group (interpreter),
+        m_option_group(),
         m_command_byte(LLDB_OPT_SET_1, true , "command", 'c', 0, eArgTypeNone, "Specify the command byte to use when sending the KDP request packet.", 0),
         m_packet_data (LLDB_OPT_SET_1, false, "payload", 'p', 0, eArgTypeNone, "Specify packet payload bytes as a hex ASCII string with no spaces or hex prefixes.", NULL)
     {
         m_option_group.Append (&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_packet_data , LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Finalize();
     }
     

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 class CommandObjectProcessGDBRemoteSpeedTest: public CommandObjectParsed
 {
 public:
     CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter) :
         CommandObjectParsed (interpreter,
                              "process plugin packet speed-test",
                              "Tests packet speeds of various sizes to determine the performance characteristics of the GDB remote connection. ",
                              NULL),
-        m_option_group (interpreter),
+        m_option_group (),
         m_num_packets (LLDB_OPT_SET_1, false, "count",       'c', 0, eArgTypeCount, "The number of packets to send of each varying size (default is 1000).", 1000),
         m_max_send    (LLDB_OPT_SET_1, false, "max-send",    's', 0, eArgTypeCount, "The maximum number of bytes to send in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024),
         m_max_recv    (LLDB_OPT_SET_1, false, "max-receive", 'r', 0, eArgTypeCount, "The maximum number of bytes to receive in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024),
         m_json        (LLDB_OPT_SET_1, false, "json",        'j', "Print the output as JSON data for easy parsing.", false, true)
     {
         m_option_group.Append (&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
         m_option_group.Append (&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);

source/Target/Platform.cpp

 
 const lldb_private::OptionDefinition*
 OptionGroupPlatformRSync::GetDefinitions ()
 {
     return g_rsync_option_table;
 }
 
 void
-OptionGroupPlatformRSync::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformRSync::OptionParsingStarting(ExecutionContext *execution_context)
 {
     m_rsync = false;
     m_rsync_opts.clear();
     m_rsync_prefix.clear();
     m_ignores_remote_hostname = false;
 }
 
 lldb_private::Error
-OptionGroupPlatformRSync::SetOptionValue (CommandInterpreter &interpreter,
-                uint32_t option_idx,
-                const char *option_arg)
+OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
+                                         const char *option_arg,
+                                         ExecutionContext *execution_context)
 {
     Error error;
     char short_option = (char) GetDefinitions()[option_idx].short_option;
     switch (short_option)
     {
         case 'r':
             m_rsync = true;
             break;

 
 const lldb_private::OptionDefinition*
 OptionGroupPlatformSSH::GetDefinitions ()
 {
     return g_ssh_option_table;
 }
 
 void
-OptionGroupPlatformSSH::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformSSH::OptionParsingStarting(ExecutionContext
+                                              *execution_context)
 {
     m_ssh = false;
     m_ssh_opts.clear();
 }
 
 lldb_private::Error
-OptionGroupPlatformSSH::SetOptionValue (CommandInterpreter &interpreter,
-                                          uint32_t option_idx,
-                                          const char *option_arg)
+OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
+                                       const char *option_arg,
+                                       ExecutionContext *execution_context)
 {
     Error error;
     char short_option = (char) GetDefinitions()[option_idx].short_option;
     switch (short_option)
     {
         case 's':
             m_ssh = true;
             break;

 
 const lldb_private::OptionDefinition*
 OptionGroupPlatformCaching::GetDefinitions ()
 {
     return g_caching_option_table;
 }
 
 void
-OptionGroupPlatformCaching::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformCaching::OptionParsingStarting(ExecutionContext
+                                                  *execution_context)
 {
     m_cache_dir.clear();
 }
 
 lldb_private::Error
-OptionGroupPlatformCaching::SetOptionValue (CommandInterpreter &interpreter,
-                                        uint32_t option_idx,
-                                        const char *option_arg)
+OptionGroupPlatformCaching::SetOptionValue(uint32_t option_idx,
+                                           const char *option_arg,
+                                           ExecutionContext *execution_context)
 {
     Error error;
     char short_option = (char) GetDefinitions()[option_idx].short_option;
     switch (short_option)
     {
         case 'c':
             m_cache_dir.assign(option_arg);
             break;

source/Target/Process.cpp

if (m_pid != LLDB_INVALID_PROCESS_ID)
             s.PutCString (GetName());
         }
 
         s.EOL();
     }
 }
 
 Error
-ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+ProcessLaunchCommandOptions::SetOptionValue(uint32_t option_idx,
+                                            const char *option_arg,
+                                            ExecutionContext *execution_context)
 {
     Error error;
     const int short_option = m_getopt_table[option_idx].val;
     
     switch (short_option)
     {
         case 's':   // Stop at program entry point
             launch_info.GetFlags().Set (eLaunchFlagStopAtEntry); 
switch (short_option)
             launch_info.SetWorkingDirectory(FileSpec{option_arg, false});
             break;
             
         case 't':   // Open process in new terminal window
             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY); 
             break;
             
         case 'a':
-            if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
+            {
+                TargetSP target_sp = execution_context ?
+                    execution_context->GetTargetSP() : TargetSP();
+                PlatformSP platform_sp = target_sp ?
+                    target_sp->GetPlatform() : PlatformSP();
+                if (!launch_info.GetArchitecture().SetTriple (option_arg, platform_sp.get()))
                     launch_info.GetArchitecture().SetTriple (option_arg);
+            }
             break;
             
         case 'A':   // Disable ASLR.
         {
             bool success;
             const bool disable_aslr_arg = Args::StringToBoolean (option_arg, true, &success);
             if (success)
                 disable_aslr = disable_aslr_arg ? eLazyBoolYes : eLazyBoolNo;