Make OptionGroup::SetValue take a StringRef

[zturner]

Summary

As before, some copies are removed, a few are introduced. When I get to Option::SetValue, those that are introduced should go away.

[clayborg]

We could avoid many of the copies in the printf statements by by doing something like this in a common header file:

#define LLVM_STRINGREF_PRINTF_FORMAT "%*s"
#define LLVM_STRINGREF_PRINTF_ARGS(s) (int)s.size(), s.data()

Then when doing errors or anything that does printf:

error.SetErrorStringWithFormat("invalid all-threads value setting: \"" LLVM_STRINGREF_PRINTF_FORMAT "\"", LLVM_STRINGREF_PRINTF_ARGS(option_arg));

There are a few places where we should plumb through StringRef variants of calls, only 2, so I think it is worth including in this change.

source/Commands/CommandObjectRegister.cpp

269 ↗

(On Diff #72216)

Add a StringRef variant as inside of OptionValueUInt64 it can use the StringRef::getAsInteger().

source/Interpreter/OptionGroupVariable.cpp

104 ↗

(On Diff #72216)

Please add llvm::StringRef version of SetCurrentValue to OptionValueString:

Error
OptionValueString::SetCurrentValue(const llvm::StringRef &value);

107 ↗

(On Diff #72216)

Please add llvm::StringRef version of SetCurrentValue to OptionValueString:

[clayborg]

I am not saying we have to do the printf changes, I was just seeing what you think. I would like to see the StringRef variants of functions put in as part of this.

[clayborg]

Yeah, don't do any calls that don't need to be converted. Just the ones you need. Should just add 2 StringRef variant functions. Don't feel the need to completely fix OptionValueString or OptionValueUInt64. We can do the full change over in a future CL. See if you can just add the two quick ones.

[clayborg]

no printf fixes are fine. I don't mind if error cases have str().c_str() so much.

[clayborg]

You can still leave the "const char *" versions in there for now until you get to the cleanup. No spiral if you do that.

[zturner]

Updated the two requested functions. I still had to make a few more changes to catch the implicit conversions into each of these functions, but it wasn't too bad.

[clayborg]

Looks good.

lldb/trunk/include/lldb/Interpreter/Args.h

StringToEncoding(const char *,
                    lldb::Encoding = lldb::eEncodingInvalid) = delete;
   static uint32_t StringToGenericRegister(const char *) = delete;
   static bool StringToVersion(const char *, uint32_t &, uint32_t &,
                               uint32_t &) = delete;
   const char *Unshift(const char *, char = '\0') = delete;
   void AddOrReplaceEnvironmentVariable(const char *, const char *) = delete;
   bool ContainsEnvironmentVariable(const char *,
                                    size_t * = nullptr) const = delete;
+  static int64_t StringToOptionEnum(const char *, OptionEnumValueElement *,
+                                    int32_t, Error &) = delete;
 
   //------------------------------------------------------------------
   /// Insert the argument value at index \a idx to \a arg_cstr.
   ///
   /// @param[in] idx
   ///     The index of where to insert the argument.
   ///
   /// @param[in] arg_cstr
static lldb::addr_t StringToAddress(const ExecutionContext *exe_ctx,
                                       Error *error);
 
   static bool StringToBoolean(llvm::StringRef s, bool fail_value,
                               bool *success_ptr);
 
   static char StringToChar(llvm::StringRef s, char fail_value,
                            bool *success_ptr);
 
-  static int64_t StringToOptionEnum(const char *s,
+  static int64_t StringToOptionEnum(llvm::StringRef s,
                                     OptionEnumValueElement *enum_values,
                                     int32_t fail_value, Error &error);
 
   static lldb::ScriptLanguage
   StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
                          bool *success_ptr);
 
   // TODO: Use StringRef

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

 class OptionGroupArchitecture : public OptionGroup {
 public:
   OptionGroupArchitecture();
 
   ~OptionGroupArchitecture() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool GetArchitecture(Platform *platform, ArchSpec &arch);
 
   bool ArchitectureWasSpecified() const { return !m_arch_str.empty(); }
 
   const char *GetArchitectureName() {

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

OptionGroupBoolean(uint32_t usage_mask, bool required,
                      bool no_argument_toggle_default);
 
   ~OptionGroupBoolean() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueBoolean &GetOptionValue() { return m_value; }
 
   const OptionValueBoolean &GetOptionValue() const { return m_value; }
 
 protected:
   OptionValueBoolean m_value;
   OptionDefinition m_option_definition;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupBoolean_h_

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

OptionGroupFile(uint32_t usage_mask, bool required, const char *long_option,
                   const char *usage_text);
 
   ~OptionGroupFile() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueFileSpec &GetOptionValue() { return m_file; }
 
   const OptionValueFileSpec &GetOptionValue() const { return m_file; }
 
 protected:
OptionGroupFileList(uint32_t usage_mask, bool required,
                       const char *usage_text);
 
   ~OptionGroupFileList() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueFileSpecList &GetOptionValue() { return m_file_list; }
 
   const OptionValueFileSpecList &GetOptionValue() const { return m_file_list; }
 
 protected:
   OptionValueFileSpecList m_file_list;
   OptionDefinition m_option_definition;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupFile_h_

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

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

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

 class OptionGroupOutputFile : public OptionGroup {
 public:
   OptionGroupOutputFile();
 
   ~OptionGroupOutputFile() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   const OptionValueFileSpec &GetFile() { return m_file; }
 
   const OptionValueBoolean &GetAppend() { return m_append; }
 
   bool AnyOptionWasSet() const {

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

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

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

OptionGroupString(uint32_t usage_mask, bool required, const char *long_option,
                     const char *usage_text, const char *default_value);
 
   ~OptionGroupString() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueString &GetOptionValue() { return m_value; }
 
   const OptionValueString &GetOptionValue() const { return m_value; }
 
 protected:
   OptionValueString m_value;
   OptionDefinition m_option_definition;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupString_h_

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

OptionGroupUInt64(uint32_t usage_mask, bool required, const char *long_option,
                     const char *usage_text, uint64_t default_value);
 
   ~OptionGroupUInt64() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::ArrayRef<OptionDefinition>(&m_option_definition, 1);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   OptionValueUInt64 &GetOptionValue() { return m_value; }
 
   const OptionValueUInt64 &GetOptionValue() const { return m_value; }
 
 protected:
   OptionValueUInt64 m_value;
   OptionDefinition m_option_definition;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_OptionGroupUInt64_h_

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

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

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

 class OptionGroupValueObjectDisplay : public OptionGroup {
 public:
   OptionGroupValueObjectDisplay();
 
   ~OptionGroupValueObjectDisplay() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool AnyOptionWasSet() const {
     return show_types || no_summary_depth != 0 || show_location ||
            flat_output || use_objc || max_depth != UINT32_MAX ||
            ptr_depth != 0 || !use_synth || be_raw || ignore_cap ||
            run_validator;

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

 class OptionGroupVariable : public OptionGroup {
 public:
   OptionGroupVariable(bool show_frame_options);
 
   ~OptionGroupVariable() override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void 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;

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

public:
   OptionGroupWatchpoint();
 
   ~OptionGroupWatchpoint() override;
 
   static bool IsWatchSizeSupported(uint32_t watch_size);
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   // Note:
   // eWatchRead == LLDB_WATCH_TYPE_READ; and
   // eWatchWrite == LLDB_WATCH_TYPE_WRITE
   typedef enum WatchType {
     eWatchInvalid = 0,

lldb/trunk/include/lldb/Interpreter/OptionValue.h

public:
   static const char *GetBuiltinTypeAsCString(Type t);
 
   virtual void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                          uint32_t dump_mask) = 0;
 
   virtual Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign);
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   virtual bool Clear() = 0;
 
   virtual lldb::OptionValueSP DeepCopy() const = 0;
 
   virtual size_t AutoComplete(CommandInterpreter &interpreter, const char *s,
                               int match_start_point, int max_return_elements,
                               bool &word_complete, StringList &matches);

lldb/trunk/include/lldb/Interpreter/OptionValueArch.h

public:
   OptionValue::Type GetType() const override { return eTypeArch; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueArray.h

public:
   OptionValue::Type GetType() const override { return eTypeArray; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_values.clear();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueBoolean.h

public:
   OptionValue::Type GetType() const override { return eTypeBoolean; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   size_t AutoComplete(CommandInterpreter &interpreter, const char *s,

lldb/trunk/include/lldb/Interpreter/OptionValueChar.h

public:
   OptionValue::Type GetType() const override { return eTypeChar; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   //---------------------------------------------------------------------

lldb/trunk/include/lldb/Interpreter/OptionValueDictionary.h

public:
   OptionValue::Type GetType() const override { return eTypeDictionary; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_values.clear();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
public:
 
   lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
                                   const char *name, bool will_modify,
                                   Error &error) const override;
 
   Error SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
                     const char *name, const char *value) override;
 
-  //---------------------------------------------------------------------
-  // String value getters and setters
-  //---------------------------------------------------------------------
-  const char *GetStringValueForKey(const ConstString &key);
-
-  bool SetStringValueForKey(const ConstString &key, const char *value,
-                            bool can_replace = true);
-
   bool SetValueForKey(const ConstString &key,
                       const lldb::OptionValueSP &value_sp,
                       bool can_replace = true);
 
   bool DeleteValueForKey(const ConstString &key);
 
   size_t GetArgs(Args &args) const;
 

lldb/trunk/include/lldb/Interpreter/OptionValueEnumeration.h

public:
   OptionValue::Type GetType() const override { return eTypeEnum; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpec.h

public:
   OptionValue::Type GetType() const override { return eTypeFileSpec; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     m_data_sp.reset();
     m_data_mod_time.Clear();
     return true;
   }

lldb/trunk/include/lldb/Interpreter/OptionValueFileSpecList.h

public:
   OptionValue::Type GetType() const override { return eTypeFileSpecList; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value.Clear();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueFormat.h

public:
   OptionValue::Type GetType() const override { return eTypeFormat; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueFormatEntity.h

public:
   OptionValue::Type GetType() const override { return eTypeFormatEntity; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override;
 
   lldb::OptionValueSP DeepCopy() const override;
 
   size_t AutoComplete(CommandInterpreter &interpreter, const char *s,
                       int match_start_point, int max_return_elements,
                       bool &word_complete, StringList &matches) override;

lldb/trunk/include/lldb/Interpreter/OptionValueLanguage.h

public:
   OptionValue::Type GetType() const override { return eTypeLanguage; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValuePathMappings.h

public:
   OptionValue::Type GetType() const override { return eTypePathMap; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_path_mappings.Clear(m_notify_changes);
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

public:
 
   bool Clear() override;
 
   lldb::OptionValueSP DeepCopy() const override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   ConstString GetName() const override { return m_name; }
 
   virtual Error DumpPropertyValue(const ExecutionContext *exe_ctx, Stream &strm,
                                   const char *property_path,

lldb/trunk/include/lldb/Interpreter/OptionValueRegex.h

public:
   OptionValue::Type GetType() const override { return eTypeRegex; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_regex.Clear();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueSInt64.h

public:
   OptionValue::Type GetType() const override { return eTypeSInt64; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueString.h

public:
   OptionValue::Type GetType() const override { return eTypeString; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;
 
   //---------------------------------------------------------------------
   // Subclass specific functions
   //---------------------------------------------------------------------
 
   Flags &GetOptions() { return m_options; }
 
   const Flags &GetOptions() const { return m_options; }
 
   const char *operator=(const char *value) {
-    SetCurrentValue(value);
+    SetCurrentValue(llvm::StringRef::withNullAsEmpty(value));
     return m_current_value.c_str();
   }
 
   const char *GetCurrentValue() const { return m_current_value.c_str(); }
   llvm::StringRef GetCurrentValueAsRef() const { return m_current_value; }
 
   const char *GetDefaultValue() const { return m_default_value.c_str(); }
   llvm::StringRef GetDefaultValueAsRef() const { return m_default_value; }
 
-  Error SetCurrentValue(const char *value);
+  Error SetCurrentValue(const char *) = delete;
+  Error SetCurrentValue(llvm::StringRef value);
 
   Error AppendToCurrentValue(const char *value);
 
   void SetDefaultValue(const char *value) {
     if (value && value[0])
       m_default_value.assign(value);
     else
       m_default_value.clear();

lldb/trunk/include/lldb/Interpreter/OptionValueUInt64.h

public:
   ~OptionValueUInt64() override {}
 
   //---------------------------------------------------------------------
   // Decode a uint64_t from "value_cstr" return a OptionValueUInt64 object
   // inside of a lldb::OptionValueSP object if all goes well. If the
   // string isn't a uint64_t value or any other error occurs, return an
   // empty lldb::OptionValueSP and fill error in with the correct stuff.
   //---------------------------------------------------------------------
-  static lldb::OptionValueSP Create(const char *value_cstr, Error &error);
+  static lldb::OptionValueSP Create(const char *, Error &) = delete;
+  static lldb::OptionValueSP Create(llvm::StringRef value_str, Error &error);
   //---------------------------------------------------------------------
   // Virtual subclass pure virtual overrides
   //---------------------------------------------------------------------
 
   OptionValue::Type GetType() const override { return eTypeUInt64; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_current_value = m_default_value;
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

lldb/trunk/include/lldb/Interpreter/OptionValueUUID.h

public:
   OptionValue::Type GetType() const override { return eTypeUUID; }
 
   void DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                  uint32_t dump_mask) override;
 
   Error
   SetValueFromString(llvm::StringRef value,
                      VarSetOperationType op = eVarSetOperationAssign) override;
+  Error
+  SetValueFromString(const char *,
+                     VarSetOperationType = eVarSetOperationAssign) = delete;
 
   bool Clear() override {
     m_uuid.Clear();
     m_value_was_set = false;
     return true;
   }
 
   lldb::OptionValueSP DeepCopy() const override;

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

 class OptionGroup {
 public:
   OptionGroup() = default;
 
   virtual ~OptionGroup() = default;
 
   virtual llvm::ArrayRef<OptionDefinition> GetDefinitions() = 0;
 
-  virtual Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  virtual Error SetOptionValue(uint32_t option_idx,
+                               llvm::StringRef option_value,
                                ExecutionContext *execution_context) = 0;
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   virtual void OptionParsingStarting(ExecutionContext *execution_context) = 0;
 
   virtual Error OptionParsingFinished(ExecutionContext *execution_context) {
     // If subclasses need to know when the options are done being parsed
     // they can implement this function to do extra checking
     Error error;
     return error;

lldb/trunk/include/lldb/Target/Language.h

virtual void GetExceptionResolverDescription(bool catch_on, bool throw_on,
                                                Stream &s);
 
   static void GetDefaultExceptionResolverDescription(bool catch_on,
                                                      bool throw_on, Stream &s);
 
   // These are accessors for general information about the Languages lldb knows
   // about:
 
-  static lldb::LanguageType GetLanguageTypeFromString(const char *string);
+  static lldb::LanguageType
+  GetLanguageTypeFromString(const char *string) = delete;
   static lldb::LanguageType GetLanguageTypeFromString(llvm::StringRef string);
 
   static const char *GetNameForLanguageType(lldb::LanguageType language);
 
   static void PrintAllLanguages(Stream &s, const char *prefix,
                                 const char *suffix);
 
   // return false from callback to stop iterating

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

 
 class OptionGroupPlatformRSync : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformRSync() = default;
 
   ~OptionGroupPlatformRSync() override = default;
 
   lldb_private::Error
-  SetOptionValue(uint32_t option_idx, const char *option_value,
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 

 
 class OptionGroupPlatformSSH : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformSSH() = default;
 
   ~OptionGroupPlatformSSH() override = default;
 
   lldb_private::Error
-  SetOptionValue(uint32_t option_idx, const char *option_value,
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 

 
 class OptionGroupPlatformCaching : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformCaching() = default;
 
   ~OptionGroupPlatformCaching() override = default;
 
   lldb_private::Error
-  SetOptionValue(uint32_t option_idx, const char *option_value,
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Options table: Required for subclasses of Options.
 

lldb/trunk/source/API/SBLanguageRuntime.cpp

 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/Target/Language.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::LanguageType
 SBLanguageRuntime::GetLanguageTypeFromString(const char *string) {
-  return Language::GetLanguageTypeFromString(string);
+  return Language::GetLanguageTypeFromString(
+      llvm::StringRef::withNullAsEmpty(string));
 }
 
 const char *
 SBLanguageRuntime::GetNameForLanguageType(lldb::LanguageType language) {
   return Language::GetNameForLanguageType(language);
 }

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         m_condition.assign(option_arg);
         break;
 
       case 'D':
         m_use_dummy = true;
         break;
 
       case 'E': {
-        LanguageType language = Language::GetLanguageTypeFromString(option_arg);
+        LanguageType language =
+            Language::GetLanguageTypeFromString(option_strref);
 
         switch (language) {
         case eLanguageTypeC89:
         case eLanguageTypeC:
         case eLanguageTypeC99:
         case eLanguageTypeC11:
           m_exception_language = eLanguageTypeC;
           break;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         m_line_num = StringConvert::ToUInt32(option_arg, 0, 0, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid line number: %s.",
                                          option_arg);
         break;
       }
 
       case 'L':
-        m_language = Language::GetLanguageTypeFromString(option_arg);
+        m_language = Language::GetLanguageTypeFromString(option_strref);
         if (m_language == eLanguageTypeUnknown)
           error.SetErrorStringWithFormat(
               "Unknown language type: '%s' for breakpoint", option_arg);
         break;
 
       case 'm': {
         bool success;
         bool value;
public:
   }
 
   ~BreakpointNameOptionGroup() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_breakpoint_name_options);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_value,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
     Error error;
     const int short_option = g_breakpoint_name_options[option_idx].short_option;
-    llvm::StringRef option_strref(option_value ? option_value : "");
 
     switch (short_option) {
     case 'N':
-      if (BreakpointID::StringIsBreakpointName(option_strref, error) &&
+      if (BreakpointID::StringIsBreakpointName(option_value, error) &&
           error.Success())
-        m_name.SetValueFromString(option_strref);
+        m_name.SetValueFromString(option_value);
       break;
 
     case 'B':
       if (m_breakpoint.SetValueFromString(option_value).Fail())
         error.SetErrorStringWithFormat(
-            "unrecognized value \"%s\" for breakpoint", option_value);
+            "unrecognized value \"%s\" for breakpoint",
+            option_value.str().c_str());
       break;
     case 'D':
       if (m_use_dummy.SetValueFromString(option_value).Fail())
         error.SetErrorStringWithFormat(
-            "unrecognized value \"%s\" for use-dummy", option_value);
+            "unrecognized value \"%s\" for use-dummy",
+            option_value.str().c_str());
       break;
 
     default:
       error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                      short_option);
       break;
     }
     return error;
   }
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_name.Clear();
     m_breakpoint.Clear();
     m_use_dummy.Clear();
     m_use_dummy.SetDefaultValue(false);
   }
 

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = option_arg;
         break;
 
       case 's':
         m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
-            option_arg, g_breakpoint_add_options[option_idx].enum_values,
+            llvm::StringRef::withNullAsEmpty(option_arg),
+            g_breakpoint_add_options[option_idx].enum_values,
             eScriptLanguageNone, error);
 
         if (m_script_language == eScriptLanguagePython ||
             m_script_language == eScriptLanguageDefault) {
           m_use_script_language = true;
         } else {
           m_use_script_language = false;
         }

lldb/trunk/source/Commands/CommandObjectCommands.cpp

public:
     }
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
+      llvm::StringRef option_strref =
+          llvm::StringRef::withNullAsEmpty(option_arg);
 
       switch (short_option) {
       case 'c':
-        error = m_count.SetValueFromString(option_arg, eVarSetOperationAssign);
+        error =
+            m_count.SetValueFromString(option_strref, eVarSetOperationAssign);
         break;
       case 's':
         if (option_arg && strcmp("end", option_arg) == 0) {
           m_start_idx.SetCurrentValue(UINT64_MAX);
           m_start_idx.SetOptionWasSet();
         } else
-          error = m_start_idx.SetValueFromString(option_arg,
+          error = m_start_idx.SetValueFromString(option_strref,
                                                  eVarSetOperationAssign);
         break;
       case 'e':
-        error =
-            m_stop_idx.SetValueFromString(option_arg, eVarSetOperationAssign);
+        error = m_stop_idx.SetValueFromString(option_strref,
+                                              eVarSetOperationAssign);
         break;
       case 'C':
         m_clear.SetCurrentValue(true);
         m_clear.SetOptionWasSet();
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
CommandOptions()
           m_stop_on_continue(true) {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
+      llvm::StringRef option_strref =
+          llvm::StringRef::withNullAsEmpty(option_arg);
 
       switch (short_option) {
       case 'e':
-        error = m_stop_on_error.SetValueFromString(option_arg);
+        error = m_stop_on_error.SetValueFromString(option_strref);
         break;
 
       case 'c':
-        error = m_stop_on_continue.SetValueFromString(option_arg);
+        error = m_stop_on_continue.SetValueFromString(option_strref);
         break;
 
       case 's':
-        error = m_silent_run.SetValueFromString(option_arg);
+        error = m_silent_run.SetValueFromString(option_strref);
         break;
 
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
public:
     CommandOptions() : OptionGroup(), m_help(), m_long_help() {}
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_alias_options);
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_value,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          ExecutionContext *execution_context) override {
       Error error;
 
       const int short_option = GetDefinitions()[option_idx].short_option;
+      std::string option_str(option_value);
 
       switch (short_option) {
       case 'h':
-        m_help.SetCurrentValue(option_value);
+        m_help.SetCurrentValue(option_str);
         m_help.SetOptionWasSet();
         break;
 
       case 'H':
-        m_long_help.SetCurrentValue(option_value);
+        m_long_help.SetCurrentValue(option_str);
         m_long_help.SetOptionWasSet();
         break;
 
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_help.Clear();
       m_long_help.Clear();
     }
 
     OptionValueString m_help;
     OptionValueString m_long_help;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         break;
       case 'h':
         if (option_arg)
           m_short_help.assign(option_arg);
         break;
       case 's':
         m_synchronicity =
             (ScriptedCommandSynchronicity)Args::StringToOptionEnum(
-                option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
+                llvm::StringRef::withNullAsEmpty(option_arg),
+                GetDefinitions()[option_idx].enum_values, 0, error);
         if (!error.Success())
           error.SetErrorStringWithFormat(
               "unrecognized value for synchronicity '%s'", option_arg);
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;

lldb/trunk/source/Commands/CommandObjectExpression.h

public:
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions();
 
     ~CommandOptions() override;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_value,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          ExecutionContext *execution_context) override;
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override;
 
     // Options table: Required for subclasses of Options.
 
     static OptionDefinition g_option_table[];
     bool top_level;
     bool unwind_on_error;

lldb/trunk/source/Commands/CommandObjectExpression.cpp

static OptionDefinition g_expression_options[] = {
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "top-level",             'p', OptionParser::eNoArgument,       nullptr, nullptr,                      0, eArgTypeNone,                 "Interpret the expression as top-level definitions rather than code to be immediately "
                                                                                                                                                                                   "executed."},
   {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "allow-jit",             'j', OptionParser::eRequiredArgument, nullptr, nullptr,                      0, eArgTypeBoolean,              "Controls whether the expression can fall back to being JITted if it's not supported by "
                                                                                                                                                                                   "the interpreter (defaults to true)."}
     // clang-format on
 };
 
 Error CommandObjectExpression::CommandOptions::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Error error;
 
-  auto option_strref = llvm::StringRef::withNullAsEmpty(option_arg);
   const int short_option = GetDefinitions()[option_idx].short_option;
 
   switch (short_option) {
   case 'l':
     language = Language::GetLanguageTypeFromString(option_arg);
     if (language == eLanguageTypeUnknown)
       error.SetErrorStringWithFormat(
-          "unknown language type: '%s' for expression", option_arg);
+          "unknown language type: '%s' for expression",
+          option_arg.str().c_str());
     break;
 
   case 'a': {
     bool success;
     bool result;
-    result = Args::StringToBoolean(option_strref, true, &success);
+    result = Args::StringToBoolean(option_arg, true, &success);
     if (!success)
       error.SetErrorStringWithFormat(
-          "invalid all-threads value setting: \"%s\"", option_arg);
+          "invalid all-threads value setting: \"%s\"",
+          option_arg.str().c_str());
     else
       try_all_threads = result;
   } break;
 
   case 'i': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
     if (success)
       ignore_breakpoints = tmp_value;
     else
       error.SetErrorStringWithFormat(
-          "could not convert \"%s\" to a boolean value.", option_arg);
+          "could not convert \"%s\" to a boolean value.",
+          option_arg.str().c_str());
     break;
   }
 
   case 'j': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
     if (success)
       allow_jit = tmp_value;
     else
       error.SetErrorStringWithFormat(
-          "could not convert \"%s\" to a boolean value.", option_arg);
+          "could not convert \"%s\" to a boolean value.",
+          option_arg.str().c_str());
     break;
   }
 
-  case 't': {
-    bool success;
-    uint32_t result;
-    result = StringConvert::ToUInt32(option_arg, 0, 0, &success);
-    if (success)
-      timeout = result;
-    else
+  case 't':
+    if (option_arg.getAsInteger(0, timeout)) {
+      timeout = 0;
       error.SetErrorStringWithFormat("invalid timeout setting \"%s\"",
-                                     option_arg);
-  } break;
+                                     option_arg.str().c_str());
+    }
+    break;
 
   case 'u': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
     if (success)
       unwind_on_error = tmp_value;
     else
       error.SetErrorStringWithFormat(
-          "could not convert \"%s\" to a boolean value.", option_arg);
+          "could not convert \"%s\" to a boolean value.",
+          option_arg.str().c_str());
     break;
   }
 
   case 'v':
-    if (!option_arg) {
+    if (!option_arg.empty()) {
       m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull;
       break;
     }
     m_verbosity =
         (LanguageRuntimeDescriptionDisplayVerbosity)Args::StringToOptionEnum(
             option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
     if (!error.Success())
       error.SetErrorStringWithFormat(
-          "unrecognized value for description-verbosity '%s'", option_arg);
+          "unrecognized value for description-verbosity '%s'",
+          option_arg.str().c_str());
     break;
 
   case 'g':
     debug = true;
     unwind_on_error = false;
     ignore_breakpoints = false;
     break;
 
   case 'p':
     top_level = true;
     break;
 
   case 'X': {
     bool success;
-    bool tmp_value = Args::StringToBoolean(option_strref, true, &success);
+    bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
     if (success)
       auto_apply_fixits = tmp_value ? eLazyBoolYes : eLazyBoolNo;
     else
       error.SetErrorStringWithFormat(
-          "could not convert \"%s\" to a boolean value.", option_arg);
+          "could not convert \"%s\" to a boolean value.",
+          option_arg.str().c_str());
     break;
   }
 
   default:
     error.SetErrorStringWithFormat("invalid short option character '%c'",
                                    short_option);
     break;
   }

lldb/trunk/source/Commands/CommandObjectMemory.cpp

OptionGroupReadMemory()
         m_offset(0, 0) {}
 
   ~OptionGroupReadMemory() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_read_memory_options);
   }
 
-  Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+  Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                        ExecutionContext *execution_context) override {
     Error error;
     const int short_option = g_read_memory_options[option_idx].short_option;
 
     switch (short_option) {
     case 'l':
-      error = m_num_per_line.SetValueFromString(option_arg);
+      error = m_num_per_line.SetValueFromString(option_value);
       if (m_num_per_line.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat(
-            "invalid value for --num-per-line option '%s'", option_arg);
+            "invalid value for --num-per-line option '%s'",
+            option_value.str().c_str());
       break;
 
     case 'b':
       m_output_as_binary = true;
       break;
 
     case 't':
-      error = m_view_as_type.SetValueFromString(option_arg);
+      error = m_view_as_type.SetValueFromString(option_value);
       break;
 
     case 'r':
       m_force = true;
       break;
 
     case 'E':
-      error = m_offset.SetValueFromString(option_arg);
+      error = m_offset.SetValueFromString(option_value);
       break;
 
     default:
       error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                      short_option);
       break;
     }
     return error;
   }
+  Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
   void 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();
   }
public:
     OptionGroupFindMemory() : OptionGroup(), m_count(1), m_offset(0) {}
 
     ~OptionGroupFindMemory() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_find_option_table);
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          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);
+        m_expr.SetValueFromString(option_value);
         break;
 
       case 's':
-        m_string.SetValueFromString(option_arg);
+        m_string.SetValueFromString(option_value);
         break;
 
       case 'c':
-        if (m_count.SetValueFromString(option_arg).Fail())
+        if (m_count.SetValueFromString(option_value).Fail())
           error.SetErrorString("unrecognized value for count");
         break;
 
       case 'o':
-        if (m_offset.SetValueFromString(option_arg).Fail())
+        if (m_offset.SetValueFromString(option_value).Fail())
           error.SetErrorString("unrecognized value for dump-offset");
         break;
 
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                        short_option);
         break;
       }
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_expr.Clear();
       m_string.Clear();
       m_count.Clear();
     }
 
     OptionValueString m_expr;
public:
     OptionGroupWriteMemory() : OptionGroup() {}
 
     ~OptionGroupWriteMemory() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_write_option_table);
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_arg,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          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);
+        m_infile.SetFile(option_value, true);
         if (!m_infile.Exists()) {
           m_infile.Clear();
           error.SetErrorStringWithFormat("input file does not exist: '%s'",
-                                         option_arg);
+                                         option_value.str().c_str());
         }
         break;
 
       case 'o': {
-        bool success;
-        m_infile_offset = StringConvert::ToUInt64(option_arg, 0, 0, &success);
-        if (!success) {
+        if (option_value.getAsInteger(0, m_infile_offset)) {
+          m_infile_offset = 0;
           error.SetErrorStringWithFormat("invalid offset string '%s'",
-                                         option_arg);
+                                         option_value.str().c_str());
         }
       } break;
 
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                        short_option);
         break;
       }
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_infile.Clear();
       m_infile_offset = 0;
     }
 
     FileSpec m_infile;
     off_t m_infile_offset;

