[lldb][NFC] Replace most uses of StringConvert in LLDB with LLVM's to_integer

[teemperor]

Summary

This replaces most uses of LLDB's own String to int/float conversion implementation with
LLVM's to_integer. The only remaining code in LLDB that now still uses StringConvert is
debugserver which can't use LLVM code, so I'll leave that part for a future commit.

Unlike the other StringConvert patch this doesn't try to add any missing error handling
but just does a NFC refactoring to to_integer.

[teemperor]

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

1508

Just to get ahead of people pointing this c_str() call out: This is just used as we keep inserting null terminators into the value string (as a replacement for doing substr()), so we actually only want to pass this new substring to to_integer and not all of value. I'll clean this (and the similar code below) up in a follow-up patch.

[shafik]

lldb/source/Interpreter/OptionValueArray.cpp

209

I am curious why we are using size_t here but it looks like we are using uint32_t in other places.

lldb/source/Interpreter/OptionValueFileSpecList.cpp

132

We use uint32_t to hold the result of m_current_value.GetSize() above, but size_t here.

These should be consistent.

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

4643

Should this be LLDB_INVALID_ADDRESS?

[JDevlieghere]

lldb/source/Host/common/Socket.cpp

286

Consider inlining the call?

lldb/source/Host/common/Socket.cpp

 //===-- Socket.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Socket.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/SocketAddress.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/Error.h"
