Rename Error -> Status.

This renames the LLDB error class to Status, as discussed
on the lldb-dev mailing list.

A change of this magnitude cannot easily be done without
find and replace, but that has potential to catch unwanted
occurrences of common strings such as "Error".  Every effort
was made to find all the obvious things such as the word "Error"
appearing in a string, etc, but it's possible there are still
some lingering occurences left around.  Hopefully nothing too
serious.

llvm-svn: 302872

11 files changed, 128 insertions, 127 deletions

diff --git a/lldb/source/Expression/DWARFExpression.cpp b/lldb/source/Expression/DWARFExpression.cpp
index 928577cd7ee..592a30cdd78 100644
--- a/lldb/source/Expression/DWARFExpression.cpp
+++ b/lldb/source/Expression/DWARFExpression.cpp
@@ -655,7 +655,7 @@ void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
 
 static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
                                       lldb::RegisterKind reg_kind,
-                                      uint32_t reg_num, Error *error_ptr,
+                                      uint32_t reg_num, Status *error_ptr,
                                       Value &value) {
   if (reg_ctx == NULL) {
     if (error_ptr)
@@ -1250,7 +1250,7 @@ bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
                                lldb::addr_t loclist_base_load_addr,
                                const Value *initial_value_ptr,
                                const Value *object_address_ptr, Value &result,
-                               Error *error_ptr) const {
+                               Status *error_ptr) const {
   ExecutionContext exe_ctx(exe_scope);
   return Evaluate(&exe_ctx, expr_locals, decl_map, nullptr,
                   loclist_base_load_addr, initial_value_ptr, object_address_ptr,
@@ -1261,7 +1261,7 @@ bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, ClangExpressionVariableList *expr_locals,
     ClangExpressionDeclMap *decl_map, RegisterContext *reg_ctx,
     lldb::addr_t loclist_base_load_addr, const Value *initial_value_ptr,
-    const Value *object_address_ptr, Value &result, Error *error_ptr) const {
+    const Value *object_address_ptr, Value &result, Status *error_ptr) const {
   ModuleSP module_sp = m_module_wp.lock();
 
   if (IsLocationList()) {
@@ -1333,7 +1333,7 @@ bool DWARFExpression::Evaluate(
     DWARFCompileUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
     const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
     const Value *initial_value_ptr, const Value *object_address_ptr,
-    Value &result, Error *error_ptr) {
+    Value &result, Status *error_ptr) {
 
   if (opcodes_length == 0) {
     if (error_ptr)
@@ -1467,7 +1467,7 @@ bool DWARFExpression::Evaluate(
           if (process) {
             lldb::addr_t pointer_addr =
                 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
-            Error error;
+            Status error;
             lldb::addr_t pointer_value =
                 process->ReadPointerFromMemory(pointer_addr, error);
             if (pointer_value != LLDB_INVALID_ADDRESS) {
@@ -1572,7 +1572,7 @@ bool DWARFExpression::Evaluate(
             lldb::addr_t pointer_addr =
                 stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
             uint8_t addr_bytes[sizeof(lldb::addr_t)];
-            Error error;
+            Status error;
             if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) ==
                 size) {
               DataExtractor addr_data(addr_bytes, sizeof(addr_bytes),
@@ -2568,7 +2568,7 @@ bool DWARFExpression::Evaluate(
           ::memset(curr_piece.GetBuffer().GetBytes(), 0, piece_byte_size);
           pieces.AppendDataToHostBuffer(curr_piece);
         } else {
-          Error error;
+          Status error;
           // Extract the current piece into "curr_piece"
           Value curr_piece_source_value(stack.back());
           stack.pop_back();
diff --git a/lldb/source/Expression/FunctionCaller.cpp b/lldb/source/Expression/FunctionCaller.cpp
index e2f38a9f50b..6f60f8bf9c1 100644
--- a/lldb/source/Expression/FunctionCaller.cpp
+++ b/lldb/source/Expression/FunctionCaller.cpp
@@ -86,7 +86,7 @@ bool FunctionCaller::WriteFunctionWrapper(
 
   bool can_interpret = false; // should stay that way
 
-  Error jit_error(m_parser->PrepareForExecution(
+  Status jit_error(m_parser->PrepareForExecution(
       m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
       can_interpret, eExecutionPolicyAlways));
 
@@ -135,7 +135,7 @@ bool FunctionCaller::WriteFunctionArguments(
     return false;
   }
 
-  Error error;
+  Status error;
   lldb::ExpressionResults return_value = lldb::eExpressionSetupError;
 
   Process *process = exe_ctx.GetProcessPtr();
@@ -172,7 +172,7 @@ bool FunctionCaller::WriteFunctionArguments(
 
   // FIXME: We will need to extend this for Variadic functions.
 
-  Error value_error;
+  Status value_error;
 
   size_t num_args = arg_values.GetSize();
   if (num_args != m_arg_values.GetSize()) {
@@ -289,7 +289,7 @@ bool FunctionCaller::FetchFunctionResults(ExecutionContext &exe_ctx,
   if (process != jit_process_sp.get())
     return false;
 
-  Error error;
+  Status error;
   ret_value.GetScalar() = process->ReadUnsignedIntegerFromMemory(
       args_addr + m_return_offset, m_return_size, 0, error);
 
diff --git a/lldb/source/Expression/IRDynamicChecks.cpp b/lldb/source/Expression/IRDynamicChecks.cpp
index 44ff6295ca1..0c8cba2050c 100644
--- a/lldb/source/Expression/IRDynamicChecks.cpp
+++ b/lldb/source/Expression/IRDynamicChecks.cpp
@@ -51,7 +51,7 @@ DynamicCheckerFunctions::~DynamicCheckerFunctions() = default;
 
 bool DynamicCheckerFunctions::Install(DiagnosticManager &diagnostic_manager,
                                       ExecutionContext &exe_ctx) {
-  Error error;
+  Status error;
   m_valid_pointer_check.reset(
       exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage(
           g_valid_pointer_check_text, lldb::eLanguageTypeC,
diff --git a/lldb/source/Expression/IRExecutionUnit.cpp b/lldb/source/Expression/IRExecutionUnit.cpp
index 4309caefbd4..e31483f1728 100644
--- a/lldb/source/Expression/IRExecutionUnit.cpp
+++ b/lldb/source/Expression/IRExecutionUnit.cpp
@@ -50,7 +50,7 @@ IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_ap,
       m_reported_allocations(false) {}
 
 lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size,
-                                       Error &error) {
+                                       Status &error) {
   const bool zero_memory = false;
   lldb::addr_t allocation_process_addr =
       Malloc(size, 8, lldb::ePermissionsWritable | lldb::ePermissionsReadable,
@@ -62,7 +62,7 @@ lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size,
   WriteMemory(allocation_process_addr, bytes, size, error);
 
   if (!error.Success()) {
-    Error err;
+    Status err;
     Free(allocation_process_addr, err);
 
     return LLDB_INVALID_ADDRESS;
@@ -71,7 +71,7 @@ lldb::addr_t IRExecutionUnit::WriteNow(const uint8_t *bytes, size_t size,
   if (Log *log =
           lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)) {
     DataBufferHeap my_buffer(size, 0);
-    Error err;
+    Status err;
     ReadMemory(my_buffer.GetBytes(), allocation_process_addr, size, err);
 
     if (err.Success()) {
@@ -90,18 +90,18 @@ void IRExecutionUnit::FreeNow(lldb::addr_t allocation) {
   if (allocation == LLDB_INVALID_ADDRESS)
     return;
 
-  Error err;
+  Status err;
 
   Free(allocation, err);
 }
 
-Error IRExecutionUnit::DisassembleFunction(Stream &stream,
-                                           lldb::ProcessSP &process_wp) {
+Status IRExecutionUnit::DisassembleFunction(Stream &stream,
+                                            lldb::ProcessSP &process_wp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   ExecutionContext exe_ctx(process_wp);
 
-  Error ret;
+  Status ret;
 
   ret.Clear();
 
@@ -152,7 +152,7 @@ Error IRExecutionUnit::DisassembleFunction(Stream &stream,
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(func_range.second, 0));
 
   Process *process = exe_ctx.GetProcessPtr();
-  Error err;
+  Status err;
   process->ReadMemory(func_remote_addr, buffer_sp->GetBytes(),
                       buffer_sp->GetByteSize(), err);
 
@@ -203,7 +203,7 @@ Error IRExecutionUnit::DisassembleFunction(Stream &stream,
 
 static void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic,
                                  void *Context, unsigned LocCookie) {
-  Error *err = static_cast<Error *>(Context);
+  Status *err = static_cast<Status *>(Context);
 
   if (err && err->Success()) {
     err->SetErrorToGenericError();
@@ -216,7 +216,7 @@ void IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) {
   m_failed_lookups.push_back(name);
 }
 
-void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
+void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
                                       lldb::addr_t &func_end) {
   lldb::ProcessSP process_sp(GetProcessWP().lock());
 
@@ -452,7 +452,7 @@ void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
 
     StreamString disassembly_stream;
 
-    Error err = DisassembleFunction(disassembly_stream, process_sp);
+    Status err = DisassembleFunction(disassembly_stream, process_sp);
 
     if (!err.Success()) {
       log->Printf("Couldn't disassemble function : %s",
@@ -467,7 +467,7 @@ void IRExecutionUnit::GetRunnableInfo(Error &error, lldb::addr_t &func_addr,
         record.dump(log);
 
         DataBufferHeap my_buffer(record.m_size, 0);
-        Error err;
+        Status err;
         ReadMemory(my_buffer.GetBytes(), record.m_process_address,
                    record.m_size, err);
 
@@ -643,7 +643,7 @@ uint8_t *IRExecutionUnit::MemoryManager::allocateCodeSection(
   }
 
   if (m_parent.m_reported_allocations) {
-    Error err;
+    Status err;
     lldb::ProcessSP process_sp =
         m_parent.GetBestExecutionContextScope()->CalculateProcess();
 
@@ -675,7 +675,7 @@ uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection(
   }
 
   if (m_parent.m_reported_allocations) {
-    Error err;
+    Status err;
     lldb::ProcessSP process_sp =
         m_parent.GetBestExecutionContextScope()->CalculateProcess();
 
@@ -1104,7 +1104,7 @@ IRExecutionUnit::GetRemoteRangeForLocal(lldb::addr_t local_address) {
 }
 
 bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp,
-                                          Error &error,
+                                          Status &error,
                                           AllocationRecord &record) {
   if (record.m_process_address != LLDB_INVALID_ADDRESS) {
     return true;
@@ -1145,7 +1145,7 @@ bool IRExecutionUnit::CommitOneAllocation(lldb::ProcessSP &process_sp,
 bool IRExecutionUnit::CommitAllocations(lldb::ProcessSP &process_sp) {
   bool ret = true;
 
-  lldb_private::Error err;
+  lldb_private::Status err;
 
   for (AllocationRecord &record : m_records) {
     ret = CommitOneAllocation(process_sp, err, record);
@@ -1189,7 +1189,7 @@ bool IRExecutionUnit::WriteData(lldb::ProcessSP &process_sp) {
   bool wrote_something = false;
   for (AllocationRecord &record : m_records) {
     if (record.m_process_address != LLDB_INVALID_ADDRESS) {
-      lldb_private::Error err;
+      lldb_private::Status err;
       WriteMemory(record.m_process_address, (uint8_t *)record.m_host_address,
                   record.m_size, err);
       if (err.Success())
diff --git a/lldb/source/Expression/IRInterpreter.cpp b/lldb/source/Expression/IRInterpreter.cpp
index 6867443cdf5..6b5e22329af 100644
--- a/lldb/source/Expression/IRInterpreter.cpp
+++ b/lldb/source/Expression/IRInterpreter.cpp
@@ -18,8 +18,8 @@
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/Target/ABI.h"
@@ -189,7 +189,7 @@ public:
       size_t value_size = m_target_data.getTypeStoreSize(value->getType());
 
       lldb_private::DataExtractor value_extractor;
-      lldb_private::Error extract_error;
+      lldb_private::Status extract_error;
 
       m_execution_unit.GetMemoryData(value_extractor, process_address,
                                      value_size, extract_error);
@@ -224,13 +224,13 @@ public:
 
     lldb_private::DataBufferHeap buf(value_byte_size, 0);
 
-    lldb_private::Error get_data_error;
+    lldb_private::Status get_data_error;
 
     if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(),
                                      m_byte_order, get_data_error))
       return false;
 
-    lldb_private::Error write_error;
+    lldb_private::Status write_error;
 
     m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
                                  buf.GetByteSize(), write_error);
@@ -322,12 +322,12 @@ public:
     if (data_address == LLDB_INVALID_ADDRESS)
       return false;
 
-    lldb_private::Error write_error;
+    lldb_private::Status write_error;
 
     m_execution_unit.WritePointerToMemory(data_address, address, write_error);
 
     if (!write_error.Success()) {
-      lldb_private::Error free_error;
+      lldb_private::Status free_error;
       m_execution_unit.Free(data_address, free_error);
       return false;
     }
@@ -356,7 +356,7 @@ public:
     size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
     lldb_private::DataBufferHeap buf(constant_size, 0);
 
-    lldb_private::Error get_data_error;
+    lldb_private::Status get_data_error;
 
     lldb_private::Scalar resolved_scalar(
         resolved_value.zextOrTrunc(llvm::NextPowerOf2(constant_size) * 8));
@@ -364,7 +364,7 @@ public:
                                          m_byte_order, get_data_error))
       return false;
 
-    lldb_private::Error write_error;
+    lldb_private::Status write_error;
 
     m_execution_unit.WriteMemory(process_address, buf.GetBytes(),
                                  buf.GetByteSize(), write_error);
@@ -391,7 +391,7 @@ public:
   }
 
   lldb::addr_t Malloc(llvm::Type *type) {
-    lldb_private::Error alloc_error;
+    lldb_private::Status alloc_error;
 
     return Malloc(m_target_data.getTypeAllocSize(type),
                   m_target_data.getPrefTypeAlignment(type));
@@ -402,7 +402,7 @@ public:
 
     lldb_private::DataBufferHeap buf(length, 0);
 
-    lldb_private::Error read_error;
+    lldb_private::Status read_error;
 
     m_execution_unit.ReadMemory(buf.GetBytes(), addr, length, read_error);
 
@@ -433,7 +433,7 @@ public:
 
     if (const Constant *constant = dyn_cast<Constant>(value)) {
       if (!ResolveConstant(data_address, constant)) {
-        lldb_private::Error free_error;
+        lldb_private::Status free_error;
         m_execution_unit.Free(data_address, free_error);
         return LLDB_INVALID_ADDRESS;
       }
@@ -499,7 +499,7 @@ static bool CanResolveConstant(llvm::Constant *constant) {
 }
 
 bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
-                                 lldb_private::Error &error,
+                                 lldb_private::Status &error,
                                  const bool support_function_calls) {
   lldb_private::Log *log(
       lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
@@ -648,7 +648,7 @@ bool IRInterpreter::CanInterpret(llvm::Module &module, llvm::Function &function,
 bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
                               llvm::ArrayRef<lldb::addr_t> args,
                               lldb_private::IRExecutionUnit &execution_unit,
-                              lldb_private::Error &error,
+                              lldb_private::Status &error,
                               lldb::addr_t stack_frame_bottom,
                               lldb::addr_t stack_frame_top,
                               lldb_private::ExecutionContext &exe_ctx) {
@@ -867,7 +867,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
         return false;
       }
 
-      lldb_private::Error write_error;
+      lldb_private::Status write_error;
 
       execution_unit.WritePointerToMemory(P, R, write_error);
 
@@ -876,7 +876,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
           log->Printf("Couldn't write the result pointer for an AllocaInst");
         error.SetErrorToGenericError();
         error.SetErrorString(memory_write_error);
-        lldb_private::Error free_error;
+        lldb_private::Status free_error;
         execution_unit.Free(P, free_error);
         execution_unit.Free(R, free_error);
         return false;
@@ -1349,7 +1349,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
       }
 
       lldb::addr_t R;
-      lldb_private::Error read_error;
+      lldb_private::Status read_error;
       execution_unit.ReadPointerFromMemory(&R, P, read_error);
 
       if (!read_error.Success()) {
@@ -1374,7 +1374,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
         return false;
       }
 
-      lldb_private::Error write_error;
+      lldb_private::Status write_error;
       execution_unit.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(),
                                  write_error);
       if (!write_error.Success()) {
@@ -1442,7 +1442,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
       }
 
       lldb::addr_t R;
-      lldb_private::Error read_error;
+      lldb_private::Status read_error;
       execution_unit.ReadPointerFromMemory(&R, P, read_error);
 
       if (!read_error.Success()) {
@@ -1467,7 +1467,7 @@ bool IRInterpreter::Interpret(llvm::Module &module, llvm::Function &function,
         return false;
       }
 
-      lldb_private::Error write_error;
+      lldb_private::Status write_error;
       execution_unit.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(),
                                  write_error);
       if (!write_error.Success()) {
diff --git a/lldb/source/Expression/IRMemoryMap.cpp b/lldb/source/Expression/IRMemoryMap.cpp
index 66510ac978a..817c75e66a3 100644
--- a/lldb/source/Expression/IRMemoryMap.cpp
+++ b/lldb/source/Expression/IRMemoryMap.cpp
@@ -14,9 +14,9 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Error.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
 
 using namespace lldb_private;
 
@@ -31,7 +31,7 @@ IRMemoryMap::~IRMemoryMap() {
   if (process_sp) {
     AllocationMap::iterator iter;
 
-    Error err;
+    Status err;
 
     while ((iter = m_allocations.begin()) != m_allocations.end()) {
       err.Clear();
@@ -66,7 +66,7 @@ lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
     return ret;
 
   if (process_is_alive && process_sp->CanJIT()) {
-    Error alloc_error;
+    Status alloc_error;
 
     ret = process_sp->AllocateMemory(size, lldb::ePermissionsReadable |
                                                lldb::ePermissionsWritable,
@@ -104,7 +104,7 @@ lldb::addr_t IRMemoryMap::FindSpace(size_t size) {
                end_of_memory != 0xffffffffull);
 
     MemoryRegionInfo region_info;
-    Error err = process_sp->GetMemoryRegionInfo(ret, region_info);
+    Status err = process_sp->GetMemoryRegionInfo(ret, region_info);
     if (err.Success()) {
       while (true) {
         if (region_info.GetReadable() != MemoryRegionInfo::OptionalBool::eNo ||
@@ -297,7 +297,7 @@ IRMemoryMap::Allocation::Allocation(lldb::addr_t process_alloc,
 
 lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
                                  uint32_t permissions, AllocationPolicy policy,
-                                 bool zero_memory, Error &error) {
+                                 bool zero_memory, Status &error) {
   lldb_private::Log *log(
       lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
   error.Clear();
@@ -397,7 +397,7 @@ lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
                  permissions, alignment, policy);
 
   if (zero_memory) {
-    Error write_error;
+    Status write_error;
     std::vector<uint8_t> zero_buf(size, 0);
     WriteMemory(aligned_address, zero_buf.data(), size, write_error);
   }
@@ -429,7 +429,7 @@ lldb::addr_t IRMemoryMap::Malloc(size_t size, uint8_t alignment,
   return aligned_address;
 }
 
-void IRMemoryMap::Leak(lldb::addr_t process_address, Error &error) {
+void IRMemoryMap::Leak(lldb::addr_t process_address, Status &error) {
   error.Clear();
 
   AllocationMap::iterator iter = m_allocations.find(process_address);
@@ -445,7 +445,7 @@ void IRMemoryMap::Leak(lldb::addr_t process_address, Error &error) {
   allocation.m_leak = true;
 }
 
-void IRMemoryMap::Free(lldb::addr_t process_address, Error &error) {
+void IRMemoryMap::Free(lldb::addr_t process_address, Status &error) {
   error.Clear();
 
   AllocationMap::iterator iter = m_allocations.find(process_address);
@@ -512,7 +512,8 @@ bool IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size) {
 }
 
 void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
-                              const uint8_t *bytes, size_t size, Error &error) {
+                              const uint8_t *bytes, size_t size,
+                              Status &error) {
   error.Clear();
 
   AllocationMap::iterator iter = FindAllocation(process_address, size);
@@ -587,7 +588,7 @@ void IRMemoryMap::WriteMemory(lldb::addr_t process_address,
 
 void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
                                       Scalar &scalar, size_t size,
-                                      Error &error) {
+                                      Status &error) {
   error.Clear();
 
   if (size == UINT32_MAX)
@@ -612,7 +613,7 @@ void IRMemoryMap::WriteScalarToMemory(lldb::addr_t process_address,
 }
 
 void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
-                                       lldb::addr_t address, Error &error) {
+                                       lldb::addr_t address, Status &error) {
   error.Clear();
 
   Scalar scalar(address);
@@ -621,7 +622,7 @@ void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
 }
 
 void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
-                             size_t size, Error &error) {
+                             size_t size, Status &error) {
   error.Clear();
 
   AllocationMap::iterator iter = FindAllocation(process_address, size);
@@ -717,7 +718,7 @@ void IRMemoryMap::ReadMemory(uint8_t *bytes, lldb::addr_t process_address,
 
 void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
                                        lldb::addr_t process_address,
-                                       size_t size, Error &error) {
+                                       size_t size, Status &error) {
   error.Clear();
 
   if (size > 0) {
@@ -760,7 +761,7 @@ void IRMemoryMap::ReadScalarFromMemory(Scalar &scalar,
 
 void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
                                         lldb::addr_t process_address,
-                                        Error &error) {
+                                        Status &error) {
   error.Clear();
 
   Scalar pointer_scalar;
@@ -777,7 +778,7 @@ void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
 
 void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
                                 lldb::addr_t process_address, size_t size,
-                                Error &error) {
+                                Status &error) {
   error.Clear();
 
   if (size > 0) {
diff --git a/lldb/source/Expression/LLVMUserExpression.cpp b/lldb/source/Expression/LLVMUserExpression.cpp
index 396a7e29503..83acb8249ba 100644
--- a/lldb/source/Expression/LLVMUserExpression.cpp
+++ b/lldb/source/Expression/LLVMUserExpression.cpp
@@ -106,7 +106,7 @@ LLVMUserExpression::DoExecute(DiagnosticManager &diagnostic_manager,
         return lldb::eExpressionSetupError;
       }
 
-      Error interpreter_error;
+      Status interpreter_error;
 
       std::vector<lldb::addr_t> args;
 
@@ -270,7 +270,7 @@ bool LLVMUserExpression::FinalizeJITExecution(
     return false;
   }
 
-  Error dematerialize_error;
+  Status dematerialize_error;
 
   m_dematerializer_sp->Dematerialize(dematerialize_error, function_stack_bottom,
                                      function_stack_top);
@@ -309,7 +309,7 @@ bool LLVMUserExpression::PrepareToExecuteJITExpression(
 
   if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) {
     if (m_materialized_address == LLDB_INVALID_ADDRESS) {
-      Error alloc_error;
+      Status alloc_error;
 
       IRMemoryMap::AllocationPolicy policy =
           m_can_interpret ? IRMemoryMap::eAllocationPolicyHostOnly
@@ -335,7 +335,7 @@ bool LLVMUserExpression::PrepareToExecuteJITExpression(
     struct_address = m_materialized_address;
 
     if (m_can_interpret && m_stack_frame_bottom == LLDB_INVALID_ADDRESS) {
-      Error alloc_error;
+      Status alloc_error;
 
       const size_t stack_frame_size = 512 * 1024;
 
@@ -357,7 +357,7 @@ bool LLVMUserExpression::PrepareToExecuteJITExpression(
       }
     }
 
-    Error materialize_error;
+    Status materialize_error;
 
     m_dematerializer_sp = m_materializer_ap->Materialize(
         frame, *m_execution_unit_sp, struct_address, materialize_error);
diff --git a/lldb/source/Expression/Materializer.cpp b/lldb/source/Expression/Materializer.cpp
index 8a22daa5acd..39fc5c8c253 100644
--- a/lldb/source/Expression/Materializer.cpp
+++ b/lldb/source/Expression/Materializer.cpp
@@ -74,12 +74,12 @@ public:
     m_alignment = 8;
   }
 
-  void MakeAllocation(IRMemoryMap &map, Error &err) {
+  void MakeAllocation(IRMemoryMap &map, Status &err) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     // Allocate a spare memory area to store the persistent variable's contents.
 
-    Error allocate_error;
+    Status allocate_error;
     const bool zero_memory = false;
 
     lldb::addr_t mem = map.Malloc(
@@ -112,7 +112,7 @@ public:
 
     if (m_persistent_variable_sp->m_flags &
         ExpressionVariable::EVKeepInTarget) {
-      Error leak_error;
+      Status leak_error;
       map.Leak(mem, leak_error);
       m_persistent_variable_sp->m_flags &=
           ~ExpressionVariable::EVNeedsAllocation;
@@ -120,7 +120,7 @@ public:
 
     // Write the contents of the variable to the area.
 
-    Error write_error;
+    Status write_error;
 
     map.WriteMemory(mem, m_persistent_variable_sp->GetValueBytes(),
                     m_persistent_variable_sp->GetByteSize(), write_error);
@@ -134,8 +134,8 @@ public:
     }
   }
 
-  void DestroyAllocation(IRMemoryMap &map, Error &err) {
-    Error deallocate_error;
+  void DestroyAllocation(IRMemoryMap &map, Status &err) {
+    Status deallocate_error;
 
     map.Free((lldb::addr_t)m_persistent_variable_sp->m_live_sp->GetValue()
                  .GetScalar()
@@ -153,7 +153,7 @@ public:
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                   lldb::addr_t process_address, Error &err) override {
+                   lldb::addr_t process_address, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -181,7 +181,7 @@ public:
          m_persistent_variable_sp->m_live_sp) ||
         m_persistent_variable_sp->m_flags &
             ExpressionVariable::EVIsLLDBAllocated) {
-      Error write_error;
+      Status write_error;
 
       map.WriteScalarToMemory(
           load_addr,
@@ -204,7 +204,7 @@ public:
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
-                     lldb::addr_t frame_bottom, Error &err) override {
+                     lldb::addr_t frame_bottom, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -234,7 +234,7 @@ public:
         // live variable data hasn't been set up yet.  Do this now.
 
         lldb::addr_t location;
-        Error read_error;
+        Status read_error;
 
         map.ReadPointerFromMemory(&location, load_addr, read_error);
 
@@ -304,7 +304,7 @@ public:
 
         m_persistent_variable_sp->ValueUpdated();
 
-        Error read_error;
+        Status read_error;
 
         map.ReadMemory(m_persistent_variable_sp->GetValueBytes(), mem,
                        m_persistent_variable_sp->GetByteSize(), read_error);
@@ -353,7 +353,7 @@ public:
                  Log *log) override {
     StreamString dump_stream;
 
-    Error err;
+    Status err;
 
     const lldb::addr_t load_addr = process_address + m_offset;
 
@@ -416,7 +416,7 @@ private:
 
 uint32_t Materializer::AddPersistentVariable(
     lldb::ExpressionVariableSP &persistent_variable_sp,
-    PersistentVariableDelegate *delegate, Error &err) {
+    PersistentVariableDelegate *delegate, Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   iter->reset(new EntityPersistentVariable(persistent_variable_sp, delegate));
   uint32_t ret = AddStructMember(**iter);
@@ -439,7 +439,7 @@ public:
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                   lldb::addr_t process_address, Error &err) override {
+                   lldb::addr_t process_address, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -464,7 +464,7 @@ public:
       return;
     }
 
-    Error valobj_error = valobj_sp->GetError();
+    Status valobj_error = valobj_sp->GetError();
 
     if (valobj_error.Fail()) {
       err.SetErrorStringWithFormat("couldn't get the value of variable %s: %s",
@@ -475,7 +475,7 @@ public:
 
     if (m_is_reference) {
       DataExtractor valobj_extractor;
-      Error extract_error;
+      Status extract_error;
       valobj_sp->GetData(valobj_extractor, extract_error);
 
       if (!extract_error.Success()) {
@@ -488,7 +488,7 @@ public:
       lldb::offset_t offset = 0;
       lldb::addr_t reference_addr = valobj_extractor.GetAddress(&offset);
 
-      Error write_error;
+      Status write_error;
       map.WritePointerToMemory(load_addr, reference_addr, write_error);
 
       if (!write_error.Success()) {
@@ -504,7 +504,7 @@ public:
       lldb::addr_t addr_of_valobj =
           valobj_sp->GetAddressOf(scalar_is_load_address, &address_type);
       if (addr_of_valobj != LLDB_INVALID_ADDRESS) {
-        Error write_error;
+        Status write_error;
         map.WritePointerToMemory(load_addr, addr_of_valobj, write_error);
 
         if (!write_error.Success()) {
@@ -515,7 +515,7 @@ public:
         }
       } else {
         DataExtractor data;
-        Error extract_error;
+        Status extract_error;
         valobj_sp->GetData(data, extract_error);
         if (!extract_error.Success()) {
           err.SetErrorStringWithFormat("couldn't get the value of %s: %s",
@@ -554,7 +554,7 @@ public:
         if (!byte_align)
           byte_align = 1;
 
-        Error alloc_error;
+        Status alloc_error;
         const bool zero_memory = false;
 
         m_temporary_allocation = map.Malloc(
@@ -574,7 +574,7 @@ public:
           return;
         }
 
-        Error write_error;
+        Status write_error;
 
         map.WriteMemory(m_temporary_allocation, data.GetDataStart(),
                         data.GetByteSize(), write_error);
@@ -586,7 +586,7 @@ public:
           return;
         }
 
-        Error pointer_write_error;
+        Status pointer_write_error;
 
         map.WritePointerToMemory(load_addr, m_temporary_allocation,
                                  pointer_write_error);
@@ -603,7 +603,7 @@ public:
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
-                     lldb::addr_t frame_bottom, Error &err) override {
+                     lldb::addr_t frame_bottom, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -631,7 +631,7 @@ public:
 
       lldb_private::DataExtractor data;
 
-      Error extract_error;
+      Status extract_error;
 
       map.GetMemoryData(data, m_temporary_allocation, valobj_sp->GetByteSize(),
                         extract_error);
@@ -652,7 +652,7 @@ public:
         }
       }
 
-      Error set_error;
+      Status set_error;
 
       if (actually_write) {
         valobj_sp->SetData(data, set_error);
@@ -665,7 +665,7 @@ public:
         }
       }
 
-      Error free_error;
+      Status free_error;
 
       map.Free(m_temporary_allocation, free_error);
 
@@ -689,7 +689,7 @@ public:
     const lldb::addr_t load_addr = process_address + m_offset;
     dump_stream.Printf("0x%" PRIx64 ": EntityVariable\n", load_addr);
 
-    Error err;
+    Status err;
 
     lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 
@@ -746,7 +746,7 @@ public:
 
   void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {
     if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
-      Error free_error;
+      Status free_error;
 
       map.Free(m_temporary_allocation, free_error);
 
@@ -763,7 +763,7 @@ private:
   lldb::DataBufferSP m_original_data;
 };
 
-uint32_t Materializer::AddVariable(lldb::VariableSP &variable_sp, Error &err) {
+uint32_t Materializer::AddVariable(lldb::VariableSP &variable_sp, Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   iter->reset(new EntityVariable(variable_sp));
   uint32_t ret = AddStructMember(**iter);
@@ -787,7 +787,7 @@ public:
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                   lldb::addr_t process_address, Error &err) override {
+                   lldb::addr_t process_address, Status &err) override {
     if (!m_is_program_reference) {
       if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
         err.SetErrorString("Trying to create a temporary region for the result "
@@ -806,7 +806,7 @@ public:
       if (!byte_align)
         byte_align = 1;
 
-      Error alloc_error;
+      Status alloc_error;
       const bool zero_memory = true;
 
       m_temporary_allocation = map.Malloc(
@@ -822,7 +822,7 @@ public:
         return;
       }
 
-      Error pointer_write_error;
+      Status pointer_write_error;
 
       map.WritePointerToMemory(load_addr, m_temporary_allocation,
                                pointer_write_error);
@@ -837,7 +837,7 @@ public:
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
-                     lldb::addr_t frame_bottom, Error &err) override {
+                     lldb::addr_t frame_bottom, Status &err) override {
     err.Clear();
 
     ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
@@ -849,7 +849,7 @@ public:
     }
 
     lldb::addr_t address;
-    Error read_error;
+    Status read_error;
     const lldb::addr_t load_addr = process_address + m_offset;
 
     map.ReadPointerFromMemory(&address, load_addr, read_error);
@@ -867,7 +867,7 @@ public:
       return;
     }
 
-    Error type_system_error;
+    Status type_system_error;
     TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
         &type_system_error, m_type.GetMinimumLanguage());
 
@@ -937,7 +937,7 @@ public:
       ret->m_flags |= ExpressionVariable::EVNeedsAllocation;
 
       if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
-        Error free_error;
+        Status free_error;
         map.Free(m_temporary_allocation, free_error);
       }
     } else {
@@ -956,7 +956,7 @@ public:
 
     dump_stream.Printf("0x%" PRIx64 ": EntityResultVariable\n", load_addr);
 
-    Error err;
+    Status err;
 
     lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 
@@ -1013,7 +1013,7 @@ public:
 
   void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {
     if (!m_keep_in_memory && m_temporary_allocation != LLDB_INVALID_ADDRESS) {
-      Error free_error;
+      Status free_error;
 
       map.Free(m_temporary_allocation, free_error);
     }
@@ -1036,7 +1036,7 @@ uint32_t Materializer::AddResultVariable(const CompilerType &type,
                                          bool is_program_reference,
                                          bool keep_in_memory,
                                          PersistentVariableDelegate *delegate,
-                                         Error &err) {
+                                         Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   iter->reset(new EntityResultVariable(type, is_program_reference,
                                        keep_in_memory, delegate));
@@ -1054,7 +1054,7 @@ public:
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                   lldb::addr_t process_address, Error &err) override {
+                   lldb::addr_t process_address, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -1086,7 +1086,7 @@ public:
     if (resolved_address == LLDB_INVALID_ADDRESS)
       resolved_address = sym_address.GetFileAddress();
 
-    Error pointer_write_error;
+    Status pointer_write_error;
 
     map.WritePointerToMemory(load_addr, resolved_address, pointer_write_error);
 
@@ -1100,7 +1100,7 @@ public:
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
-                     lldb::addr_t frame_bottom, Error &err) override {
+                     lldb::addr_t frame_bottom, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -1118,7 +1118,7 @@ public:
                  Log *log) override {
     StreamString dump_stream;
 
-    Error err;
+    Status err;
 
     const lldb::addr_t load_addr = process_address + m_offset;
 
@@ -1151,7 +1151,7 @@ private:
   Symbol m_symbol;
 };
 
-uint32_t Materializer::AddSymbol(const Symbol &symbol_sp, Error &err) {
+uint32_t Materializer::AddSymbol(const Symbol &symbol_sp, Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   iter->reset(new EntitySymbol(symbol_sp));
   uint32_t ret = AddStructMember(**iter);
@@ -1169,7 +1169,7 @@ public:
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                   lldb::addr_t process_address, Error &err) override {
+                   lldb::addr_t process_address, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -1216,7 +1216,7 @@ public:
     m_register_contents.reset(new DataBufferHeap(register_data.GetDataStart(),
                                                  register_data.GetByteSize()));
 
-    Error write_error;
+    Status write_error;
 
     map.WriteMemory(load_addr, register_data.GetDataStart(),
                     register_data.GetByteSize(), write_error);
@@ -1231,7 +1231,7 @@ public:
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
-                     lldb::addr_t frame_bottom, Error &err) override {
+                     lldb::addr_t frame_bottom, Status &err) override {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     const lldb::addr_t load_addr = process_address + m_offset;
@@ -1242,7 +1242,7 @@ public:
                   (uint64_t)load_addr, m_register_info.name);
     }
 
-    Error extract_error;
+    Status extract_error;
 
     DataExtractor register_data;
 
@@ -1291,7 +1291,7 @@ public:
                  Log *log) override {
     StreamString dump_stream;
 
-    Error err;
+    Status err;
 
     const lldb::addr_t load_addr = process_address + m_offset;
 
@@ -1326,7 +1326,7 @@ private:
 };
 
 uint32_t Materializer::AddRegister(const RegisterInfo &register_info,
-                                   Error &err) {
+                                   Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   iter->reset(new EntityRegister(register_info));
   uint32_t ret = AddStructMember(**iter);
@@ -1346,7 +1346,7 @@ Materializer::~Materializer() {
 
 Materializer::DematerializerSP
 Materializer::Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
-                          lldb::addr_t process_address, Error &error) {
+                          lldb::addr_t process_address, Status &error) {
   ExecutionContextScope *exe_scope = frame_sp.get();
 
   if (!exe_scope)
@@ -1389,7 +1389,7 @@ Materializer::Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
   return ret;
 }
 
-void Materializer::Dematerializer::Dematerialize(Error &error,
+void Materializer::Dematerializer::Dematerialize(Status &error,
                                                  lldb::addr_t frame_bottom,
                                                  lldb::addr_t frame_top) {
   lldb::StackFrameSP frame_sp;
diff --git a/lldb/source/Expression/REPL.cpp b/lldb/source/Expression/REPL.cpp
index e404537562b..84a6405f326 100644
--- a/lldb/source/Expression/REPL.cpp
+++ b/lldb/source/Expression/REPL.cpp
@@ -42,7 +42,7 @@ REPL::REPL(LLVMCastKind kind, Target &target) : m_target(target), m_kind(kind) {
 
 REPL::~REPL() = default;
 
-lldb::REPLSP REPL::Create(Error &err, lldb::LanguageType language,
+lldb::REPLSP REPL::Create(Status &err, lldb::LanguageType language,
                           Debugger *debugger, Target *target,
                           const char *repl_options) {
   uint32_t idx = 0;
@@ -309,7 +309,7 @@ void REPL::IOHandlerInputComplete(IOHandler &io_handler, std::string &code) {
 
       const char *expr_prefix = nullptr;
       lldb::ValueObjectSP result_valobj_sp;
-      Error error;
+      Status error;
       lldb::ModuleSP jit_module_sp;
       lldb::ExpressionResults execution_results =
           UserExpression::Evaluate(exe_ctx, expr_options, code.c_str(),
@@ -518,8 +518,8 @@ bool QuitCommandOverrideCallback(void *baton, const char **argv) {
   return false;
 }
 
-Error REPL::RunLoop() {
-  Error error;
+Status REPL::RunLoop() {
+  Status error;
 
   error = DoInitialization();
   m_repl_source_path = GetSourcePath();
diff --git a/lldb/source/Expression/UserExpression.cpp b/lldb/source/Expression/UserExpression.cpp
index c7cf106e19d..3386bc4577a 100644
--- a/lldb/source/Expression/UserExpression.cpp
+++ b/lldb/source/Expression/UserExpression.cpp
@@ -101,7 +101,7 @@ bool UserExpression::MatchesContext(ExecutionContext &exe_ctx) {
 
 lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
                                               ConstString &object_name,
-                                              Error &err) {
+                                              Status &err) {
   err.Clear();
 
   if (!frame_sp) {
@@ -140,7 +140,7 @@ lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
 lldb::ExpressionResults UserExpression::Evaluate(
     ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options,
     llvm::StringRef expr, llvm::StringRef prefix,
-    lldb::ValueObjectSP &result_valobj_sp, Error &error, uint32_t line_offset,
+    lldb::ValueObjectSP &result_valobj_sp, Status &error, uint32_t line_offset,
     std::string *fixed_expression, lldb::ModuleSP *jit_module_sp_ptr) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
                                                   LIBLLDB_LOG_STEP));
diff --git a/lldb/source/Expression/UtilityFunction.cpp b/lldb/source/Expression/UtilityFunction.cpp
index 6772fd18ac5..52f3bfc4d12 100644
--- a/lldb/source/Expression/UtilityFunction.cpp
+++ b/lldb/source/Expression/UtilityFunction.cpp
@@ -65,7 +65,7 @@ UtilityFunction::~UtilityFunction() {
 
 FunctionCaller *UtilityFunction::MakeFunctionCaller(
     const CompilerType &return_type, const ValueList &arg_value_list,
-    lldb::ThreadSP thread_to_use_sp, Error &error) {
+    lldb::ThreadSP thread_to_use_sp, Status &error) {
   if (m_caller_up)
     return m_caller_up.get();