[lldb] Remove SBHostOS threading functionality

[teemperor]

Summary

Follow up patch for D104231 which deprecates this in the SB API.

This removes the threading functionality that just exists for the sake of implementing the SBHostOS threading framework.

lldb/include/lldb/Host/HostNativeThreadBase.h

class HostNativeThreadBase {
   const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete;
 
 public:
   HostNativeThreadBase();
   explicit HostNativeThreadBase(lldb::thread_t thread);
   virtual ~HostNativeThreadBase() {}
 
   virtual Status Join(lldb::thread_result_t *result) = 0;
-  virtual Status Cancel() = 0;
   virtual bool IsJoinable() const;
   virtual void Reset();
   virtual bool EqualsThread(lldb::thread_t thread) const;
   lldb::thread_t Release();
 
   lldb::thread_t GetSystemHandle() const;
   lldb::thread_result_t GetResult() const;
 

lldb/include/lldb/Host/HostThread.h

 /// machine.
 ///
 class HostThread {
 public:
   HostThread();
   HostThread(lldb::thread_t thread);
 
   Status Join(lldb::thread_result_t *result);
-  Status Cancel();
   void Reset();
   lldb::thread_t Release();
 
   bool IsJoinable() const;
   HostNativeThread &GetNativeThread();
   const HostNativeThread &GetNativeThread() const;
   lldb::thread_result_t GetResult() const;
 
   bool EqualsThread(lldb::thread_t thread) const;
 
 private:
   std::shared_ptr<HostNativeThreadBase> m_native_thread;
 };
 }
 
 #endif

lldb/include/lldb/Host/posix/HostThreadPosix.h

class HostThreadPosix : public HostNativeThreadBase {
   const HostThreadPosix &operator=(const HostThreadPosix &) = delete;
 
 public:
   HostThreadPosix();
   HostThreadPosix(lldb::thread_t thread);
   ~HostThreadPosix() override;
 
   Status Join(lldb::thread_result_t *result) override;
-  Status Cancel() override;
-
-  Status Detach();
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_POSIX_HOSTTHREADPOSIX_H

lldb/include/lldb/Host/windows/HostThreadWindows.h

 public:
   HostThreadWindows();
   HostThreadWindows(lldb::thread_t thread);
   virtual ~HostThreadWindows();
 
   void SetOwnsHandle(bool owns);
 
   Status Join(lldb::thread_result_t *result) override;
-  Status Cancel() override;
   void Reset() override;
   bool EqualsThread(lldb::thread_t thread) const override;
 
   lldb::tid_t GetThreadId() const;
 
 private:
   bool m_owns_handle;
 };
 }
 
 #endif

lldb/source/API/SBHostOS.cpp

 //===-- SBHostOS.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/API/SBHostOS.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBError.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostNativeThread.h"
 #include "lldb/Host/HostThread.h"
SBFileSpec SBHostOS::GetUserHomeDirectory() {
   sb_fspec.SetFileSpec(homedir);
 
   return LLDB_RECORD_RESULT(sb_fspec);
 }
 
 lldb::thread_t SBHostOS::ThreadCreate(const char *name,
                                       lldb::thread_func_t thread_function,
                                       void *thread_arg, SBError *error_ptr) {
-  LLDB_RECORD_DUMMY(lldb::thread_t, SBHostOS, ThreadCreate,
-                    (lldb::thread_func_t, void *, SBError *), name,
-                    thread_function, thread_arg, error_ptr);
-  llvm::Expected<HostThread> thread =
-      ThreadLauncher::LaunchThread(name, thread_function, thread_arg);
-  if (!thread) {
-    if (error_ptr)
-      error_ptr->SetError(Status(thread.takeError()));
-    else
-      llvm::consumeError(thread.takeError());
-    return LLDB_INVALID_HOST_THREAD;
-  }
+
+    error_ptr->SetErrorString("ThreadCreate is no longer supported.");
 
-  return thread->Release();
-}
-
 void SBHostOS::ThreadCreated(const char *name) {
   LLDB_RECORD_STATIC_METHOD(void, SBHostOS, ThreadCreated, (const char *),
                             name);
 }
 
 bool SBHostOS::ThreadCancel(lldb::thread_t thread, SBError *error_ptr) {
   LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadCancel,
                             (lldb::thread_t, lldb::SBError *), thread,
                             error_ptr);
 
-  Status error;
-  HostThread host_thread(thread);
-  error = host_thread.Cancel();
   if (error_ptr)