lldb/trunk/source/Commands/CommandObjectPlatform.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Utils.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-static mode_t ParsePermissionString(const char *permissions) {
-  if (strlen(permissions) != 9)
+static mode_t ParsePermissionString(const char *) = delete;
+
+static mode_t ParsePermissionString(llvm::StringRef permissions) {
+  if (permissions.size() != 9)
     return (mode_t)(-1);
   bool user_r, user_w, user_x, group_r, group_w, group_x, world_r, world_w,
       world_x;
 
   user_r = (permissions[0] == 'r');
   user_w = (permissions[1] == 'w');
   user_x = (permissions[2] == 'x');
 
static OptionDefinition g_permissions_options[] = {
   {LLDB_OPT_SET_ALL, false, "group-write",         'W', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Allow group to write."},
   {LLDB_OPT_SET_ALL, false, "group-exec",          'X', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Allow group to execute."},
   {LLDB_OPT_SET_ALL, false, "world-read",          'd', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Allow world to read."},
   {LLDB_OPT_SET_ALL, false, "world-write",         't', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Allow world to write."},
   {LLDB_OPT_SET_ALL, false, "world-exec",          'e', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,              "Allow world to execute."},
     // clang-format on
 };
 
-class OptionPermissions : public lldb_private::OptionGroup {
+class OptionPermissions : public OptionGroup {
 public:
   OptionPermissions() {}
 
   ~OptionPermissions() override = default;
 
   lldb_private::Error
-  SetOptionValue(uint32_t option_idx, const char *option_arg,
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                  ExecutionContext *execution_context) override {
     Error error;
     char short_option = (char)GetDefinitions()[option_idx].short_option;
     switch (short_option) {
     case 'v': {
-      bool ok;
-      uint32_t perms = StringConvert::ToUInt32(option_arg, 777, 8, &ok);
-      if (!ok)
+      if (option_arg.getAsInteger(8, m_permissions)) {
+        m_permissions = 0777;
         error.SetErrorStringWithFormat("invalid value for permissions: %s",
-                                       option_arg);
-      else
-        m_permissions = perms;
+                                       option_arg.str().c_str());
+      }
+
     } break;
     case 's': {
       mode_t perms = ParsePermissionString(option_arg);
       if (perms == (mode_t)-1)
         error.SetErrorStringWithFormat("invalid value for permissions: %s",
-                                       option_arg);
+                                       option_arg.str().c_str());
       else
         m_permissions = perms;
     } break;
     case 'r':
       m_permissions |= lldb::eFilePermissionsUserRead;
       break;
     case 'w':
       m_permissions |= lldb::eFilePermissionsUserWrite;

lldb/trunk/source/Commands/CommandObjectRegister.cpp

public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       set_indexes.Clear();
       dump_all_sets.Clear();
       alternate_name.Clear();
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_value,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = GetDefinitions()[option_idx].short_option;
       switch (short_option) {
       case 's': {
         OptionValueSP value_sp(OptionValueUInt64::Create(option_value, error));
         if (value_sp)
           set_indexes.AppendValue(value_sp);
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
 
       default:
         error.SetErrorStringWithFormat("unrecognized short option '%c'",
                                        short_option);
         break;
       }
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     // Instance variables to hold the values for command options.
     OptionValueArray set_indexes;
     OptionValueBoolean dump_all_sets;
     OptionValueBoolean alternate_name;
   };
 
   OptionGroupOptions m_option_group;

lldb/trunk/source/Commands/CommandObjectTarget.cpp

public:
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 's':
         m_sort_order = (SortOrder)Args::StringToOptionEnum(
-            option_arg, GetDefinitions()[option_idx].enum_values,
-            eSortOrderNone, error);
+            llvm::StringRef::withNullAsEmpty(option_arg),
+            GetDefinitions()[option_idx].enum_values, eSortOrderNone, error);
         break;
 
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
       return error;

lldb/trunk/source/Commands/CommandObjectThread.cpp

Error SetOptionValue(uint32_t option_idx, const char *option_arg,
         m_class_name.clear();
         m_class_name.assign(option_arg);
         break;
 
       case 'm': {
         OptionEnumValueElement *enum_values =
             GetDefinitions()[option_idx].enum_values;
         m_run_mode = (lldb::RunMode)Args::StringToOptionEnum(
-            option_arg, enum_values, eOnlyDuringStepping, error);
+            option_strref, enum_values, eOnlyDuringStepping, error);
       } break;
 
       case 'e': {
         if (strcmp(option_arg, "block") == 0) {
           m_end_line_is_block_end = 1;
           break;
         }
         uint32_t tmp_end_line =
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
           error.SetErrorStringWithFormat("invalid frame index '%s'",
                                          option_arg);
         }
         break;
       case 'm': {
         OptionEnumValueElement *enum_values =
             GetDefinitions()[option_idx].enum_values;
         lldb::RunMode run_mode = (lldb::RunMode)Args::StringToOptionEnum(
-            option_arg, enum_values, eOnlyDuringStepping, error);
+            llvm::StringRef::withNullAsEmpty(option_arg), enum_values,
+            eOnlyDuringStepping, error);
 
         if (error.Success()) {
           if (run_mode == eAllThreads)
             m_stop_others = false;
           else
             m_stop_others = true;
         }
       } break;

lldb/trunk/source/Commands/CommandObjectType.cpp

void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_cascade = true;
       m_skip_pointers = false;
       m_skip_references = false;
       m_regex = false;
       m_category.assign("default");
       m_custom_type_name.clear();
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_value,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option =
           g_type_format_add_options[option_idx].short_option;
       bool success;
 
       switch (short_option) {
       case 'C':
-        m_cascade = Args::StringToBoolean(
-            llvm::StringRef::withNullAsEmpty(option_value), true, &success);
+        m_cascade = Args::StringToBoolean(option_value, true, &success);
         if (!success)
           error.SetErrorStringWithFormat("invalid value for cascade: %s",
-                                         option_value);
+                                         option_value.str().c_str());
         break;
       case 'p':
         m_skip_pointers = true;
         break;
       case 'w':
         m_category.assign(option_value);
         break;
       case 'r':
         m_skip_references = true;
         break;
       case 'x':
         m_regex = true;
         break;
       case 't':
         m_custom_type_name.assign(option_value);
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     // Instance variables to hold the values for command options.
 
     bool m_cascade;
     bool m_skip_references;
     bool m_skip_pointers;
     bool m_regex;
     std::string m_category;
Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       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);
+        m_language = Language::GetLanguageTypeFromString(
+            llvm::StringRef::withNullAsEmpty(option_arg));
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
       return error;
CommandOptions()
                               lldb::eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
-
+      llvm::StringRef option_strref =
+          llvm::StringRef::withNullAsEmpty(option_arg);
       switch (short_option) {
       case 'w':
-        m_category_regex.SetCurrentValue(option_arg);
+        m_category_regex.SetCurrentValue(option_strref);
         m_category_regex.SetOptionWasSet();
         break;
       case 'l':
-        error = m_category_language.SetValueFromString(option_arg);
+        error = m_category_language.SetValueFromString(option_strref);
         if (error.Success())
           m_category_language.SetOptionWasSet();
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
public:
 
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'e':
-        m_define_enabled.SetValueFromString("true");
+        m_define_enabled.SetValueFromString(llvm::StringRef("true"));
         break;
       case 'l':
-        error = m_cate_language.SetValueFromString(option_arg);
+        error = m_cate_language.SetValueFromString(
+            llvm::StringRef::withNullAsEmpty(option_arg));
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
         break;
       }
 
       return error;
public:
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'l':
         if (option_arg) {
-          m_language = Language::GetLanguageTypeFromString(option_arg);
+          m_language = Language::GetLanguageTypeFromString(
+              llvm::StringRef::withNullAsEmpty(option_arg));
           if (m_language == lldb::eLanguageTypeUnknown)
             error.SetErrorStringWithFormat("unrecognized language '%s'",
                                            option_arg);
         }
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
public:
     Error SetOptionValue(uint32_t option_idx, const char *option_arg,
                          ExecutionContext *execution_context) override {
       Error error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'l':
         if (option_arg) {
-          m_language = Language::GetLanguageTypeFromString(option_arg);
+          m_language = Language::GetLanguageTypeFromString(
+              llvm::StringRef::withNullAsEmpty(option_arg));
           if (m_language == lldb::eLanguageTypeUnknown)
             error.SetErrorStringWithFormat("unrecognized language '%s'",
                                            option_arg);
         }
         break;
       default:
         error.SetErrorStringWithFormat("unrecognized option '%c'",
                                        short_option);
CommandOptions()
         : OptionGroup(), m_show_help(false), m_language(eLanguageTypeUnknown) {}
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_lookup_options);
     }
 
-    Error SetOptionValue(uint32_t option_idx, const char *option_value,
+    Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                          ExecutionContext *execution_context) override {
       Error error;
 
       const int short_option = g_type_lookup_options[option_idx].short_option;
 
       switch (short_option) {
       case 'h':
         m_show_help = true;
         break;
 
       case 'l':
         m_language = Language::GetLanguageTypeFromString(option_value);
         break;
 
       default:
         error.SetErrorStringWithFormat("invalid short option character '%c'",
                                        short_option);
         break;
       }
 
       return error;
     }
+    Error SetOptionValue(uint32_t, const char *, ExecutionContext *) = delete;
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_help = false;
       m_language = eLanguageTypeUnknown;
     }
 
     // Options table: Required for subclasses of Options.
 

lldb/trunk/source/Commands/CommandObjectWatchpointCommand.cpp

Error SetOptionValue(uint32_t option_idx, const char *option_arg,
       switch (short_option) {
       case 'o':
         m_use_one_liner = true;
         m_one_liner = option_arg;
         break;
 
       case 's':
         m_script_language = (lldb::ScriptLanguage)Args::StringToOptionEnum(
-            option_arg, GetDefinitions()[option_idx].enum_values,
-            eScriptLanguageNone, error);
+            llvm::StringRef::withNullAsEmpty(option_arg),
+            GetDefinitions()[option_idx].enum_values, eScriptLanguageNone,
+            error);
 
         m_use_script_language = (m_script_language == eScriptLanguagePython ||
                                  m_script_language == eScriptLanguageDefault);
         break;
 
       case 'e': {
         bool success = false;
         m_stop_on_error = Args::StringToBoolean(

lldb/trunk/source/Interpreter/Args.cpp

if (pos != std::string::npos) {
       safe_arg.insert(pos, 1, '\\');
       prev_pos = pos + 2;
     } else
       break;
   }
   return safe_arg.c_str();
 }
 
-int64_t Args::StringToOptionEnum(const char *s,
+int64_t Args::StringToOptionEnum(llvm::StringRef s,
                                  OptionEnumValueElement *enum_values,
                                  int32_t fail_value, Error &error) {
-  if (enum_values) {
-    if (s && s[0]) {
-      for (int i = 0; enum_values[i].string_value != nullptr; i++) {
-        if (strstr(enum_values[i].string_value, s) ==
-            enum_values[i].string_value) {
-          error.Clear();
-          return enum_values[i].value;
-        }
-      }
-    }
+  if (!enum_values) {
+    error.SetErrorString("invalid enumeration argument");
+    return fail_value;
+
+  if (s.empty()) {
+    error.SetErrorString("empty enumeration string");
+    return fail_value;
+
+  for (int i = 0; enum_values[i].string_value != nullptr; i++) {
+    llvm::StringRef this_enum(enum_values[i].string_value);
+    if (this_enum.startswith(s))
+      return enum_values[i].value;
 
-    StreamString strm;
-    strm.PutCString("invalid enumeration value, valid values are: ");
-    for (int i = 0; enum_values[i].string_value != nullptr; i++) {
-      strm.Printf("%s\"%s\"", i > 0 ? ", " : "", enum_values[i].string_value);
-    }
-    error.SetErrorString(strm.GetData());
-  } else {
-    error.SetErrorString("invalid enumeration argument");
-  }
   return fail_value;
 }
 
 lldb::ScriptLanguage
 Args::StringToScriptLanguage(llvm::StringRef s, lldb::ScriptLanguage fail_value,
                              bool *success_ptr) {
   if (success_ptr)
     *success_ptr = true;

lldb/trunk/source/Interpreter/OptionGroupArchitecture.cpp

bool OptionGroupArchitecture::GetArchitecture(Platform *platform,
   if (m_arch_str.empty())
     arch.Clear();
   else
     arch.SetTriple(m_arch_str.c_str(), platform);
   return arch.IsValid();
 }
 
 Error OptionGroupArchitecture::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef 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;

lldb/trunk/source/Interpreter/OptionGroupBoolean.cpp

OptionGroupBoolean::OptionGroupBoolean(uint32_t usage_mask, bool required,
   m_option_definition.completion_type = 0;
   m_option_definition.argument_type = eArgTypeBoolean;
   m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupBoolean::~OptionGroupBoolean() {}
 
 Error OptionGroupBoolean::SetOptionValue(uint32_t option_idx,
-                                         const char *option_arg,
+                                         llvm::StringRef option_value,
                                          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);
+    error = m_value.SetValueFromString(option_value);
   }
   return error;
 }
 
 void OptionGroupBoolean::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupFile.cpp

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

lldb/trunk/source/Interpreter/OptionGroupFormat.cpp

if (m_count.GetDefaultValue() < UINT64_MAX)
       return result;
     else
       return result.take_front(3);
   }
   return result.take_front(2);
 }
 
 Error OptionGroupFormat::SetOptionValue(uint32_t option_idx,
-                                        const char *option_arg,
+                                        llvm::StringRef 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);
     break;
 
   case 'c':
     if (m_count.GetDefaultValue() == 0) {
       error.SetErrorString("--count option is disabled");
     } else {
       error = m_count.SetValueFromString(option_arg);
       if (m_count.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat("invalid --count option value '%s'",
-                                       option_arg);
+                                       option_arg.str().c_str());
     }
     break;
 
   case 's':
     if (m_byte_size.GetDefaultValue() == 0) {
       error.SetErrorString("--size option is disabled");
     } else {
       error = m_byte_size.SetValueFromString(option_arg);
       if (m_byte_size.GetCurrentValue() == 0)
         error.SetErrorStringWithFormat("invalid --size option value '%s'",
-                                       option_arg);
+                                       option_arg.str().c_str());
     }
     break;
 
   case 'G': {
-    char *end = nullptr;
-    const char *gdb_format_cstr = option_arg;
     uint64_t count = 0;
-    if (::isdigit(gdb_format_cstr[0])) {
-      count = strtoull(gdb_format_cstr, &end, 0);
-
-      if (option_arg != end)
-        gdb_format_cstr =
-            end; // We have a valid count, advance the string position
-      else
-        count = 0;
-    }
+    llvm::StringRef gdb_format_str = option_arg;
+    gdb_format_str.consumeInteger(0, count);
 
     Format format = eFormatDefault;
     uint32_t byte_size = 0;
 
-    while (ParserGDBFormatLetter(execution_context, gdb_format_cstr[0], format,
+    while (!gdb_format_str.empty() &&
+           ParserGDBFormatLetter(execution_context, gdb_format_str[0], format,
                                  byte_size)) {
-      ++gdb_format_cstr;
+      gdb_format_str = gdb_format_str.drop_front();
     }
 
-    // We the first character of the "gdb_format_cstr" is not the
+    // We the first character of the "gdb_format_str" 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] ||
+    if (!gdb_format_str.empty() ||
         (format == eFormatInvalid && byte_size == 0 && count == 0)) {
       // Nothing got set correctly
       error.SetErrorStringWithFormat("invalid gdb format string '%s'",
-                                     option_arg);
+                                     option_arg.str().c_str());
       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(execution_context, m_prev_gdb_format, format,

lldb/trunk/source/Interpreter/OptionGroupOutputFile.cpp

static OptionDefinition g_option_table[] = {
      "Append to the file specified with '--outfile <path>'."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupOutputFile::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Error OptionGroupOutputFile::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef 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;

lldb/trunk/source/Interpreter/OptionGroupPlatform.cpp

 llvm::ArrayRef<OptionDefinition> OptionGroupPlatform::GetDefinitions() {
   llvm::ArrayRef<OptionDefinition> result(g_option_table);
   if (m_include_platform_option)
     return result;
   return result.drop_front();
 }
 
 Error OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
-                                          const char *option_arg,
+                                          llvm::StringRef 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;
-  llvm::StringRef option_strref(option_arg ? option_arg : "");
 
   switch (short_option) {
   case 'p':
     m_platform_name.assign(option_arg);
     break;
 
   case 'v':
-    if (!Args::StringToVersion(option_strref, m_os_version_major,
+    if (!Args::StringToVersion(option_arg, m_os_version_major,
                                m_os_version_minor, m_os_version_update))
-      error.SetErrorStringWithFormat("invalid version string '%s'", option_arg);
+      error.SetErrorStringWithFormat("invalid version string '%s'",
+                                     option_arg.str().c_str());
     break;
 
   case 'b':
-    m_sdk_build.SetCString(option_arg);
+    m_sdk_build.SetString(option_arg);
     break;
 
   case 'S':
-    m_sdk_sysroot.SetCString(option_arg);
+    m_sdk_sysroot.SetString(option_arg);
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
   return error;
 }

lldb/trunk/source/Interpreter/OptionGroupString.cpp

OptionGroupString::OptionGroupString(uint32_t usage_mask, bool required,
   m_option_definition.completion_type = completion_type;
   m_option_definition.argument_type = argument_type;
   m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupString::~OptionGroupString() {}
 
 Error OptionGroupString::SetOptionValue(uint32_t option_idx,
-                                        const char *option_arg,
+                                        llvm::StringRef option_arg,
                                         ExecutionContext *execution_context) {
   Error error(m_value.SetValueFromString(option_arg));
   return error;
 }
 
 void OptionGroupString::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupUInt64.cpp

OptionGroupUInt64::OptionGroupUInt64(uint32_t usage_mask, bool required,
   m_option_definition.completion_type = completion_type;
   m_option_definition.argument_type = argument_type;
   m_option_definition.usage_text = usage_text;
 }
 
 OptionGroupUInt64::~OptionGroupUInt64() {}
 
 Error OptionGroupUInt64::SetOptionValue(uint32_t option_idx,
-                                        const char *option_arg,
+                                        llvm::StringRef option_arg,
                                         ExecutionContext *execution_context) {
   Error error(m_value.SetValueFromString(option_arg));
   return error;
 }
 
 void OptionGroupUInt64::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_value.Clear();
 }

lldb/trunk/source/Interpreter/OptionGroupUUID.cpp

static OptionDefinition g_option_table[] = {
      nullptr, nullptr, 0, eArgTypeNone, "A module UUID value."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Error OptionGroupUUID::SetOptionValue(uint32_t option_idx,
-                                      const char *option_arg,
+                                      llvm::StringRef 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())

lldb/trunk/source/Interpreter/OptionGroupValueObjectDisplay.cpp

static OptionDefinition g_option_table[] = {
      "many values."}};
 
 llvm::ArrayRef<OptionDefinition>
 OptionGroupValueObjectDisplay::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Error OptionGroupValueObjectDisplay::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {
   Error error;
   const int short_option = g_option_table[option_idx].short_option;
   bool success = false;
 
-  auto option_strref = llvm::StringRef::withNullAsEmpty(option_arg);
-
   switch (short_option) {
   case 'd': {
     int32_t result;
     result =
         Args::StringToOptionEnum(option_arg, g_dynamic_value_types, 2, error);
     if (error.Success())
       use_dynamic = (lldb::DynamicValueType)result;
   } break;
Error OptionGroupValueObjectDisplay::SetOptionValue(
   case 'R':
     be_raw = true;
     break;
   case 'A':
     ignore_cap = true;
     break;
 
   case 'D':
-    max_depth = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0, &success);
-    if (!success)
-      error.SetErrorStringWithFormat("invalid max depth '%s'", option_arg);
+    if (option_arg.getAsInteger(0, max_depth)) {
+      max_depth = UINT32_MAX;
+      error.SetErrorStringWithFormat("invalid max depth '%s'",
+                                     option_arg.str().c_str());
+    }
     break;
 
   case 'Z':
-    elem_count = StringConvert::ToUInt32(option_arg, UINT32_MAX, 0, &success);
-    if (!success)
-      error.SetErrorStringWithFormat("invalid element count '%s'", option_arg);
+    if (option_arg.getAsInteger(0, elem_count)) {
+      elem_count = UINT32_MAX;
+      error.SetErrorStringWithFormat("invalid element count '%s'",
+                                     option_arg.str().c_str());
+    }
     break;
 
   case 'P':
-    ptr_depth = StringConvert::ToUInt32(option_arg, 0, 0, &success);
-    if (!success)
-      error.SetErrorStringWithFormat("invalid pointer depth '%s'", option_arg);
+    if (option_arg.getAsInteger(0, ptr_depth)) {
+      ptr_depth = 0;
+      error.SetErrorStringWithFormat("invalid pointer depth '%s'",
+                                     option_arg.str().c_str());
+    }
     break;
 
   case 'Y':
-    if (option_arg) {
-      no_summary_depth = StringConvert::ToUInt32(option_arg, 0, 0, &success);
-      if (!success)
-        error.SetErrorStringWithFormat("invalid pointer depth '%s'",
-                                       option_arg);
-    } else
+    if (option_arg.getAsInteger(0, no_summary_depth)) {
       no_summary_depth = 1;
+      error.SetErrorStringWithFormat("invalid pointer depth '%s'",
+                                     option_arg.str().c_str());
+    }
     break;
 
   case 'S':
-    use_synth = Args::StringToBoolean(option_strref, true, &success);
+    use_synth = Args::StringToBoolean(option_arg, true, &success);
     if (!success)
-      error.SetErrorStringWithFormat("invalid synthetic-type '%s'", option_arg);
+      error.SetErrorStringWithFormat("invalid synthetic-type '%s'",
+                                     option_arg.str().c_str());
     break;
 
   case 'V':
-    run_validator = Args::StringToBoolean(option_strref, true, &success);
+    run_validator = Args::StringToBoolean(option_arg, true, &success);
     if (!success)
-      error.SetErrorStringWithFormat("invalid validate '%s'", option_arg);
+      error.SetErrorStringWithFormat("invalid validate '%s'",
+                                     option_arg.str().c_str());
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;

lldb/trunk/source/Interpreter/OptionGroupVariable.cpp

 
 OptionGroupVariable::OptionGroupVariable(bool show_frame_options)
     : OptionGroup(), include_frame_options(show_frame_options),
       summary(ValidateNamedSummary), summary_string(ValidateSummaryString) {}
 
 OptionGroupVariable::~OptionGroupVariable() {}
 
 Error OptionGroupVariable::SetOptionValue(uint32_t option_idx,
-                                          const char *option_arg,
+                                          llvm::StringRef option_arg,
                                           ExecutionContext *execution_context) {
   Error error;
   if (!include_frame_options)
     option_idx += 3;
   const int short_option = g_variable_options[option_idx].short_option;
   switch (short_option) {
   case 'r':
     use_regex = true;

lldb/trunk/source/Interpreter/OptionGroupWatchpoint.cpp

bool OptionGroupWatchpoint::IsWatchSizeSupported(uint32_t watch_size) {
   return false;
 }
 
 OptionGroupWatchpoint::OptionGroupWatchpoint() : OptionGroup() {}
 
 OptionGroupWatchpoint::~OptionGroupWatchpoint() {}
 
 Error OptionGroupWatchpoint::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef 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;
     tmp_watch_type = (WatchType)Args::StringToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);

lldb/trunk/source/Interpreter/OptionValue.cpp

const char *OptionValue::GetStringValue(const char *fail_value) const {
   if (option_value)
     return option_value->GetCurrentValue();
   return fail_value;
 }
 
 bool OptionValue::SetStringValue(const char *new_value) {
   OptionValueString *option_value = GetAsString();
   if (option_value) {
-    option_value->SetCurrentValue(new_value);
+    option_value->SetCurrentValue(llvm::StringRef::withNullAsEmpty(new_value));
     return true;
   }
   return false;
 }
 
 uint64_t OptionValue::GetUInt64Value(uint64_t fail_value) const {
   const OptionValueUInt64 *option_value = GetAsUInt64();
   if (option_value)
case 1u << eTypeUInt64:
     value_sp.reset(new OptionValueUInt64());
     break;
   case 1u << eTypeUUID:
     value_sp.reset(new OptionValueUUID());
     break;
   }
 
   if (value_sp)
-    error = value_sp->SetValueFromString(value_cstr, eVarSetOperationAssign);
+    error = value_sp->SetValueFromString(
+        llvm::StringRef::withNullAsEmpty(value_cstr), eVarSetOperationAssign);
   else
     error.SetErrorString("unsupported type mask");
   return value_sp;
 }
 
 bool OptionValue::DumpQualifiedName(Stream &strm) const {
   bool dumped_something = false;
   lldb::OptionValueSP m_parent_sp(m_parent_wp.lock());

lldb/trunk/source/Interpreter/OptionValueChar.cpp

if (success) {
       m_current_value = char_value;
       m_value_was_set = true;
     } else
       error.SetErrorStringWithFormat("'%s' cannot be longer than 1 character",
                                      value.str().c_str());
   } break;
 
   default:
-    error = OptionValue::SetValueFromString(value.str().c_str(), op);
+    error = OptionValue::SetValueFromString(value, op);
     break;
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueChar::DeepCopy() const {
   return OptionValueSP(new OptionValueChar(*this));
 }

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

 
 Error OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
                                          VarSetOperationType op,
                                          const char *name, const char *value) {
   Error error;
   const bool will_modify = true;
   lldb::OptionValueSP value_sp(GetSubValue(exe_ctx, name, will_modify, error));
   if (value_sp)
-    error = value_sp->SetValueFromString(value, op);
+    error = value_sp->SetValueFromString(
+        llvm::StringRef::withNullAsEmpty(value), op);
   else {
     if (error.AsCString() == nullptr)
       error.SetErrorStringWithFormat("invalid value path '%s'", name);
   }
   return error;
 }
 
 lldb::OptionValueSP
 OptionValueDictionary::GetValueForKey(const ConstString &key) const {
   lldb::OptionValueSP value_sp;
   collection::const_iterator pos = m_values.find(key);
   if (pos != m_values.end())
     value_sp = pos->second;
   return value_sp;
 }
 
-const char *
-OptionValueDictionary::GetStringValueForKey(const ConstString &key) {
-  collection::const_iterator pos = m_values.find(key);
-  if (pos != m_values.end()) {
-    OptionValueString *string_value = pos->second->GetAsString();
-    if (string_value)
-      return string_value->GetCurrentValue();
-  }
-  return nullptr;
-}
-
-bool OptionValueDictionary::SetStringValueForKey(const ConstString &key,
-                                                 const char *value,
-                                                 bool can_replace) {
-  collection::const_iterator pos = m_values.find(key);
-  if (pos != m_values.end()) {
-    if (!can_replace)
-      return false;
-    if (pos->second->GetType() == OptionValue::eTypeString) {
-      pos->second->SetValueFromString(value);
-      return true;
-    }
-  }
-  m_values[key] = OptionValueSP(new OptionValueString(value));
-  return true;
-}
-
 bool OptionValueDictionary::SetValueForKey(const ConstString &key,
                                            const lldb::OptionValueSP &value_sp,
                                            bool can_replace) {
   // Make sure the value_sp object is allowed to contain
   // values of the type passed in...
   if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
     if (!can_replace) {
       collection::const_iterator pos = m_values.find(key);

lldb/trunk/source/Interpreter/OptionValueString.cpp

if (m_validator) {
       error = m_validator(value_str.c_str(), m_validator_baton);
       if (error.Fail())
         return error;
     }
     m_value_was_set = true;
     if (m_options.Test(eOptionEncodeCharacterEscapeSequences)) {
       Args::EncodeEscapeSequences(value_str.c_str(), m_current_value);
     } else {
-      SetCurrentValue(value_str.c_str());
+      SetCurrentValue(value_str);
     }
     NotifyValueChanged();
     break;
   }
   return error;
 }
 
 lldb::OptionValueSP OptionValueString::DeepCopy() const {
   return OptionValueSP(new OptionValueString(*this));
 }
 
-Error OptionValueString::SetCurrentValue(const char *value) {
+Error OptionValueString::SetCurrentValue(llvm::StringRef value) {
   if (m_validator) {
-    Error error(m_validator(value, m_validator_baton));
+    Error error(m_validator(value.str().c_str(), m_validator_baton));
     if (error.Fail())
       return error;
   }
-  if (value && value[0])
-    m_current_value.assign(value);
-  else
-    m_current_value.clear();
   return Error();
 }
 
 Error OptionValueString::AppendToCurrentValue(const char *value) {
   if (value && value[0]) {
     if (m_validator) {
       std::string new_value(m_current_value);
       new_value.append(value);

lldb/trunk/source/Interpreter/OptionValueUInt64.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Stream.h"
 #include "lldb/Host/StringConvert.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-lldb::OptionValueSP OptionValueUInt64::Create(const char *value_cstr,
+lldb::OptionValueSP OptionValueUInt64::Create(llvm::StringRef value_str,
                                               Error &error) {
   lldb::OptionValueSP value_sp(new OptionValueUInt64());
-  error = value_sp->SetValueFromString(value_cstr);
+  error = value_sp->SetValueFromString(value_str);
   if (error.Fail())
     value_sp.reset();
   return value_sp;
 }
 
 void OptionValueUInt64::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                   uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)

lldb/trunk/source/Interpreter/Options.cpp

Error OptionGroupOptions::SetOptionValue(uint32_t option_idx,
                                          const char *option_value,
                                          ExecutionContext *execution_context) {
   // After calling OptionGroupOptions::Append(...), you must finalize the groups
   // by calling OptionGroupOptions::Finlize()
   assert(m_did_finalize);
   Error error;
   if (option_idx < m_option_infos.size()) {
     error = m_option_infos[option_idx].option_group->SetOptionValue(
-        m_option_infos[option_idx].option_index, option_value,
-        execution_context);
+        m_option_infos[option_idx].option_index,
+        llvm::StringRef::withNullAsEmpty(option_value), execution_context);
 
   } else {
     error.SetErrorString("invalid option index"); // Shouldn't happen...
   }
   return error;
 }
 
 void OptionGroupOptions::OptionParsingStarting(

lldb/trunk/source/Interpreter/Property.cpp

case OptionValue::eTypeEnum:
     // "definition.default_cstr_value" as a string value that represents the
     // default
     // value.
     {
       OptionValueEnumeration *enum_value = new OptionValueEnumeration(
           definition.enum_values, definition.default_uint_value);
       m_value_sp.reset(enum_value);
       if (definition.default_cstr_value) {
-        if (enum_value->SetValueFromString(definition.default_cstr_value)
+        if (enum_value
+                ->SetValueFromString(
+                    llvm::StringRef(definition.default_cstr_value))
                 .Success()) {
           enum_value->SetDefaultValue(enum_value->GetCurrentValue());
           // Call Clear() since we don't want the value to appear as
           // having been set since we called SetValueFromString() above.
           // Clear will set the current value to the default and clear
           // the boolean that says that the value has been set.
           enum_value->Clear();
         }

lldb/trunk/source/Target/Language.cpp

struct language_name_pair language_names[] = {
     // Now synonyms, in arbitrary order
     {"objc", eLanguageTypeObjC},
     {"objc++", eLanguageTypeObjC_plus_plus},
     {"pascal", eLanguageTypePascal83}};
 
 static uint32_t num_languages =
     sizeof(language_names) / sizeof(struct language_name_pair);
 
-LanguageType Language::GetLanguageTypeFromString(const char *s) {
-  return GetLanguageTypeFromString(llvm::StringRef(s ? s : ""));
-}
-
 LanguageType Language::GetLanguageTypeFromString(llvm::StringRef string) {
   for (const auto &L : language_names) {
     if (string.equals_lower(L.name))
       return static_cast<LanguageType>(L.type);
   }
 
   return eLanguageTypeUnknown;
 }

lldb/trunk/source/Target/Platform.cpp

void OptionGroupPlatformRSync::OptionParsingStarting(
   m_rsync = false;
   m_rsync_opts.clear();
   m_rsync_prefix.clear();
   m_ignores_remote_hostname = false;
 }
 
 lldb_private::Error
 OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
-                                         const char *option_arg,
+                                         llvm::StringRef 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;
 

 void OptionGroupPlatformSSH::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_ssh = false;
   m_ssh_opts.clear();
 }
 
 lldb_private::Error
 OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
-                                       const char *option_arg,
+                                       llvm::StringRef 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;
 

 }
 
 void OptionGroupPlatformCaching::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_cache_dir.clear();
 }
 
 lldb_private::Error OptionGroupPlatformCaching::SetOptionValue(
-    uint32_t option_idx, const char *option_arg,
+    uint32_t option_idx, llvm::StringRef 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;