[lldb] Replace StringConvert with llvm::to_integer when parsing integer values in CommandObjects

[teemperor]

Summary

This replaces the current use of LLDB's own StringConvert with LLVM's to_integer which
has a less error-prone API and doesn't use special 'error values' to designate parsing problems.

Where needed I also added missing error handling code that prints a parsing error instead of continuing
with the error value returned from StringConvert (which either gave a cryptic error message or just took
the error value performed an incorrect action with it. For example, frame recognizer delete -1
just deleted the frame recognizer at index 0).

[labath]

cool

lldb/test/API/commands/process/signal/TestProcessSignal.py

11

@no_debug_info_test

lldb/source/Commands/CommandObjectFrame.cpp

 //===-- CommandObjectFrame.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 "CommandObjectFrame.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Interpreter/OptionGroupVariable.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolContext.h"
bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     if (command.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat("'%s' takes zero or one arguments.\n",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    uint32_t recognizer_id =
-        StringConvert::ToUInt32(command.GetArgumentAtIndex(0), 0, 0);
+    uint32_t recognizer_id;
+    if (!llvm::to_integer(command.GetArgumentAtIndex(0), recognizer_id)) {
+      result.AppendErrorWithFormat("'%s' is not a valid recognizer id.\n",
+                                   command.GetArgumentAtIndex(0));
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
 
     StackFrameRecognizerManager::RemoveRecognizerWithID(recognizer_id);
     result.SetStatus(eReturnStatusSuccessFinishResult);
     return result.Succeeded();
   }
 };
 
 class CommandObjectFrameRecognizerList : public CommandObjectParsed {
CommandObjectFrameRecognizerInfo(CommandInterpreter &interpreter)
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectFrameRecognizerInfo() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
+    const char *frame_index_str = command.GetArgumentAtIndex(0);
+    uint32_t frame_index;
+    if (!llvm::to_integer(frame_index_str, frame_index)) {
+      result.AppendErrorWithFormat("'%s' is not a valid frame index.",
+                                   frame_index_str);
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
+
     Process *process = m_exe_ctx.GetProcessPtr();
     if (process == nullptr) {
       result.AppendError("no process");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     Thread *thread = m_exe_ctx.GetThreadPtr();
     if (thread == nullptr) {
       result.AppendError("no thread");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
     if (command.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat(
           "'%s' takes exactly one frame index argument.\n", m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    uint32_t frame_index =
-        StringConvert::ToUInt32(command.GetArgumentAtIndex(0), 0, 0);
     StackFrameSP frame_sp = thread->GetStackFrameAtIndex(frame_index);
     if (!frame_sp) {
       result.AppendErrorWithFormat("no frame with index %u", frame_index);
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     auto recognizer =

lldb/source/Commands/CommandObjectPlatform.cpp

 //===-- CommandObjectPlatform.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 "CommandObjectPlatform.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandOptionValidators.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
public:
   ~CommandObjectPlatformFClose() override = default;
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       std::string cmd_line;
       args.GetCommandString(cmd_line);
-      const lldb::user_id_t fd =
-          StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
+      lldb::user_id_t fd;
+      if (!llvm::to_integer(cmd_line, fd)) {
+        result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.\n",
+                                      cmd_line);
+        result.SetStatus(eReturnStatusFailed);
+        return result.Succeeded();
+      }
       Status error;
       bool success = platform_sp->CloseFile(fd, error);
       if (success) {
         result.AppendMessageWithFormat("file %" PRIu64 " closed.\n", fd);
         result.SetStatus(eReturnStatusSuccessFinishResult);
       } else {
         result.AppendError(error.AsCString());
         result.SetStatus(eReturnStatusFailed);
public:
   ~CommandObjectPlatformFRead() override = default;
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       std::string cmd_line;
       args.GetCommandString(cmd_line);
-      const lldb::user_id_t fd =
-          StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
+      lldb::user_id_t fd;
+      if (!llvm::to_integer(cmd_line, fd)) {
+        result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.\n",
+                                      cmd_line);
+        result.SetStatus(eReturnStatusFailed);
+        return result.Succeeded();
+      }
       std::string buffer(m_options.m_count, 0);
       Status error;
       uint32_t retcode = platform_sp->ReadFile(
           fd, m_options.m_offset, &buffer[0], m_options.m_count, error);
       result.AppendMessageWithFormat("Return = %d\n", retcode);
       result.AppendMessageWithFormat("Data = \"%s\"\n", buffer.c_str());
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
public:
 
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
     if (platform_sp) {
       std::string cmd_line;
       args.GetCommandString(cmd_line);
       Status error;
-      const lldb::user_id_t fd =
-          StringConvert::ToUInt64(cmd_line.c_str(), UINT64_MAX);
+      lldb::user_id_t fd;
+      if (!llvm::to_integer(cmd_line, fd)) {
+        result.AppendErrorWithFormatv("'{0}' is not a valid file descriptor.",
+                                      cmd_line);
+        result.SetStatus(eReturnStatusFailed);
+        return result.Succeeded();
+      }
       uint32_t retcode =
           platform_sp->WriteFile(fd, m_options.m_offset, &m_options.m_data[0],
                                  m_options.m_data.size(), error);
       result.AppendMessageWithFormat("Return = %d\n", retcode);
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       result.AppendError("no platform currently selected\n");
       result.SetStatus(eReturnStatusFailed);

lldb/source/Commands/CommandObjectProcess.cpp

 //===-- CommandObjectProcess.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 "CommandObjectProcess.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"

 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Process *process = m_exe_ctx.GetProcessPtr();
 
     if (command.GetArgumentCount() == 1) {
       int signo = LLDB_INVALID_SIGNAL_NUMBER;
 
       const char *signal_name = command.GetArgumentAtIndex(0);
-      if (::isxdigit(signal_name[0]))
-        signo =
-            StringConvert::ToSInt32(signal_name, LLDB_INVALID_SIGNAL_NUMBER, 0);
-      else
+      if (::isxdigit(signal_name[0])) {
+        if (!llvm::to_integer(signal_name, signo))
+          signo = LLDB_INVALID_SIGNAL_NUMBER;
+      } else
         signo = process->GetUnixSignals()->GetSignalNumberFromName(signal_name);
 
       if (signo == LLDB_INVALID_SIGNAL_NUMBER) {
         result.AppendErrorWithFormat("Invalid signal argument '%s'.\n",
                                      command.GetArgumentAtIndex(0));
         result.SetStatus(eReturnStatusFailed);
       } else {
         Status error(process->Signal(signo));
bool VerifyCommandOptionValue(const std::string &option, int &real_value) {
     bool tmp_value = OptionArgParser::ToBoolean(option, false, &success);
 
     if (success && tmp_value)
       real_value = 1;
     else if (success && !tmp_value)
       real_value = 0;
     else {
       // If the value isn't 'true' or 'false', it had better be 0 or 1.
-      real_value = StringConvert::ToUInt32(option.c_str(), 3);
+      if (!llvm::to_integer(option, real_value))
+        real_value = 3;
       if (real_value != 0 && real_value != 1)
         okay = false;
     }
 
     return okay;
   }
 
   void PrintSignalHeader(Stream &str) {

lldb/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupArchitecture.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupFile.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupString.h"
CommandObjectTargetSelect(CommandInterpreter &interpreter)
             "Select a target as the current target by target index.", nullptr) {
   }
 
   ~CommandObjectTargetSelect() override = default;
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() == 1) {
-      bool success = false;
       const char *target_idx_arg = args.GetArgumentAtIndex(0);
-      uint32_t target_idx =
-          StringConvert::ToUInt32(target_idx_arg, UINT32_MAX, 0, &success);
-      if (success) {
+      uint32_t target_idx;
+      if (llvm::to_integer(target_idx_arg, target_idx)) {
         TargetList &target_list = GetDebugger().GetTargetList();
         const uint32_t num_targets = target_list.GetNumTargets();
         if (target_idx < num_targets) {
           TargetSP target_sp(target_list.GetTargetAtIndex(target_idx));
           if (target_sp) {
             Stream &strm = result.GetOutputStream();
             target_list.SetSelectedTarget(target_sp.get());
             bool show_stopped_process_status = false;
public:
   ~CommandObjectTargetModulesSearchPathsInsert() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     size_t argc = command.GetArgumentCount();
     // check for at least 3 arguments and an odd number of parameters
     if (argc >= 3 && argc & 1) {
-      bool success = false;
-
-      uint32_t insert_idx = StringConvert::ToUInt32(
-          command.GetArgumentAtIndex(0), UINT32_MAX, 0, &success);
+      uint32_t insert_idx;
 
-      if (!success) {
+      if (!llvm::to_integer(command.GetArgumentAtIndex(0), insert_idx)) {
         result.AppendErrorWithFormat(
             "<index> parameter is not an integer: '%s'.\n",
             command.GetArgumentAtIndex(0));
         result.SetStatus(eReturnStatusFailed);
         return result.Succeeded();
       }
 
       // shift off the index
if (search_using_module_spec) {
                   return false;
                 }
 
                 for (size_t i = 0; i < argc; i += 2) {
                   const char *sect_name = args.GetArgumentAtIndex(i);
                   const char *load_addr_cstr = args.GetArgumentAtIndex(i + 1);
                   if (sect_name && load_addr_cstr) {
                     ConstString const_sect_name(sect_name);
-                    bool success = false;
-                    addr_t load_addr = StringConvert::ToUInt64(
-                        load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
-                    if (success) {
+                    addr_t load_addr;
+                    if (llvm::to_integer(load_addr_cstr, load_addr)) {
                       SectionSP section_sp(
                           section_list->FindSectionByName(const_sect_name));
                       if (section_sp) {
                         if (section_sp->IsThreadSpecific()) {
                           result.AppendErrorWithFormat(
                               "thread specific sections are not yet "
                               "supported (section '%s')\n",
                               sect_name);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (num_args == 0) {
       if (!m_interpreter.Confirm("Delete all stop hooks?", true)) {
         result.SetStatus(eReturnStatusFailed);
         return false;
       } else {
         target.RemoveAllStopHooks();
       }
     } else {
-      bool success;
       for (size_t i = 0; i < num_args; i++) {
-        lldb::user_id_t user_id = StringConvert::ToUInt32(
-            command.GetArgumentAtIndex(i), 0, 0, &success);
-        if (!success) {
+        lldb::user_id_t user_id;
+        if (!llvm::to_integer(command.GetArgumentAtIndex(i), user_id)) {
           result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
                                        command.GetArgumentAtIndex(i));
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
-        success = target.RemoveStopHookByID(user_id);
-        if (!success) {
+        if (!target.RemoveStopHookByID(user_id)) {
           result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",
                                        command.GetArgumentAtIndex(i));
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
       }
     }
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // FIXME: see if we can use the breakpoint id style parser?
     size_t num_args = command.GetArgumentCount();
     bool success;
 
     if (num_args == 0) {
       target.SetAllStopHooksActiveState(m_enable);
     } else {
       for (size_t i = 0; i < num_args; i++) {
-        lldb::user_id_t user_id = StringConvert::ToUInt32(
-            command.GetArgumentAtIndex(i), 0, 0, &success);
-        if (!success) {
+        lldb::user_id_t user_id;
+        if (!llvm::to_integer(command.GetArgumentAtIndex(i), user_id)) {
           result.AppendErrorWithFormat("invalid stop hook id: \"%s\".\n",
                                        command.GetArgumentAtIndex(i));
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
         success = target.SetStopHookActiveStateByID(user_id, m_enable);
         if (!success) {
           result.AppendErrorWithFormat("unknown stop hook id: \"%s\".\n",

lldb/source/Commands/CommandObjectThread.cpp

 //===-- CommandObjectThread.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 "CommandObjectThread.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Host/OptionParser.h"
-#include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPythonClassWithDict.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineEntry.h"
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else {
       const size_t num_args = command.GetArgumentCount();
       Process *process = m_exe_ctx.GetProcessPtr();
 
       std::lock_guard<std::recursive_mutex> guard(
           process->GetThreadList().GetMutex());
 
       for (size_t i = 0; i < num_args; i++) {
-        bool success;
-
-        uint32_t thread_idx = StringConvert::ToUInt32(
-            command.GetArgumentAtIndex(i), 0, 0, &success);
-        if (!success) {
+        uint32_t thread_idx;
+        if (!llvm::to_integer(command.GetArgumentAtIndex(i), thread_idx)) {
           result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
                                        command.GetArgumentAtIndex(i));
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
 
         ThreadSP thread =
             process->GetThreadList().FindThreadByIndexID(thread_idx);
if (command.GetArgumentCount() == 0) {
 
       if (thread == nullptr) {
         result.AppendError("no selected thread in process");
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     } else {
       const char *thread_idx_cstr = command.GetArgumentAtIndex(0);
-      uint32_t step_thread_idx =
-          StringConvert::ToUInt32(thread_idx_cstr, LLDB_INVALID_INDEX32);
-      if (step_thread_idx == LLDB_INVALID_INDEX32) {
+      uint32_t step_thread_idx;
+
+      if (!llvm::to_integer(thread_idx_cstr, step_thread_idx)) {
         result.AppendErrorWithFormat("invalid thread index '%s'.\n",
                                      thread_idx_cstr);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
       thread =
           process->GetThreadList().FindThreadByIndexID(step_thread_idx).get();
       if (thread == nullptr) {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else {
       Thread *thread = nullptr;
       std::vector<uint32_t> line_numbers;
 
       if (command.GetArgumentCount() >= 1) {
         size_t num_args = command.GetArgumentCount();
         for (size_t i = 0; i < num_args; i++) {
           uint32_t line_number;
-          line_number = StringConvert::ToUInt32(command.GetArgumentAtIndex(i),
-                                                UINT32_MAX);
-          if (line_number == UINT32_MAX) {
+          if (!llvm::to_integer(command.GetArgumentAtIndex(i), line_number)) {
             result.AppendErrorWithFormat("invalid line number: '%s'.\n",
                                          command.GetArgumentAtIndex(i));
             result.SetStatus(eReturnStatusFailed);
             return false;
           } else
             line_numbers.push_back(line_number);
         }
       } else if (m_options.m_until_addrs.empty()) {
bool DoExecute(Args &command, CommandReturnObject &result) override {
     } else if (command.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat(
           "'%s' takes exactly one thread index argument:\nUsage: %s\n",
           m_cmd_name.c_str(), m_cmd_syntax.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    uint32_t index_id =
-        StringConvert::ToUInt32(command.GetArgumentAtIndex(0), 0, 0);
+    uint32_t index_id;
+    if (!llvm::to_integer(command.GetArgumentAtIndex(0), index_id)) {
+      result.AppendErrorWithFormat("Invalid thread index '%s'",
+                                   command.GetArgumentAtIndex(0));
+      result.SetStatus(eReturnStatusFailed);
+      return false;
+    }
 
     Thread *new_thread =
         process->GetThreadList().FindThreadByIndexID(index_id).get();
     if (new_thread == nullptr) {
       result.AppendErrorWithFormat("invalid thread #%s.\n",
                                    command.GetArgumentAtIndex(0));
       result.SetStatus(eReturnStatusFailed);
       return false;
bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat("Too many arguments, expected one - the "
                                    "thread plan index - but got %zu.",
                                    args.GetArgumentCount());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
-    bool success;
-    uint32_t thread_plan_idx =
-        StringConvert::ToUInt32(args.GetArgumentAtIndex(0), 0, 0, &success);
-    if (!success) {
+    uint32_t thread_plan_idx;
+    if (!llvm::to_integer(args.GetArgumentAtIndex(0), thread_plan_idx)) {
       result.AppendErrorWithFormat(
           "Invalid thread index: \"%s\" - should be unsigned int.",
           args.GetArgumentAtIndex(0));
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     if (thread_plan_idx == 0) {
bool DoExecute(Args &args, CommandReturnObject &result) override {
     }
 
     const size_t num_args = args.GetArgumentCount();
 
     std::lock_guard<std::recursive_mutex> guard(
         process->GetThreadList().GetMutex());
 
     for (size_t i = 0; i < num_args; i++) {
-      bool success;
-
-      lldb::tid_t tid = StringConvert::ToUInt64(
-          args.GetArgumentAtIndex(i), 0, 0, &success);
-      if (!success) {
+      lldb::tid_t tid;
+      if (!llvm::to_integer(args.GetArgumentAtIndex(i), tid)) {
         result.AppendErrorWithFormat("invalid thread specification: \"%s\"\n",
                                      args.GetArgumentAtIndex(i));
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
       if (!process->PruneThreadPlansForTID(tid)) {
         result.AppendErrorWithFormat("Could not find unreported tid: \"%s\"\n",
                                      args.GetArgumentAtIndex(i));

lldb/test/API/commands/frame/recognizer/TestFrameRecognizer.py

def test_frame_recognizer_multi_symbol(self):
                     substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer'])
 
         target, process, thread, _ = lldbutil.run_to_name_breakpoint(self, "bar",
                                                                  exe_name = exe)
         frame = thread.GetSelectedFrame()
 
         self.expect("frame recognizer info 0",
                     substrs=['frame 0 is recognized by recognizer.MyFrameRecognizer'])
+
+    @no_debug_info_test
+    def test_frame_recognizer_delete_invalid_arg(self):
+        self.expect("frame recognizer delete a", error=True,
+                    substrs=["error: 'a' is not a valid recognizer id."])
+        self.expect("frame recognizer delete \"\"", error=True,
+                    substrs=["error: '' is not a valid recognizer id."])
+        self.expect("frame recognizer delete -1", error=True,
+                    substrs=["error: '-1' is not a valid recognizer id."])
+        self.expect("frame recognizer delete 4294967297", error=True,
+                    substrs=["error: '4294967297' is not a valid recognizer id."])
+
+    @no_debug_info_test
+    def test_frame_recognizer_info_invalid_arg(self):
+        self.expect("frame recognizer info a", error=True,
+                    substrs=["error: 'a' is not a valid frame index."])
+        self.expect("frame recognizer info \"\"", error=True,
+                    substrs=["error: '' is not a valid frame index."])
+        self.expect("frame recognizer info -1", error=True,
+                    substrs=["error: '-1' is not a valid frame index."])
+        self.expect("frame recognizer info 4294967297", error=True,
+                    substrs=["error: '4294967297' is not a valid frame index."])

lldb/test/API/commands/platform/file/close/TestPlatformFileClose.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_file_close_invalid_arg(self):
+        self.expect("platform file close y", error=True,
+                    substrs=["'y' is not a valid file descriptor."])
+        self.expect("platform file close -1", error=True,
+                    substrs=["'-1' is not a valid file descriptor."])

lldb/test/API/commands/platform/file/read/TestPlatformFileRead.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_file_close_invalid_arg(self):
+        self.expect("platform file read y", error=True,
+                    substrs=["'y' is not a valid file descriptor."])
+        # 'file read' takes an option, so this will be treated as an option.
+        self.expect("platform file read -1", error=True,
+                    substrs=["unknown or ambiguous option"])

lldb/test/API/commands/process/signal/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/process/signal/TestProcessSignal.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+        self.expect("process signal az", error=True, startstr="error: Invalid signal argument 'az'.")
+        self.expect("process signal 0x1ffffffff", error=True, startstr="error: Invalid signal argument '0x1ffffffff'.")
+        self.expect("process signal 0xffffffff", error=True, startstr="error: Invalid signal argument '0xffffffff'.")

lldb/test/API/commands/process/signal/main.cpp

+int main() {
+  return 0; // break here
+}

lldb/test/API/commands/target/modules/search-paths/insert/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/target/modules/search-paths/insert/TestTargetModulesSearchpathsInsert.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+
+        self.expect("target create %s" % (exe))
+        self.expect("target modules search-paths insert -1 a b", error=True,
+                    startstr="error: <index> parameter is not an integer: '-1'.")
+
+        self.expect("target modules search-paths insert abcdefx a b", error=True,
+                    startstr="error: <index> parameter is not an integer: 'abcdefx'.")

lldb/test/API/commands/target/modules/search-paths/insert/main.cpp

+int main() { return 0; }

lldb/test/API/commands/target/select/TestTargetSelect.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.expect("target select -1", error=True,
+                    startstr="error: invalid index string value '-1'")
+        self.expect("target select abcdfx", error=True,
+                    startstr="error: invalid index string value 'abcdfx'")

lldb/test/API/commands/target/stop-hook/delete/TestTargetStopHookDelete.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.expect("target stop-hook delete -1", error=True,
+                    startstr="error: invalid stop hook id: \"-1\".")
+        self.expect("target stop-hook delete abcdfx", error=True,
+                    startstr="error: invalid stop hook id: \"abcdfx\".")

lldb/test/API/commands/target/stop-hook/disable/TestTargetStopHookDisable.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.expect("target stop-hook disable -1", error=True,
+                    startstr="error: invalid stop hook id: \"-1\".")
+        self.expect("target stop-hook disable abcdfx", error=True,
+                    startstr="error: invalid stop hook id: \"abcdfx\".")

lldb/test/API/commands/target/stop-hook/enable/TestTargetStopHookEnable.py

+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test_invalid_arg(self):
+        self.expect("target stop-hook enable -1", error=True,
+                    startstr="error: invalid stop hook id: \"-1\".")
+        self.expect("target stop-hook enable abcdfx", error=True,
+                    startstr="error: invalid stop hook id: \"abcdfx\".")

lldb/test/API/commands/thread/select/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/thread/select/TestThreadSelect.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_invalid_arg(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+
+        self.expect("thread select -1", error=True, startstr="error: Invalid thread index '-1'")
+        self.expect("thread select 0x1ffffffff", error=True, startstr="error: Invalid thread index '0x1ffffffff'")
+        # Parses but not a valid thread id.
+        self.expect("thread select 0xffffffff", error=True, startstr="error: invalid thread #0xffffffff.")

lldb/test/API/commands/thread/select/main.cpp

+int main() {
+  return 0; // break here
+}