-    error_ptr->SetError(error);
-  host_thread.Release();
-  return error.Success();
+    error_ptr->SetErrorString("ThreadCancel is no longer supported.");
+  return false;
 }
 
 bool SBHostOS::ThreadDetach(lldb::thread_t thread, SBError *error_ptr) {
   LLDB_RECORD_DUMMY(bool, SBHostOS, ThreadDetach,
                             (lldb::thread_t, lldb::SBError *), thread,
                             error_ptr);
 
-  Status error;
-#if defined(_WIN32)
   if (error_ptr)
-    error_ptr->SetErrorString("ThreadDetach is not supported on this platform");
-#else
-  HostThread host_thread(thread);
-  error = host_thread.GetNativeThread().Detach();
-  if (error_ptr)
-    error_ptr->SetError(error);
-  host_thread.Release();
-#endif
-  return error.Success();
+    error_ptr->SetErrorString("ThreadDetach is no longer supported.");
+  return false;
 }
 
 bool SBHostOS::ThreadJoin(lldb::thread_t thread, lldb::thread_result_t *result,
                           SBError *error_ptr) {
   LLDB_RECORD_DUMMY(
       bool, SBHostOS, ThreadJoin,
       (lldb::thread_t, lldb::thread_result_t *, lldb::SBError *), thread,
       result, error_ptr);
-
-  Status error;
-  HostThread host_thread(thread);
-  error = host_thread.Join(result);
   if (error_ptr)
-    error_ptr->SetError(error);
-  host_thread.Release();
-  return error.Success();
+    error_ptr->SetErrorString("ThreadJoin is no longer supported.");
+  return false;
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBHostOS>(Registry &R) {
   LLDB_REGISTER_STATIC_METHOD(lldb::SBFileSpec, SBHostOS, GetProgramFileSpec,

lldb/source/Host/common/HostThread.cpp

 
 HostThread::HostThread(lldb::thread_t thread)
     : m_native_thread(new HostNativeThread(thread)) {}
 
 Status HostThread::Join(lldb::thread_result_t *result) {
   return m_native_thread->Join(result);
 }
 
-Status HostThread::Cancel() { return m_native_thread->Cancel(); }
-
 void HostThread::Reset() { return m_native_thread->Reset(); }
 
 lldb::thread_t HostThread::Release() { return m_native_thread->Release(); }
 
 bool HostThread::IsJoinable() const { return m_native_thread->IsJoinable(); }
 
 HostNativeThread &HostThread::GetNativeThread() {
   return static_cast<HostNativeThread &>(*m_native_thread);

lldb/source/Host/posix/HostThreadPosix.cpp

if (IsJoinable()) {
     if (result)
       *result = nullptr;
     error.SetError(EINVAL, eErrorTypePOSIX);
   }
 
   Reset();
   return error;
 }
-
-Status HostThreadPosix::Cancel() {
-  Status error;
-  if (IsJoinable()) {
-#ifndef __FreeBSD__
-    llvm_unreachable("someone is calling HostThread::Cancel()");
-#else
-    int err = ::pthread_cancel(m_thread);
-    error.SetError(err, eErrorTypePOSIX);
-#endif
-  }
-  return error;
-}
-
-Status HostThreadPosix::Detach() {
-  Status error;
-  if (IsJoinable()) {
-    int err = ::pthread_detach(m_thread);
-    error.SetError(err, eErrorTypePOSIX);
-  }
-  Reset();
-  return error;
-}

lldb/source/Host/windows/HostThreadWindows.cpp

if (WAIT_OBJECT_0 == wait_result && result) {
       error.SetError(::GetLastError(), eErrorTypeWin32);
   } else
     error.SetError(ERROR_INVALID_HANDLE, eErrorTypeWin32);
 
   Reset();
   return error;
 }
 
-Status HostThreadWindows::Cancel() {
-  Status error;
-
-  DWORD result = ::QueueUserAPC(::ExitThreadProxy, m_thread, 0);
-  error.SetError(result, eErrorTypeWin32);
-  return error;
-}
-
 lldb::tid_t HostThreadWindows::GetThreadId() const {
   return ::GetThreadId(m_thread);
 }
 
 void HostThreadWindows::Reset() {
   if (m_owns_handle && m_thread != LLDB_INVALID_HOST_THREAD)
     ::CloseHandle(m_thread);
 
   HostNativeThreadBase::Reset();
 }
 
 bool HostThreadWindows::EqualsThread(lldb::thread_t thread) const {
   return GetThreadId() == ::GetThreadId(thread);
 }