static RegularExpression g_regex(
       llvm::StringRef("([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)"));
   llvm::SmallVector<llvm::StringRef, 3> matches;
   if (g_regex.Execute(host_and_port, &matches)) {
     host_str = matches[1].str();
     port_str = matches[2].str();
     // IPv6 addresses are wrapped in [] when specified with ports
     if (host_str.front() == '[' && host_str.back() == ']')
       host_str = host_str.substr(1, host_str.size() - 2);
-    bool ok = false;
-    port = StringConvert::ToUInt32(port_str.c_str(), UINT32_MAX, 10, &ok);
+    bool ok = llvm::to_integer(port_str, port);
     if (ok && port <= UINT16_MAX) {
       if (error_ptr)
         error_ptr->Clear();
       return true;
     }
     // port is too large
     if (error_ptr)
       error_ptr->SetErrorStringWithFormat(

lldb/source/Host/common/XML.cpp

 //===-- XML.cpp -----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h> /* atof */
 
 #include "lldb/Host/Config.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/XML.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark-- XMLDocument
 
 XMLDocument::XMLDocument() : m_document(nullptr) {}

 
 bool XMLNode::GetAttributeValueAsUnsigned(const char *name, uint64_t &value,
                                           uint64_t fail_value, int base) const {
 #if LLDB_ENABLE_LIBXML2
   llvm::StringRef str_value = GetAttributeValue(name, "");
 #else
   llvm::StringRef str_value;
 #endif
-  bool success = false;
-  value = StringConvert::ToUInt64(str_value.data(), fail_value, base, &success);
-  return success;
+  if (!llvm::to_integer(str_value, value, base)) {
+    value = fail_value;
+    return false;
+  }
+  return true;
 }
 
 void XMLNode::ForEachChildNode(NodeCallback const &callback) const {
 #if LLDB_ENABLE_LIBXML2
   if (IsValid())
     GetChild().ForEachSiblingNode(callback);
 #endif
 }

 
 bool XMLNode::GetElementTextAsUnsigned(uint64_t &value, uint64_t fail_value,
                                        int base) const {
   bool success = false;
 #if LLDB_ENABLE_LIBXML2
   if (IsValid()) {
     std::string text;
     if (GetElementText(text))
-      value = StringConvert::ToUInt64(text.c_str(), fail_value, base, &success);
+      success = llvm::to_integer(text, value, base);
   }
 #endif
   if (!success)
     value = fail_value;
   return success;
 }
 
 bool XMLNode::GetElementTextAsFloat(double &value, double fail_value) const {

lldb/source/Interpreter/OptionValueArray.cpp

 //===-- OptionValueArray.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueArray.h"
 
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueArray::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                  uint32_t dump_mask) {
Status OptionValueArray::SetArgs(const Args &args, VarSetOperationType op) {
   switch (op) {
   case eVarSetOperationInvalid:
     error.SetErrorString("unsupported operation");
     break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
     if (argc > 1) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx))
+        idx = UINT32_MAX;
       const uint32_t count = GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid insert array index %u, index must be 0 through %u", idx,
             count);
       } else {
         if (op == eVarSetOperationInsertAfter)
           ++idx;
Status OptionValueArray::SetArgs(const Args &args, VarSetOperationType op) {
 
   case eVarSetOperationRemove:
     if (argc > 0) {
       const uint32_t size = m_values.size();
       std::vector<int> remove_indexes;
       bool all_indexes_valid = true;
       size_t i;
       for (i = 0; i < argc; ++i) {
-        const size_t idx =
-            StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
-        if (idx >= size) {
+        size_t idx;
+        if (!llvm::to_integer(args.GetArgumentAtIndex(i), idx) || idx >= size) {
           all_indexes_valid = false;
           break;
         } else
           remove_indexes.push_back(idx);
       }
 
       if (all_indexes_valid) {
         size_t num_remove_indexes = remove_indexes.size();
case eVarSetOperationRemove:
     break;
 
   case eVarSetOperationClear:
     Clear();
     break;
 
   case eVarSetOperationReplace:
     if (argc > 1) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx))
+        idx = UINT32_MAX;
       const uint32_t count = GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid replace array index %u, index must be 0 through %u", idx,
             count);
       } else {
         for (size_t i = 1; i < argc; ++i, ++idx) {
           lldb::OptionValueSP value_sp(CreateValueFromCStringForTypeMask(

lldb/source/Interpreter/OptionValueFileSpecList.cpp

 //===-- OptionValueFileSpecList.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueFileSpecList::DumpValue(const ExecutionContext *exe_ctx,
                                         Stream &strm, uint32_t dump_mask) {
Status OptionValueFileSpecList::SetValueFromString(llvm::StringRef value,
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
     if (argc > 1) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx))
+        idx = UINT32_MAX;
       const uint32_t count = m_current_value.GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid file list index %u, index must be 0 through %u", idx,
             count);
       } else {
         for (size_t i = 1; i < argc; ++i, ++idx) {
           FileSpec file(args.GetArgumentAtIndex(i));
if (argc > 0) {
       error.SetErrorString(
           "assign operation takes at least one file path argument");
     }
     break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
     if (argc > 1) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx))
+        idx = UINT32_MAX;
       const uint32_t count = m_current_value.GetSize();
       if (idx > count) {
         error.SetErrorStringWithFormat(
             "invalid insert file list index %u, index must be 0 through %u",
             idx, count);
       } else {
         if (op == eVarSetOperationInsertAfter)
           ++idx;
case eVarSetOperationInsertAfter:
     }
     break;
 
   case eVarSetOperationRemove:
     if (argc > 0) {
       std::vector<int> remove_indexes;
       bool all_indexes_valid = true;
       size_t i;
+      const std::size_t size = m_current_value.GetSize();
       for (i = 0; all_indexes_valid && i < argc; ++i) {
-        const int idx =
-            StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
-        if (idx == INT32_MAX)
+        size_t idx;
+        if (!llvm::to_integer(args.GetArgumentAtIndex(i), idx) || idx >= size) {
           all_indexes_valid = false;
-        else
+          break;
+        } else
           remove_indexes.push_back(idx);
       }
 
       if (all_indexes_valid) {
         size_t num_remove_indexes = remove_indexes.size();
         if (num_remove_indexes) {
           // Sort and then erase in reverse so indexes are always valid
           llvm::sort(remove_indexes.begin(), remove_indexes.end());

lldb/source/Interpreter/OptionValuePathMappings.cpp

 //===-- OptionValuePathMappings.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValuePathMappings.h"
 
 #include "lldb/Host/FileSystem.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 namespace {
 static bool VerifyPathExists(const char *path) {
case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
     // Must be at least one index + 1 pair of paths, and the pair count must be
     // even
     if (argc >= 3 && (((argc - 1) & 1) == 0)) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
       const uint32_t count = m_path_mappings.GetSize();
-      if (idx > count) {
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx) || idx >= count) {
         error.SetErrorStringWithFormat(
-            "invalid file list index %u, index must be 0 through %u", idx,
-            count);
+            "invalid file list index '%s', index must be 0 through %u",
+            args.GetArgumentAtIndex(0), count);
       } else {
         bool changed = false;
         for (size_t i = 1; i < argc; idx++, i += 2) {
           const char *orginal_path = args.GetArgumentAtIndex(i);
           const char *replace_path = args.GetArgumentAtIndex(i + 1);
           if (VerifyPathExists(replace_path)) {
             ConstString a(orginal_path);
             ConstString b(replace_path);
case eVarSetOperationAppend:
     }
     break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
     // Must be at least one index + 1 pair of paths, and the pair count must be
     // even
     if (argc >= 3 && (((argc - 1) & 1) == 0)) {
-      uint32_t idx =
-          StringConvert::ToUInt32(args.GetArgumentAtIndex(0), UINT32_MAX);
       const uint32_t count = m_path_mappings.GetSize();
-      if (idx > count) {
+      uint32_t idx;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(0), idx) || idx > count) {
         error.SetErrorStringWithFormat(
-            "invalid file list index %u, index must be 0 through %u", idx,
-            count);
+            "invalid file list index '%s', index must be 0 through %u",
+            args.GetArgumentAtIndex(0), count);
       } else {
         bool changed = false;
         if (op == eVarSetOperationInsertAfter)
           ++idx;
         for (size_t i = 1; i < argc; i += 2) {
           const char *orginal_path = args.GetArgumentAtIndex(i);
           const char *replace_path = args.GetArgumentAtIndex(i + 1);
           if (VerifyPathExists(replace_path)) {
case eVarSetOperationInsertAfter:
     } else {
       error.SetErrorString("insert operation takes an array index followed by "
                            "one or more path pairs");
     }
     break;
 
   case eVarSetOperationRemove:
     if (argc > 0) {
-      std::vector<int> remove_indexes;
+      std::vector<size_t> remove_indexes;
       for (size_t i = 0; i < argc; ++i) {
-        int idx =
-            StringConvert::ToSInt32(args.GetArgumentAtIndex(i), INT32_MAX);
-        if (idx < 0 || idx >= (int)m_path_mappings.GetSize()) {
+        size_t idx;
+        if (!llvm::to_integer(args.GetArgumentAtIndex(i), idx) ||
+            idx >= m_path_mappings.GetSize()) {
           error.SetErrorStringWithFormat(
               "invalid array index '%s', aborting remove operation",
               args.GetArgumentAtIndex(i));
           break;
         } else
           remove_indexes.push_back(idx);
       }
 

lldb/source/Interpreter/OptionValueSInt64.cpp

 //===-- OptionValueSInt64.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueSInt64.h"
 
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void OptionValueSInt64::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                   uint32_t dump_mask) {
   // printf ("%p: DumpValue (exe_ctx=%p, strm, mask) m_current_value = %"
Status OptionValueSInt64::SetValueFromString(llvm::StringRef value_ref,
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
-    bool success = false;
-    std::string value_str = value_ref.trim().str();
-    int64_t value = StringConvert::ToSInt64(value_str.c_str(), 0, 0, &success);
-    if (success) {
+    value_ref = value_ref.trim();
+    int64_t value;
+    if (llvm::to_integer(value_ref, value)) {
       if (value >= m_min_value && value <= m_max_value) {
         m_value_was_set = true;
         m_current_value = value;
         NotifyValueChanged();
       } else
         error.SetErrorStringWithFormat(
             "%" PRIi64 " is out of range, valid values must be between %" PRIi64
             " and %" PRIi64 ".",

lldb/source/Interpreter/OptionValueUInt64.cpp

 //===-- OptionValueUInt64.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueUInt64.h"
 
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::OptionValueSP OptionValueUInt64::Create(llvm::StringRef value_str,
                                               Status &error) {
   lldb::OptionValueSP value_sp(new OptionValueUInt64());
Status OptionValueUInt64::SetValueFromString(llvm::StringRef value_ref,
   switch (op) {
   case eVarSetOperationClear:
     Clear();
     NotifyValueChanged();
     break;
 
   case eVarSetOperationReplace:
   case eVarSetOperationAssign: {
-    bool success = false;
-    std::string value_str = value_ref.trim().str();
-    uint64_t value = StringConvert::ToUInt64(value_str.c_str(), 0, 0, &success);
-    if (success) {
+    value_ref = value_ref.trim();
+    uint64_t value;
+    if (llvm::to_integer(value_ref, value)) {
       m_value_was_set = true;
       m_current_value = value;
       NotifyValueChanged();
     } else {
       error.SetErrorStringWithFormat("invalid uint64_t string value: '%s'",
-                                     value_str.c_str());
+                                     value_ref.str().c_str());
     }
   } break;
 
   case eVarSetOperationInsertBefore:
   case eVarSetOperationInsertAfter:
   case eVarSetOperationRemove:
   case eVarSetOperationAppend:
   case eVarSetOperationInvalid:

lldb/source/Interpreter/Property.cpp

 //===-- Property.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/Property.h"
 
 #include "lldb/Core/UserSettingsController.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Target/Language.h"
 
 #include <memory>
 
 using namespace lldb;
Property::Property(const PropertyDefinition &definition)
   case OptionValue::eTypeRegex:
     // "definition.default_uint_value" is used to the regular expression flags
     // "definition.default_cstr_value" the default regular expression value
     // value.
     m_value_sp =
         std::make_shared<OptionValueRegex>(definition.default_cstr_value);
     break;
 
-  case OptionValue::eTypeSInt64:
+  case OptionValue::eTypeSInt64: {
     // "definition.default_uint_value" is the default integer value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
-    m_value_sp = std::make_shared<OptionValueSInt64>(
-        definition.default_cstr_value
-            ? StringConvert::ToSInt64(definition.default_cstr_value)
-            : definition.default_uint_value);
+    int64_t value;
+    if (definition.default_cstr_value) {
+      if (!llvm::to_integer(definition.default_cstr_value, value))
+        value = 0;
+    } else {
+      value = definition.default_uint_value;
+    }
+    m_value_sp = std::make_shared<OptionValueSInt64>(value);
     break;
+  }
 
-  case OptionValue::eTypeUInt64:
+  case OptionValue::eTypeUInt64: {
     // "definition.default_uint_value" is the default unsigned integer value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
-    m_value_sp = std::make_shared<OptionValueUInt64>(
-        definition.default_cstr_value
-            ? StringConvert::ToUInt64(definition.default_cstr_value)
-            : definition.default_uint_value);
+    uint64_t value;
+    if (definition.default_cstr_value) {
+      if (!llvm::to_integer(definition.default_cstr_value, value))
+        value = 0;
+    } else {
+      value = definition.default_uint_value;
+    }
+    m_value_sp = std::make_shared<OptionValueUInt64>(value);
     break;
-
+  }
   case OptionValue::eTypeUUID:
     // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
     // "definition.default_cstr_value" can contain a default UUID value
     {
       UUID uuid;
       if (definition.default_cstr_value)
         uuid.SetFromStringRef(definition.default_cstr_value);
       m_value_sp = std::make_shared<OptionValueUUID>(uuid);

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

 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
if (argc < 1) {
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
-    bool success = false;
-    const uint32_t id =
-        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
-    if (!success) {
+    uint32_t id;
+    if (!llvm::to_integer(id_cstr, id)) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     Stream *output_stream_p = nullptr;
     std::unique_ptr<Stream> output_stream_storage;
if (argc != 2) {
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
-    bool success = false;
-    const uint32_t id =
-        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
-    if (!success) {
+    uint32_t id;
+    if (!llvm::to_integer(id_cstr, id)) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     const char *path = command.GetArgumentAtIndex(1);
     bool loaded = runtime->LoadAllocation(result.GetOutputStream(), id, path,
if (argc != 2) {
       return false;
     }
 
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
 
     const char *id_cstr = command.GetArgumentAtIndex(0);
-    bool success = false;
-    const uint32_t id =
-        StringConvert::ToUInt32(id_cstr, UINT32_MAX, 0, &success);
-    if (!success) {
+    uint32_t id;
+    if (!llvm::to_integer(id_cstr, id)) {
       result.AppendErrorWithFormat("invalid allocation id argument '%s'",
                                    id_cstr);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     const char *path = command.GetArgumentAtIndex(1);
     bool saved = runtime->SaveAllocation(result.GetOutputStream(), id, path,

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 //===-- PlatformAndroid.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/UriParser.h"
 
 #include "AdbClient.h"
 #include "PlatformAndroid.h"
 #include "PlatformAndroidRemoteGDBServer.h"
 #include "lldb/Target/Target.h"
uint32_t PlatformAndroid::GetSdkVersion() {
 
   if (error.Fail() || version_string.empty()) {
     Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM);
     LLDB_LOGF(log, "Get SDK version failed. (error: %s, output: %s)",
               error.AsCString(), version_string.c_str());
     return 0;
   }
 
-  m_sdk_version = StringConvert::ToUInt32(version_string.c_str());
+  if (!llvm::to_integer(version_string, m_sdk_version))
+    m_sdk_version = 0;
   return m_sdk_version;
 }
 
 Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                                            const FileSpec &dst_file_spec) {
   // For oat file we can try to fetch additional debug info from the device
   ConstString extension = module_sp->GetFileSpec().GetFileNameExtension();
   if (extension != ".oat" && extension != ".odex")

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 //===-- DynamicRegisterInfo.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DynamicRegisterInfo.h"
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/FormatManager.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "lldb/Utility/StructuredData.h"
 
 using namespace lldb;
 using namespace lldb_private;
if (reg_info.byte_offset == UINT32_MAX) {
         // ends at
         static RegularExpression g_bitfield_regex(
             llvm::StringRef("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]"));
         llvm::SmallVector<llvm::StringRef, 4> matches;
         if (g_bitfield_regex.Execute(slice_str, &matches)) {
           std::string reg_name_str = matches[1].str();
           std::string msbit_str = matches[2].str();
           std::string lsbit_str = matches[3].str();
-          const uint32_t msbit =
-              StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
-          const uint32_t lsbit =
-              StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
-          if (msbit != UINT32_MAX && lsbit != UINT32_MAX) {
+          uint32_t msbit = 0;
+          uint32_t lsbit = 0;
+          if (llvm::to_integer(msbit_str, msbit) &&
+              llvm::to_integer(lsbit_str, lsbit)) {
             if (msbit > lsbit) {
               const uint32_t msbyte = msbit / 8;
               const uint32_t lsbyte = lsbit / 8;
 
               ConstString containing_reg_name(reg_name_str);
 
               const RegisterInfo *containing_reg_info =
                   GetRegisterInfo(containing_reg_name);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include "lldb/Host/Config.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Host/Socket.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
if (error.Success() &&
         char port_cstr[PATH_MAX] = {0};
         port_cstr[0] = '\0';
         size_t num_bytes = sizeof(port_cstr);
         // Read port from pipe with 10 second timeout.
         error = socket_pipe.ReadWithTimeout(
             port_cstr, num_bytes, std::chrono::seconds{10}, num_bytes);
         if (error.Success() && (port != nullptr)) {
           assert(num_bytes > 0 && port_cstr[num_bytes - 1] == '\0');
-          uint16_t child_port = StringConvert::ToUInt32(port_cstr, 0);
+          uint16_t child_port;
+          if (!llvm::to_integer(port_cstr, child_port))
+            child_port = 0;
           if (*port == 0 || *port == child_port) {
             *port = child_port;
             LLDB_LOGF(log,
                       "GDBRemoteCommunication::%s() "
                       "debugserver listens %u port",
                       __FUNCTION__, *port);
           } else {
             LLDB_LOGF(log,

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

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/PseudoTerminal.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
static size_t SplitCommaSeparatedRegisterNumberString(
     const llvm::StringRef &comma_separated_regiter_numbers,
     std::vector<uint32_t> &regnums, int base) {
   regnums.clear();
   std::pair<llvm::StringRef, llvm::StringRef> value_pair;
   value_pair.second = comma_separated_regiter_numbers;
   do {
     value_pair = value_pair.second.split(',');
     if (!value_pair.first.empty()) {
-      uint32_t reg = StringConvert::ToUInt32(value_pair.first.str().c_str(),
-                                             LLDB_INVALID_REGNUM, base);
-      if (reg != LLDB_INVALID_REGNUM)
+      uint32_t reg;
+      if (llvm::to_integer(value_pair.first, reg, base))
         regnums.push_back(reg);
     }
   } while (!value_pair.second.empty());
   return regnums.size();
 }
 
 void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
   if (!force && m_register_info.GetNumRegisters() > 0)

 size_t
 ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue(std::string &value) {
   m_thread_ids.clear();
   size_t comma_pos;
   lldb::tid_t tid;
   while ((comma_pos = value.find(',')) != std::string::npos) {
     value[comma_pos] = '\0';
     // thread in big endian hex
-    tid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_THREAD_ID, 16);
-    if (tid != LLDB_INVALID_THREAD_ID)
+    if (llvm::to_integer(value.c_str(), tid, 16))
       m_thread_ids.push_back(tid);
     value.erase(0, comma_pos + 1);
   }
-  tid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_THREAD_ID, 16);
-  if (tid != LLDB_INVALID_THREAD_ID)
+  if (llvm::to_integer(value.c_str(), tid, 16))
     m_thread_ids.push_back(tid);
   return m_thread_ids.size();
 }
 
 size_t
 ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue(std::string &value) {
   m_thread_pcs.clear();
   size_t comma_pos;
   lldb::addr_t pc;
   while ((comma_pos = value.find(',')) != std::string::npos) {
     value[comma_pos] = '\0';
-    pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16);
-    if (pc != LLDB_INVALID_ADDRESS)
+    if (llvm::to_integer(value.c_str(), pc, 16))
       m_thread_pcs.push_back(pc);
     value.erase(0, comma_pos + 1);
   }
-  pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16);
-  if (pc != LLDB_INVALID_THREAD_ID)
+  if (llvm::to_integer(value.c_str(), pc, 16))
     m_thread_pcs.push_back(pc);
   return m_thread_pcs.size();
 }
 
 bool ProcessGDBRemote::UpdateThreadIDList() {
   std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
 
   if (m_jthreadsinfo_sp) {
if (key == g_key_tid) {
       description = std::string(object->GetStringValue());
     } else if (key == g_key_registers) {
       StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
 
       if (registers_dict) {
         registers_dict->ForEach(
             [&expedited_register_map](ConstString key,
                                       StructuredData::Object *object) -> bool {
-              const uint32_t reg =
-                  StringConvert::ToUInt32(key.GetCString(), UINT32_MAX, 10);
-              if (reg != UINT32_MAX)
+              uint32_t reg;
+              if (llvm::to_integer(key.GetStringRef(), reg, 10))
                 expedited_register_map[reg] =
                     std::string(object->GetStringValue());
               return true; // Keep iterating through all array items
             });
       }
     } else if (key == g_key_memory) {
       StructuredData::Array *array = object->GetAsArray();
       if (array) {
feature_node.ForEachChildElementWithName(
                                    &reg_name, &alt_name, &set_name, &value_regs,
                                    &invalidate_regs, &encoding_set, &format_set,
                                    &reg_info, &reg_offset, &dwarf_opcode_bytes](
                                       const llvm::StringRef &name,
                                       const llvm::StringRef &value) -> bool {
           if (name == "name") {
             reg_name.SetString(value);
           } else if (name == "bitsize") {
-            reg_info.byte_size =
-                StringConvert::ToUInt32(value.data(), 0, 0) / CHAR_BIT;
+            uint32_t bit_size;
+            if (llvm::to_integer(value, bit_size))
+              reg_info.byte_size = bit_size / CHAR_BIT;
+            else
+              reg_info.byte_size = 0;
           } else if (name == "type") {
             gdb_type = value.str();
           } else if (name == "group") {
             gdb_group = value.str();
           } else if (name == "regnum") {
-            const uint32_t regnum =
-                StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
-            if (regnum != LLDB_INVALID_REGNUM) {
+            uint32_t regnum;
+            if (llvm::to_integer(value, regnum))
               reg_info.kinds[eRegisterKindProcessPlugin] = regnum;
-            }
           } else if (name == "offset") {
-            reg_offset = StringConvert::ToUInt32(value.data(), UINT32_MAX, 0);
+            if (!llvm::to_integer(value, reg_offset))
+              reg_offset = UINT32_MAX;
           } else if (name == "altname") {
             alt_name.SetString(value);
           } else if (name == "encoding") {
             encoding_set = true;
             reg_info.encoding = Args::StringToEncoding(value, eEncodingUint);
           } else if (name == "format") {
             format_set = true;
             Format format = eFormatInvalid;
feature_node.ForEachChildElementWithName(
               reg_info.format = eFormatVectorOfUInt32;
             else if (value == "vector-float32")
               reg_info.format = eFormatVectorOfFloat32;
             else if (value == "vector-uint64")
               reg_info.format = eFormatVectorOfUInt64;
             else if (value == "vector-uint128")
               reg_info.format = eFormatVectorOfUInt128;
           } else if (name == "group_id") {
-            const uint32_t set_id =
-                StringConvert::ToUInt32(value.data(), UINT32_MAX, 0);
+            uint32_t set_id;
+            if (!llvm::to_integer(value, set_id))
+              set_id = UINT32_MAX;
             RegisterSetMap::const_iterator pos =
                 target_info.reg_set_map.find(set_id);
             if (pos != target_info.reg_set_map.end())
               set_name = pos->second.name;
           } else if (name == "gcc_regnum" || name == "ehframe_regnum") {
-            reg_info.kinds[eRegisterKindEHFrame] =
-                StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
+            uint32_t reg;
+            if (!llvm::to_integer(value, reg))
+              reg = LLDB_INVALID_REGNUM;
+            reg_info.kinds[eRegisterKindEHFrame] = reg;
           } else if (name == "dwarf_regnum") {
-            reg_info.kinds[eRegisterKindDWARF] =
-                StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
+            uint32_t reg;
+            if (!llvm::to_integer(value, reg))
+              reg = LLDB_INVALID_REGNUM;
+            reg_info.kinds[eRegisterKindDWARF] = reg;
           } else if (name == "generic") {
             reg_info.kinds[eRegisterKindGeneric] =
                 Args::StringToGenericRegister(value);
           } else if (name == "value_regnums") {
             SplitCommaSeparatedRegisterNumberString(value, value_regs, 0);
           } else if (name == "invalidate_regnums") {
             SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
           } else if (name == "dynamic_size_dwarf_expr_bytes") {
if (target_node) {
           node.ForEachChildElementWithName(
               "group", [&target_info](const XMLNode &node) -> bool {
                 uint32_t set_id = UINT32_MAX;
                 RegisterSetInfo set_info;
 
                 node.ForEachAttribute(
                     [&set_id, &set_info](const llvm::StringRef &name,
                                          const llvm::StringRef &value) -> bool {
-                      if (name == "id")
-                        set_id = StringConvert::ToUInt32(value.data(),
-                                                         UINT32_MAX, 0);
+                      if (name == "id") {
+                        if (!llvm::to_integer(value, set_id))
+                          set_id = UINT32_MAX;
+                      }
                       if (name == "name")
                         set_info.name = ConstString(value);
                       return true; // Keep iterating through all attributes
                     });
 
                 if (set_id != UINT32_MAX)
                   target_info.reg_set_map[set_id] = set_info;
                 return true; // Keep iterating through all "group" elements
if (can_use_svr4 && comm.GetQXferLibrariesSVR4ReadSupported()) {
     if (!root_element)
       return llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "Error finding library-list-svr4 xml element");
 
     // main link map structure
     llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
     if (!main_lm.empty()) {
-      list.m_link_map =
-          StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
+      if (!llvm::to_integer(main_lm, list.m_link_map))
+        list.m_link_map = 0;
     }
 
     root_element.ForEachChildElementWithName(
         "library", [log, &list](const XMLNode &library) -> bool {
 
           LoadedModuleInfoList::LoadedModuleInfo module;
 
           library.ForEachAttribute(
               [&module](const llvm::StringRef &name,
                         const llvm::StringRef &value) -> bool {
 
                 if (name == "name")
                   module.set_name(value.str());
                 else if (name == "lm") {
                   // the address of the link_map struct.
-                  module.set_link_map(StringConvert::ToUInt64(
-                      value.data(), LLDB_INVALID_ADDRESS, 0));
+                  lldb::addr_t link_map;
+                  if (!llvm::to_integer(value, link_map))
+                    link_map = LLDB_INVALID_ADDRESS;
+                  module.set_link_map(link_map);
                 } else if (name == "l_addr") {
                   // the displacement as read from the field 'l_addr' of the
                   // link_map struct.
-                  module.set_base(StringConvert::ToUInt64(
-                      value.data(), LLDB_INVALID_ADDRESS, 0));
+                  lldb::addr_t base;
+                  if (!llvm::to_integer(value, base))
+                    base = LLDB_INVALID_ADDRESS;
+                  module.set_base(base);
                   // base address is always a displacement, not an absolute
                   // value.
                   module.set_base_is_offset(true);
                 } else if (name == "l_ld") {
+                  lldb::addr_t dynamic;
+                  if (!llvm::to_integer(value, dynamic))
+                    dynamic = LLDB_INVALID_ADDRESS;
                   // the memory address of the libraries PT_DYNAMIC section.
-                  module.set_dynamic(StringConvert::ToUInt64(
-                      value.data(), LLDB_INVALID_ADDRESS, 0));
+                  module.set_dynamic(dynamic);
                 }
 
                 return true; // Keep iterating over all properties of "library"
               });
 
           if (log) {
             std::string name;
             lldb::addr_t lm = 0, base = 0, ld = 0;
root_element.ForEachChildElementWithName(
           module.set_name(name.str());
 
           // The base address of a given library will be the address of its
           // first section. Most remotes send only one section for Windows
           // targets for example.
           const XMLNode &section =
               library.FindFirstChildElementWithName("section");
           llvm::StringRef address = section.GetAttributeValue("address");
-          module.set_base(
-              StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS, 0));
+          lldb::addr_t base;
+          if (!llvm::to_integer(address, base))
+            base = LLDB_INVALID_ADDRESS;
+          module.set_base(base);
           // These addresses are absolute values.
           module.set_base_is_offset(false);
 
           if (log) {
             std::string name;
             lldb::addr_t base = 0;
             bool base_is_offset;
             module.get_name(name);

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 //===-- DWARFUnit.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFUnit.h"
 
 #include "lldb/Core/Module.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Object/Error.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
if (producer_cstr) {
       if (llvm_gcc_regex.Execute(llvm::StringRef(producer_cstr))) {
         m_producer = eProducerLLVMGCC;
       } else if (strstr(producer_cstr, "clang")) {
         static RegularExpression g_clang_version_regex(
             llvm::StringRef("clang-([0-9]+)\\.([0-9]+)\\.([0-9]+)"));
         llvm::SmallVector<llvm::StringRef, 4> matches;
         if (g_clang_version_regex.Execute(llvm::StringRef(producer_cstr),
                                           &matches)) {
-          m_producer_version_major =
-              StringConvert::ToUInt32(matches[1].str().c_str(), UINT32_MAX, 10);
-          m_producer_version_minor =
-              StringConvert::ToUInt32(matches[2].str().c_str(), UINT32_MAX, 10);
-          m_producer_version_update =
-              StringConvert::ToUInt32(matches[3].str().c_str(), UINT32_MAX, 10);
+          if (!llvm::to_integer(matches[1], m_producer_version_major))
+            m_producer_version_major = UINT32_MAX;
+          if (!llvm::to_integer(matches[2], m_producer_version_minor))
+            m_producer_version_minor = UINT32_MAX;
+          if (!llvm::to_integer(matches[3], m_producer_version_update))
+            m_producer_version_update = UINT32_MAX;
         }
         m_producer = eProducerClang;
       } else if (strstr(producer_cstr, "GNU"))
         m_producer = eProducerGCC;
     }
   }
   if (m_producer == eProducerInvalid)
     m_producer = eProcucerOther;

lldb/source/Symbol/SymbolContext.cpp

 //===-- SymbolContext.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/SymbolContext.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
bool SymbolContextSpecifier::AddSpecification(const char *spec_string,
   case eFileSpecified:
     // CompUnits can't necessarily be resolved here, since an inlined function
     // might show up in a number of CompUnits.  Instead we just convert to a
     // FileSpec and store it away.
     m_file_spec_up.reset(new FileSpec(spec_string));
     m_type |= eFileSpecified;
     break;
   case eLineStartSpecified:
-    m_start_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
+    return_value = llvm::to_integer(spec_string, m_start_line);
     if (return_value)
       m_type |= eLineStartSpecified;
     break;
   case eLineEndSpecified:
-    m_end_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
+    return_value = llvm::to_integer(spec_string, m_end_line);
     if (return_value)
       m_type |= eLineEndSpecified;
     break;
   case eFunctionSpecified:
     m_function_spec.assign(spec_string);
     m_type |= eFunctionSpecified;
     break;
   case eClassOrNamespaceSpecified:

lldb/source/Target/UnixSignals.cpp

 //===-- UnixSignals.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/UnixSignals.h"
 #include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "Plugins/Process/Utility/LinuxSignals.h"
 #include "Plugins/Process/Utility/MipsLinuxSignals.h"
 #include "Plugins/Process/Utility/NetBSDSignals.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Utility/ArchSpec.h"
 
 using namespace lldb_private;
 
 UnixSignals::Signal::Signal(const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias)
     : m_name(name), m_alias(alias), m_description(),
int32_t UnixSignals::GetSignalNumberFromName(const char *name) const {
   for (pos = m_signals.begin(); pos != end; pos++) {
     if ((const_name == pos->second.m_name) ||
         (const_name == pos->second.m_alias) ||
         (const_name == GetShortName(pos->second.m_name)) ||
         (const_name == GetShortName(pos->second.m_alias)))
       return pos->first;
   }
 
-  const int32_t signo =
-      StringConvert::ToSInt32(name, LLDB_INVALID_SIGNAL_NUMBER, 0);
-  if (signo != LLDB_INVALID_SIGNAL_NUMBER)
+  int32_t signo;
+  if (llvm::to_integer(name, signo))
     return signo;
   return LLDB_INVALID_SIGNAL_NUMBER;
 }
 
 int32_t UnixSignals::GetFirstSignalNumber() const {
   if (m_signals.empty())
     return LLDB_INVALID_SIGNAL_NUMBER;
 

lldb/unittests/debugserver/RNBSocketTest.cpp

 
 #include <arpa/inet.h>
 #include <sys/sysctl.h>
 #include <unistd.h>
 
 #include "RNBDefs.h"
 #include "RNBSocket.h"
 #include "lldb/Host/Socket.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 
 std::string hello = "Hello, world!";
 std::string goodbye = "Goodbye!";