vendor/lldb/lldb-trunk-r303197

22 files changed, 309 insertions, 302 deletions

diff --git a/source/Host/common/Editline.cpp b/source/Host/common/Editline.cpp
index 851287e763312..7d4b398a171da 100644
--- a/source/Host/common/Editline.cpp
+++ b/source/Host/common/Editline.cpp
@@ -14,10 +14,10 @@
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Editline.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/Timeout.h"
diff --git a/source/Host/common/File.cpp b/source/Host/common/File.cpp
index 1869a6db49c93..3de93ebc220b5 100644
--- a/source/Host/common/File.cpp
+++ b/source/Host/common/File.cpp
@@ -157,8 +157,8 @@ void File::SetStream(FILE *fh, bool transfer_ownership) {
   m_own_stream = transfer_ownership;
 }
 
-Error File::Open(const char *path, uint32_t options, uint32_t permissions) {
-  Error error;
+Status File::Open(const char *path, uint32_t options, uint32_t permissions) {
+  Status error;
   if (IsValid())
     Close();
 
@@ -246,20 +246,20 @@ Error File::Open(const char *path, uint32_t options, uint32_t permissions) {
   return error;
 }
 
-uint32_t File::GetPermissions(const FileSpec &file_spec, Error &error) {
+uint32_t File::GetPermissions(const FileSpec &file_spec, Status &error) {
   if (file_spec) {
     error.Clear();
     auto Perms = llvm::sys::fs::getPermissions(file_spec.GetPath());
     if (Perms)
       return *Perms;
-    error = Error(Perms.getError());
+    error = Status(Perms.getError());
     return 0;
   } else
     error.SetErrorString("empty file spec");
   return 0;
 }
 
-uint32_t File::GetPermissions(Error &error) const {
+uint32_t File::GetPermissions(Status &error) const {
   int fd = GetDescriptor();
   if (fd != kInvalidDescriptor) {
     struct stat file_stats;
@@ -275,8 +275,8 @@ uint32_t File::GetPermissions(Error &error) const {
   return 0;
 }
 
-Error File::Close() {
-  Error error;
+Status File::Close() {
+  Status error;
   if (StreamIsValid() && m_own_stream) {
     if (::fclose(m_stream) == EOF)
       error.SetErrorToErrno();
@@ -305,8 +305,8 @@ void File::Clear() {
       eLazyBoolCalculate;
 }
 
-Error File::GetFileSpec(FileSpec &file_spec) const {
-  Error error;
+Status File::GetFileSpec(FileSpec &file_spec) const {
+  Status error;
 #ifdef F_GETPATH
   if (IsValid()) {
     char path[PATH_MAX];
@@ -340,7 +340,7 @@ Error File::GetFileSpec(FileSpec &file_spec) const {
   return error;
 }
 
-off_t File::SeekFromStart(off_t offset, Error *error_ptr) {
+off_t File::SeekFromStart(off_t offset, Status *error_ptr) {
   off_t result = 0;
   if (DescriptorIsValid()) {
     result = ::lseek(m_descriptor, offset, SEEK_SET);
@@ -366,7 +366,7 @@ off_t File::SeekFromStart(off_t offset, Error *error_ptr) {
   return result;
 }
 
-off_t File::SeekFromCurrent(off_t offset, Error *error_ptr) {
+off_t File::SeekFromCurrent(off_t offset, Status *error_ptr) {
   off_t result = -1;
   if (DescriptorIsValid()) {
     result = ::lseek(m_descriptor, offset, SEEK_CUR);
@@ -392,7 +392,7 @@ off_t File::SeekFromCurrent(off_t offset, Error *error_ptr) {
   return result;
 }
 
-off_t File::SeekFromEnd(off_t offset, Error *error_ptr) {
+off_t File::SeekFromEnd(off_t offset, Status *error_ptr) {
   off_t result = -1;
   if (DescriptorIsValid()) {
     result = ::lseek(m_descriptor, offset, SEEK_END);
@@ -418,8 +418,8 @@ off_t File::SeekFromEnd(off_t offset, Error *error_ptr) {
   return result;
 }
 
-Error File::Flush() {
-  Error error;
+Status File::Flush() {
+  Status error;
   if (StreamIsValid()) {
     int err = 0;
     do {
@@ -434,8 +434,8 @@ Error File::Flush() {
   return error;
 }
 
-Error File::Sync() {
-  Error error;
+Status File::Sync() {
+  Status error;
   if (DescriptorIsValid()) {
 #ifdef _WIN32
     int err = FlushFileBuffers((HANDLE)_get_osfhandle(m_descriptor));
@@ -462,8 +462,8 @@ Error File::Sync() {
 #define MAX_WRITE_SIZE INT_MAX
 #endif
 
-Error File::Read(void *buf, size_t &num_bytes) {
-  Error error;
+Status File::Read(void *buf, size_t &num_bytes) {
+  Status error;
 
 #if defined(MAX_READ_SIZE)
   if (num_bytes > MAX_READ_SIZE) {
@@ -524,8 +524,8 @@ Error File::Read(void *buf, size_t &num_bytes) {
   return error;
 }
 
-Error File::Write(const void *buf, size_t &num_bytes) {
-  Error error;
+Status File::Write(const void *buf, size_t &num_bytes) {
+  Status error;
 
 #if defined(MAX_WRITE_SIZE)
   if (num_bytes > MAX_WRITE_SIZE) {
@@ -588,8 +588,8 @@ Error File::Write(const void *buf, size_t &num_bytes) {
   return error;
 }
 
-Error File::Read(void *buf, size_t &num_bytes, off_t &offset) {
-  Error error;
+Status File::Read(void *buf, size_t &num_bytes, off_t &offset) {
+  Status error;
 
 #if defined(MAX_READ_SIZE)
   if (num_bytes > MAX_READ_SIZE) {
@@ -650,9 +650,9 @@ Error File::Read(void *buf, size_t &num_bytes, off_t &offset) {
   return error;
 }
 
-Error File::Read(size_t &num_bytes, off_t &offset, bool null_terminate,
-                 DataBufferSP &data_buffer_sp) {
-  Error error;
+Status File::Read(size_t &num_bytes, off_t &offset, bool null_terminate,
+                  DataBufferSP &data_buffer_sp) {
+  Status error;
 
   if (num_bytes > 0) {
     int fd = GetDescriptor();
@@ -694,8 +694,8 @@ Error File::Read(size_t &num_bytes, off_t &offset, bool null_terminate,
   return error;
 }
 
-Error File::Write(const void *buf, size_t &num_bytes, off_t &offset) {
-  Error error;
+Status File::Write(const void *buf, size_t &num_bytes, off_t &offset) {
+  Status error;
 
 #if defined(MAX_WRITE_SIZE)
   if (num_bytes > MAX_WRITE_SIZE) {
diff --git a/source/Host/common/FileCache.cpp b/source/Host/common/FileCache.cpp
index db71813e4ffb1..b4629255c8529 100644
--- a/source/Host/common/FileCache.cpp
+++ b/source/Host/common/FileCache.cpp
@@ -24,7 +24,7 @@ FileCache &FileCache::GetInstance() {
 }
 
 lldb::user_id_t FileCache::OpenFile(const FileSpec &file_spec, uint32_t flags,
-                                    uint32_t mode, Error &error) {
+                                    uint32_t mode, Status &error) {
   std::string path(file_spec.GetPath());
   if (path.empty()) {
     error.SetErrorString("empty path");
@@ -39,7 +39,7 @@ lldb::user_id_t FileCache::OpenFile(const FileSpec &file_spec, uint32_t flags,
   return fd;
 }
 
-bool FileCache::CloseFile(lldb::user_id_t fd, Error &error) {
+bool FileCache::CloseFile(lldb::user_id_t fd, Status &error) {
   if (fd == UINT64_MAX) {
     error.SetErrorString("invalid file descriptor");
     return false;
@@ -60,7 +60,8 @@ bool FileCache::CloseFile(lldb::user_id_t fd, Error &error) {
 }
 
 uint64_t FileCache::WriteFile(lldb::user_id_t fd, uint64_t offset,
-                              const void *src, uint64_t src_len, Error &error) {
+                              const void *src, uint64_t src_len,
+                              Status &error) {
   if (fd == UINT64_MAX) {
     error.SetErrorString("invalid file descriptor");
     return UINT64_MAX;
@@ -86,7 +87,7 @@ uint64_t FileCache::WriteFile(lldb::user_id_t fd, uint64_t offset,
 }
 
 uint64_t FileCache::ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst,
-                             uint64_t dst_len, Error &error) {
+                             uint64_t dst_len, Status &error) {
   if (fd == UINT64_MAX) {
     error.SetErrorString("invalid file descriptor");
     return UINT64_MAX;
diff --git a/source/Host/common/Host.cpp b/source/Host/common/Host.cpp
index 7754d96ad3315..da35022c813cb 100644
--- a/source/Host/common/Host.cpp
+++ b/source/Host/common/Host.cpp
@@ -63,9 +63,9 @@
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferLLVM.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
@@ -484,19 +484,19 @@ MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
   return true;
 }
 
-Error Host::RunShellCommand(const char *command, const FileSpec &working_dir,
-                            int *status_ptr, int *signo_ptr,
-                            std::string *command_output_ptr,
-                            uint32_t timeout_sec, bool run_in_default_shell) {
+Status Host::RunShellCommand(const char *command, const FileSpec &working_dir,
+                             int *status_ptr, int *signo_ptr,
+                             std::string *command_output_ptr,
+                             uint32_t timeout_sec, bool run_in_default_shell) {
   return RunShellCommand(Args(command), working_dir, status_ptr, signo_ptr,
                          command_output_ptr, timeout_sec, run_in_default_shell);
 }
 
-Error Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
-                            int *status_ptr, int *signo_ptr,
-                            std::string *command_output_ptr,
-                            uint32_t timeout_sec, bool run_in_default_shell) {
-  Error error;
+Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
+                             int *status_ptr, int *signo_ptr,
+                             std::string *command_output_ptr,
+                             uint32_t timeout_sec, bool run_in_default_shell) {
+  Status error;
   ProcessLaunchInfo launch_info;
   launch_info.SetArchitecture(HostInfo::GetArchitecture());
   if (run_in_default_shell) {
@@ -654,10 +654,10 @@ short Host::GetPosixspawnFlags(const ProcessLaunchInfo &launch_info) {
   return flags;
 }
 
-Error Host::LaunchProcessPosixSpawn(const char *exe_path,
-                                    const ProcessLaunchInfo &launch_info,
-                                    lldb::pid_t &pid) {
-  Error error;
+Status Host::LaunchProcessPosixSpawn(const char *exe_path,
+                                     const ProcessLaunchInfo &launch_info,
+                                     lldb::pid_t &pid) {
+  Status error;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
                                                   LIBLLDB_LOG_PROCESS));
 
@@ -866,7 +866,7 @@ Error Host::LaunchProcessPosixSpawn(const char *exe_path,
 }
 
 bool Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info,
-                                   Log *log, Error &error) {
+                                   Log *log, Status &error) {
   if (info == NULL)
     return false;
 
@@ -947,7 +947,7 @@ bool Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info,
 // The functions below implement process launching via posix_spawn() for Linux,
 // FreeBSD and NetBSD.
 
-Error Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
+Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
   std::unique_ptr<ProcessLauncher> delegate_launcher;
 #if defined(_WIN32)
   delegate_launcher.reset(new ProcessLauncherWindows());
@@ -958,7 +958,7 @@ Error Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
 #endif
   MonitoringProcessLauncher launcher(std::move(delegate_launcher));
 
-  Error error;
+  Status error;
   HostProcess process = launcher.LaunchProcess(launch_info, error);
 
   // TODO(zturner): It would be better if the entire HostProcess were returned
diff --git a/source/Host/common/HostProcess.cpp b/source/Host/common/HostProcess.cpp
index 2d99d8e1fc997..1540333215143 100644
--- a/source/Host/common/HostProcess.cpp
+++ b/source/Host/common/HostProcess.cpp
@@ -21,9 +21,9 @@ HostProcess::HostProcess(lldb::process_t process)
 
 HostProcess::~HostProcess() {}
 
-Error HostProcess::Terminate() { return m_native_process->Terminate(); }
+Status HostProcess::Terminate() { return m_native_process->Terminate(); }
 
-Error HostProcess::GetMainModule(FileSpec &file_spec) const {
+Status HostProcess::GetMainModule(FileSpec &file_spec) const {
   return m_native_process->GetMainModule(file_spec);
 }
 
diff --git a/source/Host/common/HostThread.cpp b/source/Host/common/HostThread.cpp
index 738b7ef72f166..02882c523908c 100644
--- a/source/Host/common/HostThread.cpp
+++ b/source/Host/common/HostThread.cpp
@@ -18,11 +18,11 @@ HostThread::HostThread() : m_native_thread(new HostNativeThread) {}
 HostThread::HostThread(lldb::thread_t thread)
     : m_native_thread(new HostNativeThread(thread)) {}
 
-Error HostThread::Join(lldb::thread_result_t *result) {
+Status HostThread::Join(lldb::thread_result_t *result) {
   return m_native_thread->Join(result);
 }
 
-Error HostThread::Cancel() { return m_native_thread->Cancel(); }
+Status HostThread::Cancel() { return m_native_thread->Cancel(); }
 
 void HostThread::Reset() { return m_native_thread->Reset(); }
 
diff --git a/source/Host/common/LockFileBase.cpp b/source/Host/common/LockFileBase.cpp
index b30acc5d50447..a8d7881ab8963 100644
--- a/source/Host/common/LockFileBase.cpp
+++ b/source/Host/common/LockFileBase.cpp
@@ -14,9 +14,9 @@ using namespace lldb_private;
 
 namespace {
 
-Error AlreadyLocked() { return Error("Already locked"); }
+Status AlreadyLocked() { return Status("Already locked"); }
 
-Error NotLocked() { return Error("Not locked"); }
+Status NotLocked() { return Status("Not locked"); }
 }
 
 LockFileBase::LockFileBase(int fd)
@@ -24,31 +24,31 @@ LockFileBase::LockFileBase(int fd)
 
 bool LockFileBase::IsLocked() const { return m_locked; }
 
-Error LockFileBase::WriteLock(const uint64_t start, const uint64_t len) {
+Status LockFileBase::WriteLock(const uint64_t start, const uint64_t len) {
   return DoLock([&](const uint64_t start,
                     const uint64_t len) { return DoWriteLock(start, len); },
                 start, len);
 }
 
-Error LockFileBase::TryWriteLock(const uint64_t start, const uint64_t len) {
+Status LockFileBase::TryWriteLock(const uint64_t start, const uint64_t len) {
   return DoLock([&](const uint64_t start,
                     const uint64_t len) { return DoTryWriteLock(start, len); },
                 start, len);
 }
 
-Error LockFileBase::ReadLock(const uint64_t start, const uint64_t len) {
+Status LockFileBase::ReadLock(const uint64_t start, const uint64_t len) {
   return DoLock([&](const uint64_t start,
                     const uint64_t len) { return DoReadLock(start, len); },
                 start, len);
 }
 
-Error LockFileBase::TryReadLock(const uint64_t start, const uint64_t len) {
+Status LockFileBase::TryReadLock(const uint64_t start, const uint64_t len) {
   return DoLock([&](const uint64_t start,
                     const uint64_t len) { return DoTryReadLock(start, len); },
                 start, len);
 }
 
-Error LockFileBase::Unlock() {
+Status LockFileBase::Unlock() {
   if (!IsLocked())
     return NotLocked();
 
@@ -63,10 +63,10 @@ Error LockFileBase::Unlock() {
 
 bool LockFileBase::IsValidFile() const { return m_fd != -1; }
 
-Error LockFileBase::DoLock(const Locker &locker, const uint64_t start,
-                           const uint64_t len) {
+Status LockFileBase::DoLock(const Locker &locker, const uint64_t start,
+                            const uint64_t len) {
   if (!IsValidFile())
-    return Error("File is invalid");
+    return Status("File is invalid");
 
   if (IsLocked())
     return AlreadyLocked();
diff --git a/source/Host/common/MainLoop.cpp b/source/Host/common/MainLoop.cpp
index abd52f7f46fb3..7de6f7fa865d7 100644
--- a/source/Host/common/MainLoop.cpp
+++ b/source/Host/common/MainLoop.cpp
@@ -10,13 +10,13 @@
 #include "llvm/Config/llvm-config.h"
 
 #include "lldb/Host/MainLoop.h"
-#include "lldb/Utility/Error.h"
+#include "lldb/Utility/Status.h"
 #include <algorithm>
 #include <cassert>
 #include <cerrno>
 #include <csignal>
-#include <vector>
 #include <time.h>
+#include <vector>
 
 // Multiplexing is implemented using kqueue on systems that support it (BSD
 // variants including OSX). On linux we use ppoll, while android uses pselect
@@ -73,7 +73,7 @@ public:
   RunImpl(MainLoop &loop);
   ~RunImpl() = default;
 
-  Error Poll();
+  Status Poll();
   void ProcessEvents();
 
 private:
@@ -100,7 +100,7 @@ MainLoop::RunImpl::RunImpl(MainLoop &loop) : loop(loop) {
   in_events.reserve(loop.m_read_fds.size());
 }
 
-Error MainLoop::RunImpl::Poll() {
+Status MainLoop::RunImpl::Poll() {
   in_events.resize(loop.m_read_fds.size());
   unsigned i = 0;
   for (auto &fd : loop.m_read_fds)
@@ -110,8 +110,8 @@ Error MainLoop::RunImpl::Poll() {
                       out_events, llvm::array_lengthof(out_events), nullptr);
 
   if (num_events < 0)
-    return Error("kevent() failed with error %d\n", num_events);
-  return Error();
+    return Status("kevent() failed with error %d\n", num_events);
+  return Status();
 }
 
 void MainLoop::RunImpl::ProcessEvents() {
@@ -154,7 +154,7 @@ sigset_t MainLoop::RunImpl::get_sigmask() {
 }
 
 #ifdef FORCE_PSELECT
-Error MainLoop::RunImpl::Poll() {
+Status MainLoop::RunImpl::Poll() {
   FD_ZERO(&read_fd_set);
   int nfds = 0;
   for (const auto &fd : loop.m_read_fds) {
@@ -165,12 +165,12 @@ Error MainLoop::RunImpl::Poll() {
   sigset_t sigmask = get_sigmask();
   if (pselect(nfds, &read_fd_set, nullptr, nullptr, nullptr, &sigmask) == -1 &&
       errno != EINTR)
-    return Error(errno, eErrorTypePOSIX);
+    return Status(errno, eErrorTypePOSIX);
 
-  return Error();
+  return Status();
 }
 #else
-Error MainLoop::RunImpl::Poll() {
+Status MainLoop::RunImpl::Poll() {
   read_fds.clear();
 
   sigset_t sigmask = get_sigmask();
@@ -185,9 +185,9 @@ Error MainLoop::RunImpl::Poll() {
 
   if (ppoll(read_fds.data(), read_fds.size(), nullptr, &sigmask) == -1 &&
       errno != EINTR)
-    return Error(errno, eErrorTypePOSIX);
+    return Status(errno, eErrorTypePOSIX);
 
-  return Error();
+  return Status();
 }
 #endif
 
@@ -234,9 +234,9 @@ MainLoop::~MainLoop() {
   assert(m_signals.size() == 0);
 }
 
-MainLoop::ReadHandleUP
-MainLoop::RegisterReadObject(const IOObjectSP &object_sp,
-                                  const Callback &callback, Error &error) {
+MainLoop::ReadHandleUP MainLoop::RegisterReadObject(const IOObjectSP &object_sp,
+                                                    const Callback &callback,
+                                                    Status &error) {
 #ifdef LLVM_ON_WIN32
   if (object_sp->GetFdType() != IOObject:: eFDTypeSocket) {
     error.SetErrorString("MainLoop: non-socket types unsupported on Windows");
@@ -263,8 +263,7 @@ MainLoop::RegisterReadObject(const IOObjectSP &object_sp,
 // be unblocked in
 // the Run() function to check for signal delivery.
 MainLoop::SignalHandleUP
-MainLoop::RegisterSignal(int signo, const Callback &callback,
-                              Error &error) {
+MainLoop::RegisterSignal(int signo, const Callback &callback, Status &error) {
 #ifdef SIGNAL_POLLING_UNSUPPORTED
   error.SetErrorString("Signal polling is not supported on this platform.");
   return nullptr;
@@ -318,7 +317,7 @@ void MainLoop::UnregisterReadObject(IOObject::WaitableHandle handle) {
 
 void MainLoop::UnregisterSignal(int signo) {
 #if SIGNAL_POLLING_UNSUPPORTED
-  Error("Signal polling is not supported on this platform.");
+  Status("Signal polling is not supported on this platform.");
 #else
   auto it = m_signals.find(signo);
   assert(it != m_signals.end());
@@ -344,10 +343,10 @@ void MainLoop::UnregisterSignal(int signo) {
 #endif
 }
 
-Error MainLoop::Run() {
+Status MainLoop::Run() {
   m_terminate_request = false;
-  
-  Error error;
+
+  Status error;
   RunImpl impl(*this);
 
   // run until termination or until we run out of things to listen to
@@ -360,9 +359,9 @@ Error MainLoop::Run() {
     impl.ProcessEvents();
 
     if (m_terminate_request)
-      return Error();
+      return Status();
   }
-  return Error();
+  return Status();
 }
 
 void MainLoop::ProcessSignal(int signo) {
diff --git a/source/Host/common/MonitoringProcessLauncher.cpp b/source/Host/common/MonitoringProcessLauncher.cpp
index 2aa6c7f50b668..f1fcd0b44c150 100644
--- a/source/Host/common/MonitoringProcessLauncher.cpp
+++ b/source/Host/common/MonitoringProcessLauncher.cpp
@@ -14,8 +14,8 @@
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 
 #include "llvm/Support/FileSystem.h"
 
@@ -28,7 +28,7 @@ MonitoringProcessLauncher::MonitoringProcessLauncher(
 
 HostProcess
 MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info,
-                                         Error &error) {
+                                         Status &error) {
   ProcessLaunchInfo resolved_info(launch_info);
 
   error.Clear();
diff --git a/source/Host/common/NativeBreakpoint.cpp b/source/Host/common/NativeBreakpoint.cpp
index 8a3ee72179c3b..5eee3de482c18 100644
--- a/source/Host/common/NativeBreakpoint.cpp
+++ b/source/Host/common/NativeBreakpoint.cpp
@@ -9,8 +9,8 @@
 
 #include "lldb/Host/common/NativeBreakpoint.h"
 
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 
 using namespace lldb_private;
@@ -44,7 +44,7 @@ int32_t NativeBreakpoint::DecRef() {
   return m_ref_count;
 }
 
-Error NativeBreakpoint::Enable() {
+Status NativeBreakpoint::Enable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (m_enabled) {
@@ -53,7 +53,7 @@ Error NativeBreakpoint::Enable() {
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already enabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error();
+    return Status();
   }
 
   // Log and enable.
@@ -61,7 +61,7 @@ Error NativeBreakpoint::Enable() {
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " enabling...",
                 __FUNCTION__, m_addr);
 
-  Error error = DoEnable();
+  Status error = DoEnable();
   if (error.Success()) {
     m_enabled = true;
     if (log)
@@ -76,7 +76,7 @@ Error NativeBreakpoint::Enable() {
   return error;
 }
 
-Error NativeBreakpoint::Disable() {
+Status NativeBreakpoint::Disable() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (!m_enabled) {
@@ -85,7 +85,7 @@ Error NativeBreakpoint::Disable() {
       log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64
                   " already disabled, ignoring.",
                   __FUNCTION__, m_addr);
-    return Error();
+    return Status();
   }
 
   // Log and disable.
@@ -93,7 +93,7 @@ Error NativeBreakpoint::Disable() {
     log->Printf("NativeBreakpoint::%s addr = 0x%" PRIx64 " disabling...",
                 __FUNCTION__, m_addr);
 
-  Error error = DoDisable();
+  Status error = DoDisable();
   if (error.Success()) {
     m_enabled = false;
     if (log)
diff --git a/source/Host/common/NativeBreakpointList.cpp b/source/Host/common/NativeBreakpointList.cpp
index 60608a0bbc55e..ce5eb94a8d1fb 100644
--- a/source/Host/common/NativeBreakpointList.cpp
+++ b/source/Host/common/NativeBreakpointList.cpp
@@ -19,9 +19,9 @@ using namespace lldb_private;
 
 NativeBreakpointList::NativeBreakpointList() : m_mutex() {}
 
-Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
-                                   bool hardware,
-                                   CreateBreakpointFunc create_func) {
+Status NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
+                                    bool hardware,
+                                    CreateBreakpointFunc create_func) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
@@ -40,7 +40,7 @@ Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
                   __FUNCTION__, addr);
 
     iter->second->AddRef();
-    return Error();
+    return Status();
   }
 
   // Create a new breakpoint using the given create func.
@@ -51,7 +51,7 @@ Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
         __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
 
   NativeBreakpointSP breakpoint_sp;
-  Error error = create_func(addr, size_hint, hardware, breakpoint_sp);
+  Status error = create_func(addr, size_hint, hardware, breakpoint_sp);
   if (error.Fail()) {
     if (log)
       log->Printf(
@@ -70,8 +70,8 @@ Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
   return error;
 }
 
-Error NativeBreakpointList::DecRef(lldb::addr_t addr) {
-  Error error;
+Status NativeBreakpointList::DecRef(lldb::addr_t addr) {
+  Status error;
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
@@ -142,7 +142,7 @@ Error NativeBreakpointList::DecRef(lldb::addr_t addr) {
   return error;
 }
 
-Error NativeBreakpointList::EnableBreakpoint(lldb::addr_t addr) {
+Status NativeBreakpointList::EnableBreakpoint(lldb::addr_t addr) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__,
@@ -157,14 +157,14 @@ Error NativeBreakpointList::EnableBreakpoint(lldb::addr_t addr) {
     if (log)
       log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64 " -- NOT FOUND",
                   __FUNCTION__, addr);
-    return Error("breakpoint not found");
+    return Status("breakpoint not found");
   }
 
   // Enable it.
   return iter->second->Enable();
 }
 
-Error NativeBreakpointList::DisableBreakpoint(lldb::addr_t addr) {
+Status NativeBreakpointList::DisableBreakpoint(lldb::addr_t addr) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__,
@@ -179,15 +179,15 @@ Error NativeBreakpointList::DisableBreakpoint(lldb::addr_t addr) {
     if (log)
       log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64 " -- NOT FOUND",
                   __FUNCTION__, addr);
-    return Error("breakpoint not found");
+    return Status("breakpoint not found");
   }
 
   // Disable it.
   return iter->second->Disable();
 }
 
-Error NativeBreakpointList::GetBreakpoint(lldb::addr_t addr,
-                                          NativeBreakpointSP &breakpoint_sp) {
+Status NativeBreakpointList::GetBreakpoint(lldb::addr_t addr,
+                                           NativeBreakpointSP &breakpoint_sp) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__,
@@ -200,16 +200,16 @@ Error NativeBreakpointList::GetBreakpoint(lldb::addr_t addr,
   if (iter == m_breakpoints.end()) {
     // Not found!
     breakpoint_sp.reset();
-    return Error("breakpoint not found");
+    return Status("breakpoint not found");
   }
 
   // Disable it.
   breakpoint_sp = iter->second;
-  return Error();
+  return Status();
 }
 
-Error NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
-                                                  size_t size) const {
+Status NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
+                                                   size_t size) const {
   for (const auto &map : m_breakpoints) {
     lldb::addr_t bp_addr = map.first;
     // Breapoint not in range, ignore
@@ -225,5 +225,5 @@ Error NativeBreakpointList::RemoveTrapsFromBuffer(lldb::addr_t addr, void *buf,
     auto opcode_size = software_bp_sp->m_opcode_size;
     ::memcpy(opcode_addr, saved_opcodes, opcode_size);
   }
-  return Error();
+  return Status();
 }
diff --git a/source/Host/common/NativeProcessProtocol.cpp b/source/Host/common/NativeProcessProtocol.cpp
index 9d4149d700ba1..6f1a9f895b618 100644
--- a/source/Host/common/NativeProcessProtocol.cpp
+++ b/source/Host/common/NativeProcessProtocol.cpp
@@ -36,8 +36,8 @@ NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid)
       m_delegates_mutex(), m_delegates(), m_breakpoint_list(),
       m_watchpoint_list(), m_terminal_fd(-1), m_stop_id(0) {}
 
-lldb_private::Error NativeProcessProtocol::Interrupt() {
-  Error error;
+lldb_private::Status NativeProcessProtocol::Interrupt() {
+  Status error;
 #if !defined(SIGSTOP)
   error.SetErrorString("local host does not support signaling");
   return error;
@@ -46,17 +46,17 @@ lldb_private::Error NativeProcessProtocol::Interrupt() {
 #endif
 }
 
-Error NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) {
+Status NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) {
   m_signals_to_ignore.clear();
   m_signals_to_ignore.insert(signals.begin(), signals.end());
-  return Error();
+  return Status();
 }
 
-lldb_private::Error
+lldb_private::Status
 NativeProcessProtocol::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                            MemoryRegionInfo &range_info) {
   // Default: not implemented.
-  return Error("not implemented");
+  return Status("not implemented");
 }
 
 bool NativeProcessProtocol::GetExitStatus(ExitType *exit_type, int *status,
@@ -173,9 +173,9 @@ NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
                         reg_ctx_sp->NumSupportedHardwareWatchpoints());
 }
 
-Error NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
-                                           uint32_t watch_flags,
-                                           bool hardware) {
+Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
+                                            uint32_t watch_flags,
+                                            bool hardware) {
   // This default implementation assumes setting the watchpoint for
   // the process will require setting the watchpoint for each of the
   // threads.  Furthermore, it will track watchpoints set for the
@@ -205,7 +205,7 @@ Error NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
     if (!thread_sp)
       continue;
 
-    Error thread_error =
+    Status thread_error =
         thread_sp->SetWatchpoint(addr, size, watch_flags, hardware);
     if (thread_error.Fail() && hardware) {
       // Try software watchpoints since we failed on hardware watchpoint setting
@@ -227,7 +227,7 @@ Error NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
       // set so that we get back to a consistent state of "not
       // set" for the watchpoint.
       for (auto unwatch_thread_sp : watchpoint_established_threads) {
-        Error remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
+        Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
         if (remove_error.Fail() && log) {
           log->Warning("NativeProcessProtocol::%s (): RemoveWatchpoint failed "
                        "for pid=%" PRIu64 ", tid=%" PRIu64 ": %s",
@@ -242,11 +242,11 @@ Error NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
   return m_watchpoint_list.Add(addr, size, watch_flags, hardware);
 }
 
-Error NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
+Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
   // Update the thread list
   UpdateThreads();
 
-  Error overall_error;
+  Status overall_error;
 
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   for (auto thread_sp : m_threads) {
@@ -254,7 +254,7 @@ Error NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
     if (!thread_sp)
       continue;
 
-    const Error thread_error = thread_sp->RemoveWatchpoint(addr);
+    const Status thread_error = thread_sp->RemoveWatchpoint(addr);
     if (thread_error.Fail()) {
       // Keep track of the first thread error if any threads
       // fail. We want to try to remove the watchpoint from
@@ -263,7 +263,7 @@ Error NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
         overall_error = thread_error;
     }
   }
-  const Error error = m_watchpoint_list.Remove(addr);
+  const Status error = m_watchpoint_list.Remove(addr);
   return overall_error.Fail() ? overall_error : error;
 }
 
@@ -272,8 +272,8 @@ NativeProcessProtocol::GetHardwareBreakpointMap() const {
   return m_hw_breakpoints_map;
 }
 
-Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
-                                                   size_t size) {
+Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
+                                                    size_t size) {
   // This default implementation assumes setting a hardware breakpoint for
   // this process will require setting same hardware breakpoint for each
   // of its existing threads. New thread will do the same once created.
@@ -287,7 +287,7 @@ Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
 
   if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
       hw_debug_cap->first <= m_hw_breakpoints_map.size())
-    return Error("Target does not have required no of hardware breakpoints");
+    return Status("Target does not have required no of hardware breakpoints");
 
   // Vector below stores all thread pointer for which we have we successfully
   // set this hardware breakpoint. If any of the current process threads fails
@@ -302,7 +302,7 @@ Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
     if (!thread_sp)
       continue;
 
-    Error thread_error = thread_sp->SetHardwareBreakpoint(addr, size);
+    Status thread_error = thread_sp->SetHardwareBreakpoint(addr, size);
     if (thread_error.Success()) {
       // Remember that we set this breakpoint successfully in
       // case we need to clear it later.
@@ -312,7 +312,8 @@ Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
       // set so that we get back to a consistent state of "not
       // set" for this hardware breakpoint.
       for (auto rollback_thread_sp : breakpoint_established_threads) {
-        Error remove_error = rollback_thread_sp->RemoveHardwareBreakpoint(addr);
+        Status remove_error =
+            rollback_thread_sp->RemoveHardwareBreakpoint(addr);
         if (remove_error.Fail() && log) {
           log->Warning("NativeProcessProtocol::%s (): RemoveHardwareBreakpoint"
                        " failed for pid=%" PRIu64 ", tid=%" PRIu64 ": %s",
@@ -329,14 +330,14 @@ Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
   // process.
   m_hw_breakpoints_map[addr] = {addr, size};
 
-  return Error();
+  return Status();
 }
 
-Error NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
+Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
   // Update the thread list
   UpdateThreads();
 
-  Error error;
+  Status error;
 
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   for (auto thread_sp : m_threads) {
@@ -413,8 +414,8 @@ void NativeProcessProtocol::NotifyDidExec() {
   }
 }
 
-Error NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
-                                                   uint32_t size_hint) {
+Status NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
+                                                    uint32_t size_hint) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeProcessProtocol::%s addr = 0x%" PRIx64, __FUNCTION__,
@@ -423,25 +424,25 @@ Error NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
   return m_breakpoint_list.AddRef(
       addr, size_hint, false,
       [this](lldb::addr_t addr, size_t size_hint, bool /* hardware */,
-             NativeBreakpointSP &breakpoint_sp) -> Error {
+             NativeBreakpointSP &breakpoint_sp) -> Status {
         return SoftwareBreakpoint::CreateSoftwareBreakpoint(
             *this, addr, size_hint, breakpoint_sp);
       });
 }
 
-Error NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
-                                              bool hardware) {
+Status NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
+                                               bool hardware) {
   if (hardware)
     return RemoveHardwareBreakpoint(addr);
   else
     return m_breakpoint_list.DecRef(addr);
 }
 
-Error NativeProcessProtocol::EnableBreakpoint(lldb::addr_t addr) {
+Status NativeProcessProtocol::EnableBreakpoint(lldb::addr_t addr) {
   return m_breakpoint_list.EnableBreakpoint(addr);
 }
 
-Error NativeProcessProtocol::DisableBreakpoint(lldb::addr_t addr) {
+Status NativeProcessProtocol::DisableBreakpoint(lldb::addr_t addr) {
   return m_breakpoint_list.DisableBreakpoint(addr);
 }
 
@@ -483,25 +484,26 @@ void NativeProcessProtocol::DoStopIDBumped(uint32_t /* newBumpId */) {
   // Default implementation does nothing.
 }
 
-Error NativeProcessProtocol::ResolveProcessArchitecture(lldb::pid_t pid,
-                                                        ArchSpec &arch) {
+Status NativeProcessProtocol::ResolveProcessArchitecture(lldb::pid_t pid,
+                                                         ArchSpec &arch) {
   // Grab process info for the running process.
   ProcessInstanceInfo process_info;
   if (!Host::GetProcessInfo(pid, process_info))
-    return Error("failed to get process info");
+    return Status("failed to get process info");
 
   // Resolve the executable module.
   ModuleSpecList module_specs;
   if (!ObjectFile::GetModuleSpecifications(process_info.GetExecutableFile(), 0,
                                            0, module_specs))
-    return Error("failed to get module specifications");
+    return Status("failed to get module specifications");
   lldbassert(module_specs.GetSize() == 1);
 
   arch = module_specs.GetModuleSpecRefAtIndex(0).GetArchitecture();
   if (arch.IsValid())
-    return Error();
+    return Status();
   else
-    return Error("failed to retrieve a valid architecture from the exe module");
+    return Status(
+        "failed to retrieve a valid architecture from the exe module");
 }
 
 #if !defined(__linux__) && !defined(__NetBSD__)
@@ -509,17 +511,17 @@ Error NativeProcessProtocol::ResolveProcessArchitecture(lldb::pid_t pid,
 // Stubs are
 // provided to make the rest of the code link on non-supported platforms.
 
-Error NativeProcessProtocol::Launch(ProcessLaunchInfo &launch_info,
-                                    NativeDelegate &native_delegate,
-                                    MainLoop &mainloop,
-                                    NativeProcessProtocolSP &process_sp) {
+Status NativeProcessProtocol::Launch(ProcessLaunchInfo &launch_info,
+                                     NativeDelegate &native_delegate,
+                                     MainLoop &mainloop,
+                                     NativeProcessProtocolSP &process_sp) {
   llvm_unreachable("Platform has no NativeProcessProtocol support");
 }
 
-Error NativeProcessProtocol::Attach(lldb::pid_t pid,
-                                    NativeDelegate &native_delegate,
-                                    MainLoop &mainloop,
-                                    NativeProcessProtocolSP &process_sp) {
+Status NativeProcessProtocol::Attach(lldb::pid_t pid,
+                                     NativeDelegate &native_delegate,
+                                     MainLoop &mainloop,
+                                     NativeProcessProtocolSP &process_sp) {
   llvm_unreachable("Platform has no NativeProcessProtocol support");
 }
 
diff --git a/source/Host/common/NativeRegisterContext.cpp b/source/Host/common/NativeRegisterContext.cpp
index 3bc0a0d9705c6..2ca95d7079638 100644
--- a/source/Host/common/NativeRegisterContext.cpp
+++ b/source/Host/common/NativeRegisterContext.cpp
@@ -138,7 +138,7 @@ NativeRegisterContext::GetPCfromBreakpointLocation(lldb::addr_t fail_value) {
   return GetPC(fail_value);
 }
 
-Error NativeRegisterContext::SetPC(lldb::addr_t pc) {
+Status NativeRegisterContext::SetPC(lldb::addr_t pc) {
   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_PC);
   return WriteRegisterFromUnsigned(reg, pc);
@@ -150,7 +150,7 @@ lldb::addr_t NativeRegisterContext::GetSP(lldb::addr_t fail_value) {
   return ReadRegisterAsUnsigned(reg, fail_value);
 }
 
-Error NativeRegisterContext::SetSP(lldb::addr_t sp) {
+Status NativeRegisterContext::SetSP(lldb::addr_t sp) {
   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_SP);
   return WriteRegisterFromUnsigned(reg, sp);
@@ -162,7 +162,7 @@ lldb::addr_t NativeRegisterContext::GetFP(lldb::addr_t fail_value) {
   return ReadRegisterAsUnsigned(reg, fail_value);
 }
 
-Error NativeRegisterContext::SetFP(lldb::addr_t fp) {
+Status NativeRegisterContext::SetFP(lldb::addr_t fp) {
   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_FP);
   return WriteRegisterFromUnsigned(reg, fp);
@@ -195,7 +195,7 @@ NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
 
   if (reg_info) {
     RegisterValue value;
-    Error error = ReadRegister(reg_info, value);
+    Status error = ReadRegister(reg_info, value);
     if (error.Success()) {
       if (log)
         log->Printf("NativeRegisterContext::%s ReadRegister() succeeded, value "
@@ -215,22 +215,23 @@ NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
   return fail_value;
 }
 
-Error NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
-                                                       uint64_t uval) {
+Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
+                                                        uint64_t uval) {
   if (reg == LLDB_INVALID_REGNUM)
-    return Error("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
+    return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
 }
 
-Error NativeRegisterContext::WriteRegisterFromUnsigned(
-    const RegisterInfo *reg_info, uint64_t uval) {
+Status
+NativeRegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
+                                                 uint64_t uval) {
   assert(reg_info);
   if (!reg_info)
-    return Error("reg_info is nullptr");
+    return Status("reg_info is nullptr");
 
   RegisterValue value;
   if (!value.SetUInt(uval, reg_info->byte_size))
-    return Error("RegisterValue::SetUInt () failed");
+    return Status("RegisterValue::SetUInt () failed");
 
   return WriteRegister(reg_info, value);
 }
@@ -246,18 +247,18 @@ uint32_t NativeRegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
   return LLDB_INVALID_INDEX32;
 }
 
-Error NativeRegisterContext::ClearAllHardwareBreakpoints() {
-  return Error("not implemented");
+Status NativeRegisterContext::ClearAllHardwareBreakpoints() {
+  return Status("not implemented");
 }
 
 bool NativeRegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) {
   return false;
 }
 
-Error NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
-                                                      lldb::addr_t trap_addr) {
+Status NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                                       lldb::addr_t trap_addr) {
   bp_index = LLDB_INVALID_INDEX32;
-  return Error("not implemented");
+  return Status("not implemented");
 }
 
 uint32_t NativeRegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
@@ -272,25 +273,25 @@ bool NativeRegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
   return false;
 }
 
-Error NativeRegisterContext::ClearAllHardwareWatchpoints() {
-  return Error("not implemented");
+Status NativeRegisterContext::ClearAllHardwareWatchpoints() {
+  return Status("not implemented");
 }
 
-Error NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) {
+Status NativeRegisterContext::IsWatchpointHit(uint32_t wp_index, bool &is_hit) {
   is_hit = false;
-  return Error("not implemented");
+  return Status("not implemented");
 }
 
-Error NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index,
-                                                   lldb::addr_t trap_addr) {
+Status NativeRegisterContext::GetWatchpointHitIndex(uint32_t &wp_index,
+                                                    lldb::addr_t trap_addr) {
   wp_index = LLDB_INVALID_INDEX32;
-  return Error("not implemented");
+  return Status("not implemented");
 }
 
-Error NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index,
-                                                bool &is_vacant) {
+Status NativeRegisterContext::IsWatchpointVacant(uint32_t wp_index,
+                                                 bool &is_vacant) {
   is_vacant = false;
-  return Error("not implemented");
+  return Status("not implemented");
 }
 
 lldb::addr_t NativeRegisterContext::GetWatchpointAddress(uint32_t wp_index) {
@@ -303,10 +304,10 @@ lldb::addr_t NativeRegisterContext::GetWatchpointHitAddress(uint32_t wp_index) {
 
 bool NativeRegisterContext::HardwareSingleStep(bool enable) { return false; }
 
-Error NativeRegisterContext::ReadRegisterValueFromMemory(
+Status NativeRegisterContext::ReadRegisterValueFromMemory(
     const RegisterInfo *reg_info, lldb::addr_t src_addr, size_t src_len,
     RegisterValue &reg_value) {
-  Error error;
+  Status error;
   if (reg_info == nullptr) {
     error.SetErrorString("invalid register info argument.");
     return error;
@@ -321,7 +322,7 @@ Error NativeRegisterContext::ReadRegisterValueFromMemory(
   //
   // Case 2: src_len > dst_len
   //
-  //   Error!  (The register should always be big enough to hold the data)
+  //   Status!  (The register should always be big enough to hold the data)
   //
   // Case 3: src_len < dst_len
   //
@@ -383,13 +384,13 @@ Error NativeRegisterContext::ReadRegisterValueFromMemory(
   return error;
 }
 
-Error NativeRegisterContext::WriteRegisterValueToMemory(
+Status NativeRegisterContext::WriteRegisterValueToMemory(
     const RegisterInfo *reg_info, lldb::addr_t dst_addr, size_t dst_len,
     const RegisterValue &reg_value) {
 
   uint8_t dst[RegisterValue::kMaxRegisterByteSize];
 
-  Error error;
+  Status error;
 
   NativeProcessProtocolSP process_sp(m_thread.GetProcess());
   if (process_sp) {
@@ -400,7 +401,7 @@ Error NativeRegisterContext::WriteRegisterValueToMemory(
     // they are the same.
     lldb::ByteOrder byte_order;
     if (!process_sp->GetByteOrder(byte_order))
-      return Error("NativeProcessProtocol::GetByteOrder () failed");
+      return Status("NativeProcessProtocol::GetByteOrder () failed");
 
     const size_t bytes_copied =
         reg_value.GetAsMemoryData(reg_info, dst, dst_len, byte_order, error);
diff --git a/source/Host/common/NativeThreadProtocol.cpp b/source/Host/common/NativeThreadProtocol.cpp
index 2e76cff0d670f..29e25bbc56927 100644
--- a/source/Host/common/NativeThreadProtocol.cpp
+++ b/source/Host/common/NativeThreadProtocol.cpp
@@ -20,46 +20,46 @@ NativeThreadProtocol::NativeThreadProtocol(NativeProcessProtocol *process,
                                            lldb::tid_t tid)
     : m_process_wp(process->shared_from_this()), m_tid(tid) {}
 
-Error NativeThreadProtocol::ReadRegister(uint32_t reg,
-                                         RegisterValue &reg_value) {
+Status NativeThreadProtocol::ReadRegister(uint32_t reg,
+                                          RegisterValue &reg_value) {
   NativeRegisterContextSP register_context_sp = GetRegisterContext();
   if (!register_context_sp)
-    return Error("no register context");
+    return Status("no register context");
 
   const RegisterInfo *const reg_info =
       register_context_sp->GetRegisterInfoAtIndex(reg);
   if (!reg_info)
-    return Error("no register info for reg num %" PRIu32, reg);
+    return Status("no register info for reg num %" PRIu32, reg);
 
   return register_context_sp->ReadRegister(reg_info, reg_value);
   ;
 }
 
-Error NativeThreadProtocol::WriteRegister(uint32_t reg,
-                                          const RegisterValue &reg_value) {
+Status NativeThreadProtocol::WriteRegister(uint32_t reg,
+                                           const RegisterValue &reg_value) {
   NativeRegisterContextSP register_context_sp = GetRegisterContext();
   if (!register_context_sp)
-    return Error("no register context");
+    return Status("no register context");
 
   const RegisterInfo *const reg_info =
       register_context_sp->GetRegisterInfoAtIndex(reg);
   if (!reg_info)
-    return Error("no register info for reg num %" PRIu32, reg);
+    return Status("no register info for reg num %" PRIu32, reg);
 
   return register_context_sp->WriteRegister(reg_info, reg_value);
 }
 
-Error NativeThreadProtocol::SaveAllRegisters(lldb::DataBufferSP &data_sp) {
+Status NativeThreadProtocol::SaveAllRegisters(lldb::DataBufferSP &data_sp) {
   NativeRegisterContextSP register_context_sp = GetRegisterContext();
   if (!register_context_sp)
-    return Error("no register context");
+    return Status("no register context");
   return register_context_sp->WriteAllRegisterValues(data_sp);
 }
 
-Error NativeThreadProtocol::RestoreAllRegisters(lldb::DataBufferSP &data_sp) {
+Status NativeThreadProtocol::RestoreAllRegisters(lldb::DataBufferSP &data_sp) {
   NativeRegisterContextSP register_context_sp = GetRegisterContext();
   if (!register_context_sp)
-    return Error("no register context");
+    return Status("no register context");
   return register_context_sp->ReadAllRegisterValues(data_sp);
 }
 
diff --git a/source/Host/common/NativeWatchpointList.cpp b/source/Host/common/NativeWatchpointList.cpp
index 168e5b42b961c..e6ef7300eb22a 100644
--- a/source/Host/common/NativeWatchpointList.cpp
+++ b/source/Host/common/NativeWatchpointList.cpp
@@ -14,15 +14,15 @@
 using namespace lldb;
 using namespace lldb_private;
 
-Error NativeWatchpointList::Add(addr_t addr, size_t size, uint32_t watch_flags,
-                                bool hardware) {
+Status NativeWatchpointList::Add(addr_t addr, size_t size, uint32_t watch_flags,
+                                 bool hardware) {
   m_watchpoints[addr] = {addr, size, watch_flags, hardware};
-  return Error();
+  return Status();
 }
 
-Error NativeWatchpointList::Remove(addr_t addr) {
+Status NativeWatchpointList::Remove(addr_t addr) {
   m_watchpoints.erase(addr);
-  return Error();
+  return Status();
 }
 
 const NativeWatchpointList::WatchpointMap &
diff --git a/source/Host/common/PipeBase.cpp b/source/Host/common/PipeBase.cpp
index cf7e6c97c3c3f..632bfcb3a2e0e 100644
--- a/source/Host/common/PipeBase.cpp
+++ b/source/Host/common/PipeBase.cpp
@@ -13,12 +13,13 @@ using namespace lldb_private;
 
 PipeBase::~PipeBase() = default;
 
-Error PipeBase::OpenAsWriter(llvm::StringRef name, bool child_process_inherit) {
+Status PipeBase::OpenAsWriter(llvm::StringRef name,
+                              bool child_process_inherit) {
   return OpenAsWriterWithTimeout(name, child_process_inherit,
                                  std::chrono::microseconds::zero());
 }
 
-Error PipeBase::Read(void *buf, size_t size, size_t &bytes_read) {
+Status PipeBase::Read(void *buf, size_t size, size_t &bytes_read) {
   return ReadWithTimeout(buf, size, std::chrono::microseconds::zero(),
                          bytes_read);
 }
diff --git a/source/Host/common/Socket.cpp b/source/Host/common/Socket.cpp
index d73b5d0ad0732..0df9dc02c70fb 100644
--- a/source/Host/common/Socket.cpp
+++ b/source/Host/common/Socket.cpp
@@ -79,7 +79,7 @@ Socket::~Socket() { Close(); }
 
 std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
                                        bool child_processes_inherit,
-                                       Error &error) {
+                                       Status &error) {
   error.Clear();
 
   std::unique_ptr<Socket> socket_up;
@@ -118,14 +118,14 @@ std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
   return socket_up;
 }
 
-Error Socket::TcpConnect(llvm::StringRef host_and_port,
-                         bool child_processes_inherit, Socket *&socket) {
+Status Socket::TcpConnect(llvm::StringRef host_and_port,
+                          bool child_processes_inherit, Socket *&socket) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
   if (log)
     log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
                 host_and_port.data());
 
-  Error error;
+  Status error;
   std::unique_ptr<Socket> connect_socket(
       Create(ProtocolTcp, child_processes_inherit, error));
   if (error.Fail())
@@ -138,14 +138,14 @@ Error Socket::TcpConnect(llvm::StringRef host_and_port,
   return error;
 }
 
-Error Socket::TcpListen(llvm::StringRef host_and_port,
-                        bool child_processes_inherit, Socket *&socket,
-                        Predicate<uint16_t> *predicate, int backlog) {
+Status Socket::TcpListen(llvm::StringRef host_and_port,
+                         bool child_processes_inherit, Socket *&socket,
+                         Predicate<uint16_t> *predicate, int backlog) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("Socket::%s (%s)", __FUNCTION__, host_and_port.data());
 
-  Error error;
+  Status error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
@@ -179,8 +179,8 @@ Error Socket::TcpListen(llvm::StringRef host_and_port,
   return error;
 }
 
-Error Socket::UdpConnect(llvm::StringRef host_and_port,
-                         bool child_processes_inherit, Socket *&socket) {
+Status Socket::UdpConnect(llvm::StringRef host_and_port,
+                          bool child_processes_inherit, Socket *&socket) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("Socket::%s (host/port = %s)", __FUNCTION__,
@@ -189,9 +189,10 @@ Error Socket::UdpConnect(llvm::StringRef host_and_port,
   return UDPSocket::Connect(host_and_port, child_processes_inherit, socket);
 }
 
-Error Socket::UnixDomainConnect(llvm::StringRef name,
-                                bool child_processes_inherit, Socket *&socket) {
-  Error error;
+Status Socket::UnixDomainConnect(llvm::StringRef name,
+                                 bool child_processes_inherit,
+                                 Socket *&socket) {
+  Status error;
   std::unique_ptr<Socket> connect_socket(
       Create(ProtocolUnixDomain, child_processes_inherit, error));
   if (error.Fail())
@@ -204,9 +205,9 @@ Error Socket::UnixDomainConnect(llvm::StringRef name,
   return error;
 }
 
-Error Socket::UnixDomainAccept(llvm::StringRef name,
-                               bool child_processes_inherit, Socket *&socket) {
-  Error error;
+Status Socket::UnixDomainAccept(llvm::StringRef name,
+                                bool child_processes_inherit, Socket *&socket) {
+  Status error;
   std::unique_ptr<Socket> listen_socket(
       Create(ProtocolUnixDomain, child_processes_inherit, error));
   if (error.Fail())
@@ -220,10 +221,10 @@ Error Socket::UnixDomainAccept(llvm::StringRef name,
   return error;
 }
 
-Error Socket::UnixAbstractConnect(llvm::StringRef name,
-                                  bool child_processes_inherit,
-                                  Socket *&socket) {
-  Error error;
+Status Socket::UnixAbstractConnect(llvm::StringRef name,
+                                   bool child_processes_inherit,
+                                   Socket *&socket) {
+  Status error;
   std::unique_ptr<Socket> connect_socket(
       Create(ProtocolUnixAbstract, child_processes_inherit, error));
   if (error.Fail())
@@ -235,10 +236,10 @@ Error Socket::UnixAbstractConnect(llvm::StringRef name,
   return error;
 }
 
-Error Socket::UnixAbstractAccept(llvm::StringRef name,
-                                 bool child_processes_inherit,
-                                 Socket *&socket) {
-  Error error;
+Status Socket::UnixAbstractAccept(llvm::StringRef name,
+                                  bool child_processes_inherit,
+                                  Socket *&socket) {
+  Status error;
   std::unique_ptr<Socket> listen_socket(
       Create(ProtocolUnixAbstract, child_processes_inherit, error));
   if (error.Fail())
@@ -254,7 +255,7 @@ Error Socket::UnixAbstractAccept(llvm::StringRef name,
 
 bool Socket::DecodeHostAndPort(llvm::StringRef host_and_port,
                                std::string &host_str, std::string &port_str,
-                               int32_t &port, Error *error_ptr) {
+                               int32_t &port, Status *error_ptr) {
   static RegularExpression g_regex(
       llvm::StringRef("([^:]+|\\[[0-9a-fA-F:]+.*\\]):([0-9]+)"));
   RegularExpression::Match regex_match(2);
@@ -304,8 +305,8 @@ IOObject::WaitableHandle Socket::GetWaitableHandle() {
   return m_socket;
 }
 
-Error Socket::Read(void *buf, size_t &num_bytes) {
-  Error error;
+Status Socket::Read(void *buf, size_t &num_bytes) {
+  Status error;
   int bytes_received = 0;
   do {
     bytes_received = ::recv(m_socket, static_cast<char *>(buf), num_bytes, 0);
@@ -330,8 +331,8 @@ Error Socket::Read(void *buf, size_t &num_bytes) {
   return error;
 }
 
-Error Socket::Write(const void *buf, size_t &num_bytes) {
-  Error error;
+Status Socket::Write(const void *buf, size_t &num_bytes) {
+  Status error;
   int bytes_sent = 0;
   do {
     bytes_sent = Send(buf, num_bytes);
@@ -356,13 +357,13 @@ Error Socket::Write(const void *buf, size_t &num_bytes) {
   return error;
 }
 
-Error Socket::PreDisconnect() {
-  Error error;
+Status Socket::PreDisconnect() {
+  Status error;
   return error;
 }
 
-Error Socket::Close() {
-  Error error;
+Status Socket::Close() {
+  Status error;
   if (!IsValid() || !m_should_close_fd)
     return error;
 
@@ -404,7 +405,7 @@ size_t Socket::Send(const void *buf, const size_t num_bytes) {
   return ::send(m_socket, static_cast<const char *>(buf), num_bytes, 0);
 }
 
-void Socket::SetLastError(Error &error) {
+void Socket::SetLastError(Status &error) {
 #if defined(_WIN32)
   error.SetError(::WSAGetLastError(), lldb::eErrorTypeWin32);
 #else
@@ -414,7 +415,7 @@ void Socket::SetLastError(Error &error) {
 
 NativeSocket Socket::CreateSocket(const int domain, const int type,
                                   const int protocol,
-                                  bool child_processes_inherit, Error &error) {
+                                  bool child_processes_inherit, Status &error) {
   error.Clear();
   auto socket_type = type;
 #ifdef SOCK_CLOEXEC
@@ -430,7 +431,7 @@ NativeSocket Socket::CreateSocket(const int domain, const int type,
 
 NativeSocket Socket::AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
                                   socklen_t *addrlen,
-                                  bool child_processes_inherit, Error &error) {
+                                  bool child_processes_inherit, Status &error) {
   error.Clear();
 #if defined(ANDROID_USE_ACCEPT_WORKAROUND)
   // Hack:
diff --git a/source/Host/common/SoftwareBreakpoint.cpp b/source/Host/common/SoftwareBreakpoint.cpp
index 436cb2bb112ee..14dbafd94c039 100644
--- a/source/Host/common/SoftwareBreakpoint.cpp
+++ b/source/Host/common/SoftwareBreakpoint.cpp
@@ -10,8 +10,8 @@
 #include "lldb/Host/common/SoftwareBreakpoint.h"
 
 #include "lldb/Host/Debug.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
@@ -21,7 +21,7 @@ using namespace lldb_private;
 // static members
 // -------------------------------------------------------------------
 
-Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
+Status SoftwareBreakpoint::CreateSoftwareBreakpoint(
     NativeProcessProtocol &process, lldb::addr_t addr, size_t size_hint,
     NativeBreakpointSP &breakpoint_sp) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
@@ -30,15 +30,15 @@ Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
 
   // Validate the address.
   if (addr == LLDB_INVALID_ADDRESS)
-    return Error("SoftwareBreakpoint::%s invalid load address specified.",
-                 __FUNCTION__);
+    return Status("SoftwareBreakpoint::%s invalid load address specified.",
+                  __FUNCTION__);
 
   // Ask the NativeProcessProtocol subclass to fill in the correct software
   // breakpoint
   // trap for the breakpoint site.
   size_t bp_opcode_size = 0;
   const uint8_t *bp_opcode_bytes = NULL;
-  Error error = process.GetSoftwareBreakpointTrapOpcode(
+  Status error = process.GetSoftwareBreakpointTrapOpcode(
       size_hint, bp_opcode_size, bp_opcode_bytes);
 
   if (error.Fail()) {
@@ -54,10 +54,10 @@ Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to retrieve any trap opcodes",
                   __FUNCTION__);
-    return Error("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
-                 "returned zero, unable to get breakpoint trap for address "
-                 "0x%" PRIx64,
-                 addr);
+    return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
+                  "returned zero, unable to get breakpoint trap for address "
+                  "0x%" PRIx64,
+                  addr);
   }
 
   if (bp_opcode_size > MAX_TRAP_OPCODE_SIZE) {
@@ -65,10 +65,10 @@ Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
       log->Printf("SoftwareBreakpoint::%s cannot support %zu trapcode bytes, "
                   "max size is %zu",
                   __FUNCTION__, bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
-    return Error("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
-                 "returned too many trap opcode bytes: requires %zu but we "
-                 "only support a max of %zu",
-                 bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
+    return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
+                  "returned too many trap opcode bytes: requires %zu but we "
+                  "only support a max of %zu",
+                  bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
   }
 
   // Validate that we received opcodes.
@@ -76,10 +76,10 @@ Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to retrieve trap opcode bytes",
                   __FUNCTION__);
-    return Error("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
-                 "returned NULL trap opcode bytes, unable to get breakpoint "
-                 "trap for address 0x%" PRIx64,
-                 addr);
+    return Status("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
+                  "returned NULL trap opcode bytes, unable to get breakpoint "
+                  "trap for address 0x%" PRIx64,
+                  addr);
   }
 
   // Enable the breakpoint.
@@ -103,10 +103,10 @@ Error SoftwareBreakpoint::CreateSoftwareBreakpoint(
   // breakpoint.
   breakpoint_sp.reset(new SoftwareBreakpoint(process, addr, saved_opcode_bytes,
                                              bp_opcode_bytes, bp_opcode_size));
-  return Error();
+  return Status();
 }
 
-Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
+Status SoftwareBreakpoint::EnableSoftwareBreakpoint(
     NativeProcessProtocol &process, lldb::addr_t addr, size_t bp_opcode_size,
     const uint8_t *bp_opcode_bytes, uint8_t *saved_opcode_bytes) {
   assert(bp_opcode_size <= MAX_TRAP_OPCODE_SIZE &&
@@ -121,7 +121,7 @@ Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
   // Save the original opcodes by reading them so we can restore later.
   size_t bytes_read = 0;
 
-  Error error =
+  Status error =
       process.ReadMemory(addr, saved_opcode_bytes, bp_opcode_size, bytes_read);
   if (error.Fail()) {
     if (log)
@@ -138,10 +138,10 @@ Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
                   "attempting to set breakpoint: attempted to read %zu bytes "
                   "but only read %zu",
                   __FUNCTION__, bp_opcode_size, bytes_read);
-    return Error("SoftwareBreakpoint::%s failed to read memory while "
-                 "attempting to set breakpoint: attempted to read %zu bytes "
-                 "but only read %zu",
-                 __FUNCTION__, bp_opcode_size, bytes_read);
+    return Status("SoftwareBreakpoint::%s failed to read memory while "
+                  "attempting to set breakpoint: attempted to read %zu bytes "
+                  "but only read %zu",
+                  __FUNCTION__, bp_opcode_size, bytes_read);
   }
 
   // Log what we read.
@@ -197,10 +197,11 @@ Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
                   "attempting to verify breakpoint: attempted to read %zu "
                   "bytes but only read %zu",
                   __FUNCTION__, bp_opcode_size, verify_bytes_read);
-    return Error("SoftwareBreakpoint::%s failed to read memory while "
-                 "attempting to verify breakpoint: attempted to read %zu bytes "
-                 "but only read %zu",
-                 __FUNCTION__, bp_opcode_size, verify_bytes_read);
+    return Status(
+        "SoftwareBreakpoint::%s failed to read memory while "
+        "attempting to verify breakpoint: attempted to read %zu bytes "
+        "but only read %zu",
+        __FUNCTION__, bp_opcode_size, verify_bytes_read);
   }
 
   if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) != 0) {
@@ -209,17 +210,17 @@ Error SoftwareBreakpoint::EnableSoftwareBreakpoint(
                   "writing failed - trap opcodes not successfully read back "
                   "after writing when setting breakpoint at 0x%" PRIx64,
                   __FUNCTION__, addr);
-    return Error("SoftwareBreakpoint::%s: verification of software breakpoint "
-                 "writing failed - trap opcodes not successfully read back "
-                 "after writing when setting breakpoint at 0x%" PRIx64,
-                 __FUNCTION__, addr);
+    return Status("SoftwareBreakpoint::%s: verification of software breakpoint "
+                  "writing failed - trap opcodes not successfully read back "
+                  "after writing when setting breakpoint at 0x%" PRIx64,
+                  __FUNCTION__, addr);
   }
 
   if (log)
     log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64 " -- SUCCESS",
                 __FUNCTION__, addr);
 
-  return Error();
+  return Status();
 }
 
 // -------------------------------------------------------------------
@@ -240,13 +241,13 @@ SoftwareBreakpoint::SoftwareBreakpoint(NativeProcessProtocol &process,
   ::memcpy(m_trap_opcodes, trap_opcodes, opcode_size);
 }
 
-Error SoftwareBreakpoint::DoEnable() {
+Status SoftwareBreakpoint::DoEnable() {
   return EnableSoftwareBreakpoint(m_process, m_addr, m_opcode_size,
                                   m_trap_opcodes, m_saved_opcodes);
 }
 
-Error SoftwareBreakpoint::DoDisable() {
-  Error error;
+Status SoftwareBreakpoint::DoDisable() {
+  Status error;
   assert(m_addr && (m_addr != LLDB_INVALID_ADDRESS) &&
          "can't remove a software breakpoint for an invalid address");
 
diff --git a/source/Host/common/Symbols.cpp b/source/Host/common/Symbols.cpp
index 9e0a3b5bf4dfa..1d9180bf528ef 100644
--- a/source/Host/common/Symbols.cpp
+++ b/source/Host/common/Symbols.cpp
@@ -151,8 +151,9 @@ FileSpec LocateExecutableSymbolFileDsym(const ModuleSpec &module_spec) {
   const ArchSpec *arch = module_spec.GetArchitecturePtr();
   const UUID *uuid = module_spec.GetUUIDPtr();
 
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
+      func_cat,
       "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)",
       exec_fspec ? exec_fspec->GetFilename().AsCString("<NULL>") : "<NULL>",
       arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid);
@@ -175,9 +176,9 @@ ModuleSpec Symbols::LocateExecutableObjectFile(const ModuleSpec &module_spec) {
   const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
   const ArchSpec *arch = module_spec.GetArchitecturePtr();
   const UUID *uuid = module_spec.GetUUIDPtr();
+  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
-      LLVM_PRETTY_FUNCTION,
-      "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
+      func_cat, "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
       exec_fspec ? exec_fspec->GetFilename().AsCString("<NULL>") : "<NULL>",
       arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid);
 
diff --git a/source/Host/common/TCPSocket.cpp b/source/Host/common/TCPSocket.cpp
index 55db4bb0c4562..c013334ce23af 100644
--- a/source/Host/common/TCPSocket.cpp
+++ b/source/Host/common/TCPSocket.cpp
@@ -117,8 +117,8 @@ std::string TCPSocket::GetRemoteIPAddress() const {
   return "";
 }
 
-Error TCPSocket::CreateSocket(int domain) {
-  Error error;
+Status TCPSocket::CreateSocket(int domain) {
+  Status error;
   if (IsValid())
     error = Close();
   if (error.Fail())
@@ -128,13 +128,13 @@ Error TCPSocket::CreateSocket(int domain) {
   return error;
 }
 
-Error TCPSocket::Connect(llvm::StringRef name) {
+Status TCPSocket::Connect(llvm::StringRef name) {
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_COMMUNICATION));
   if (log)
     log->Printf("TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
 
-  Error error;
+  Status error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
@@ -166,12 +166,12 @@ Error TCPSocket::Connect(llvm::StringRef name) {
   return error;
 }
 
-Error TCPSocket::Listen(llvm::StringRef name, int backlog) {
+Status TCPSocket::Listen(llvm::StringRef name, int backlog) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("TCPSocket::%s (%s)", __FUNCTION__, name.data());
 
-  Error error;
+  Status error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;
@@ -227,8 +227,8 @@ void TCPSocket::CloseListenSockets() {
   m_listen_sockets.clear();
 }
 
-Error TCPSocket::Accept(Socket *&conn_socket) {
-  Error error;
+Status TCPSocket::Accept(Socket *&conn_socket) {
+  Status error;
   if (m_listen_sockets.size() == 0) {
     error.SetErrorString("No open listening sockets!");
     return error;
diff --git a/source/Host/common/ThreadLauncher.cpp b/source/Host/common/ThreadLauncher.cpp
index 32641efe408a2..f3401016393f3 100644
--- a/source/Host/common/ThreadLauncher.cpp
+++ b/source/Host/common/ThreadLauncher.cpp
@@ -24,9 +24,9 @@ using namespace lldb_private;
 HostThread ThreadLauncher::LaunchThread(llvm::StringRef name,
                                         lldb::thread_func_t thread_function,
                                         lldb::thread_arg_t thread_arg,
-                                        Error *error_ptr,
+                                        Status *error_ptr,
                                         size_t min_stack_byte_size) {
-  Error error;
+  Status error;
   if (error_ptr)
     error_ptr->Clear();
 
diff --git a/source/Host/common/UDPSocket.cpp b/source/Host/common/UDPSocket.cpp
index ce8d90891b2bf..21dacbc626eee 100644
--- a/source/Host/common/UDPSocket.cpp
+++ b/source/Host/common/UDPSocket.cpp
@@ -42,27 +42,27 @@ size_t UDPSocket::Send(const void *buf, const size_t num_bytes) {
                   m_sockaddr, m_sockaddr.GetLength());
 }
 
-Error UDPSocket::Connect(llvm::StringRef name) {
-  return Error("%s", g_not_supported_error);
+Status UDPSocket::Connect(llvm::StringRef name) {
+  return Status("%s", g_not_supported_error);
 }
 
-Error UDPSocket::Listen(llvm::StringRef name, int backlog) {
-  return Error("%s", g_not_supported_error);
+Status UDPSocket::Listen(llvm::StringRef name, int backlog) {
+  return Status("%s", g_not_supported_error);
 }
 
-Error UDPSocket::Accept(Socket *&socket) {
-  return Error("%s", g_not_supported_error);
+Status UDPSocket::Accept(Socket *&socket) {
+  return Status("%s", g_not_supported_error);
 }
 
-Error UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
-                         Socket *&socket) {
+Status UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
+                          Socket *&socket) {
   std::unique_ptr<UDPSocket> final_socket;
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("UDPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
 
-  Error error;
+  Status error;
   std::string host_str;
   std::string port_str;
   int32_t port = INT32_MIN;