[NativeProcessLinux] Refactor PtraceWrapper

[labath]

Summary

This changes PtraceWrapper to return an Error, while the actual result is in an pointer parameter
(instead of the other way around). This arrangement makes a lot of the code much simpler.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.h

145

It seems like every argument besides req could use a default. (0 or nullptr).

[labath]

Add default values.

[chaoren]

LGTM.

source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) override;
 
         // ---------------------------------------------------------------------
         // Interface used by NativeRegisterContext-derived classes.
         // ---------------------------------------------------------------------
         Error
         DoOperation(const Operation &op);
 
-        static long
-        PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size, Error& error);
+        static Error
+        PtraceWrapper(int req,
+                      lldb::pid_t pid,
+                      void *addr = nullptr,
+                      void *data = nullptr,
+                      size_t data_size = 0,
+                      long *result = nullptr);
 
     protected:
         // ---------------------------------------------------------------------
         // NativeProcessProtocol protected interface
         // ---------------------------------------------------------------------
         Error
         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
 

source/Plugins/Process/Linux/NativeProcessLinux.cpp

DoReadMemory(
             ProcessPOSIXLog::IncNestLevel();
         if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY))
             log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %d, %p, %p, %zd, _)", __FUNCTION__,
                     pid, word_size, (void*)vm_addr, buf, size);
 
         assert(sizeof(data) >= word_size);
         for (bytes_read = 0; bytes_read < size; bytes_read += remainder)
         {
-            Error error;
-            data = NativeProcessLinux::PtraceWrapper(PTRACE_PEEKDATA, pid, (void*)vm_addr, nullptr, 0, error);
+            Error error = NativeProcessLinux::PtraceWrapper(PTRACE_PEEKDATA, pid, (void*)vm_addr, nullptr, 0, &data);
             if (error.Fail())
             {
                 if (log)
                     ProcessPOSIXLog::DecNestLevel();
                 return error;
             }
 
             remainder = size - bytes_read;
DoWriteMemory(
 
                 if (log && ProcessPOSIXLog::AtTopNestLevel() &&
                         (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_LONG) ||
                                 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_SHORT) &&
                                         size <= POSIX_LOG_MEMORY_SHORT_BYTES)))
                     log->Printf ("NativeProcessLinux::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__,
                             (void*)vm_addr, *(const unsigned long*)src, data);
 
-                if (NativeProcessLinux::PtraceWrapper(PTRACE_POKEDATA, pid, (void*)vm_addr, (void*)data, 0, error))
+                error = NativeProcessLinux::PtraceWrapper(PTRACE_POKEDATA, pid, (void*)vm_addr, (void*)data);
+                if (error.Fail())
                 {
                     if (log)
                         ProcessPOSIXLog::DecNestLevel();
                     return error;
                 }
             }
             else
             {
NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
 
     // Child process.
     if (pid == 0)
     {
         // FIXME consider opening a pipe between parent/child and have this forked child
         // send log info to parent re: launch status, in place of the log lines removed here.
 
         // Start tracing this child that is about to exec.
-        NativeProcessLinux::PtraceWrapper(PTRACE_TRACEME, 0, nullptr, nullptr, 0, error);
+        error = PtraceWrapper(PTRACE_TRACEME, 0);
         if (error.Fail())
             exit(ePtraceFailed);
 
         // terminal has already dupped the tty descriptors to stdin/out/err.
         // This closes original fd from which they were copied (and avoids
         // leaking descriptors to the debugged process.
         terminal.CloseSlaveFileDescriptor();
 
while (Host::FindProcessThreads(pid, tids_to_attach))
              it != tids_to_attach.end();)
         {
             if (it->second == false)
             {
                 lldb::tid_t tid = it->first;
 
                 // Attach to the requested process.
                 // An attach will cause the thread to stop with a SIGSTOP.
-                NativeProcessLinux::PtraceWrapper(PTRACE_ATTACH, tid, nullptr, nullptr, 0, error);
+                error = PtraceWrapper(PTRACE_ATTACH, tid);
                 if (error.Fail())
                 {
                     // No such thread. The thread may have exited.
                     // More error handling may be needed.
                     if (error.GetError() == ESRCH)
                     {
                         it = tids_to_attach.erase(it);
                         continue;
NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid)
     // TODO: if we want to support tracing the inferiors' child, add the
     // appropriate ptrace flags here (PTRACE_O_TRACEFORK, PTRACE_O_TRACEVFORK)
     ptrace_opts |= PTRACE_O_TRACECLONE;
 
     // Have the tracer notify us before execve returns
     // (needed to disable legacy SIGTRAP generation)
     ptrace_opts |= PTRACE_O_TRACEEXEC;
 
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void*)ptrace_opts, 0, error);
-    return error;
+    return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void*)ptrace_opts);
 }
 
 static ExitType convert_pid_status_to_exit_type (int status)
 {
     if (WIFEXITED (status))
         return ExitType::eExitTypeExit;
     else if (WIFSIGNALED (status))
         return ExitType::eExitTypeSignal;
NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo)
 
 
 
     intptr_t data = 0;
 
     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
         data = signo;
 
-    Error error = DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_CONT, tid, nullptr, (void*)data, 0, error);
-        return error;
-    });
+    Error error = DoOperation([&] { return PtraceWrapper(PTRACE_CONT, tid, nullptr, (void*)data); });
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " result = %s", __FUNCTION__, tid, error.Success() ? "true" : "false");
     return error;
 }
 
 Error
 NativeProcessLinux::SingleStep(lldb::tid_t tid, uint32_t signo)
 {
     intptr_t data = 0;
 
     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
         data = signo;
 
-    return DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_SINGLESTEP, tid, nullptr, (void*)data, 0, error);
-        return error;
-    });
+    return DoOperation([&] { return PtraceWrapper(PTRACE_SINGLESTEP, tid, nullptr, (void*)data); });
 }
 
 Error
 NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo)
 {
-    return DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo, 0, error);
-        return error;
-    });
+    return DoOperation([&] { return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo); });
 }
 
 Error
 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message)
 {
-    return DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message, 0, error);
-        return error;
-    });
+    return DoOperation([&] { return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message); });
 }
 
 Error
 NativeProcessLinux::Detach(lldb::tid_t tid)
 {
     if (tid == LLDB_INVALID_THREAD_ID)
         return Error();
 
-    return DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_DETACH, tid, nullptr, 0, 0, error);
-        return error;
-    });
+    return DoOperation([&] { return PtraceWrapper(PTRACE_DETACH, tid); });
 }
 
 bool
 NativeProcessLinux::DupDescriptor(const FileSpec &file_spec, int fd, int flags)
 {
     int target_fd = open(file_spec.GetCString(), flags, 0666);
 
     if (target_fd == -1)

 Error
 NativeProcessLinux::DoOperation(const Operation &op)
 {
     return m_monitor_up->DoOperation(op);
 }
 
 // Wrapper for ptrace to catch errors and log calls.
 // Note that ptrace sets errno on error because -1 can be a valid result (i.e. for PTRACE_PEEK*)
-long
-NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size, Error& error)
+Error
+NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size, long *result)
 {
-    long int result;
+    Error error;
+    long int ret;
 
     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PTRACE));
 
     PtraceDisplayBytes(req, data, data_size);
 
-    error.Clear();
     errno = 0;
     if (req == PTRACE_GETREGSET || req == PTRACE_SETREGSET)
-        result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), *(unsigned int *)addr, data);
+        ret = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), *(unsigned int *)addr, data);
     else
-        result = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), addr, data);
+        ret = ptrace(static_cast<__ptrace_request>(req), static_cast< ::pid_t>(pid), addr, data);
 
-    if (result == -1)
+    if (ret == -1)
         error.SetErrorToErrno();
 
+    if (result)
+        *result = ret;
+
     if (log)
-        log->Printf("ptrace(%d, %" PRIu64 ", %p, %p, %zu)=%lX", req, pid, addr, data, data_size, result);
+        log->Printf("ptrace(%d, %" PRIu64 ", %p, %p, %zu)=%lX", req, pid, addr, data, data_size, ret);
 
     PtraceDisplayBytes(req, data, data_size);
 
     if (log && error.GetError() != 0)
     {
         const char* str;
         switch (error.GetError())
         {
         case ESRCH:  str = "ESRCH"; break;
         case EINVAL: str = "EINVAL"; break;
         case EBUSY:  str = "EBUSY"; break;
         case EPERM:  str = "EPERM"; break;
         default:     str = error.AsCString();
         }
         log->Printf("ptrace() failed; errno=%d (%s)", error.GetError(), str);
     }
 
-    return result;
+    return error;
 }

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 NativeRegisterContextLinux::ReadRegisterSet(void *buf, size_t buf_size, unsigned int regset)
 {
     NativeProcessProtocolSP process_sp (m_thread.GetProcess());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
 
     return process_p->DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(),
-                static_cast<void *>(&regset), buf, buf_size, error);
-        return error;
+        return NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(),
+                static_cast<void *>(&regset), buf, buf_size);
     });
 }
 
 Error
 NativeRegisterContextLinux::WriteRegisterSet(void *buf, size_t buf_size, unsigned int regset)
 {
     NativeProcessProtocolSP process_sp (m_thread.GetProcess());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
 
     return process_p->DoOperation([&] {
-        Error error;
-        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(),
-                static_cast<void *>(&regset), buf, buf_size, error);
-        return error;
+        return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(),
+                static_cast<void *>(&regset), buf, buf_size);
     });
 }
 
 Error
 NativeRegisterContextLinux::DoReadRegisterValue(uint32_t offset,
                                                 const char* reg_name,
                                                 uint32_t size,
                                                 RegisterValue &value)
 {
     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
-    Error error;
 
-    lldb::addr_t data = NativeProcessLinux::PtraceWrapper(
-            PTRACE_PEEKUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), nullptr, 0, error);
+    long data;
+    Error error = NativeProcessLinux::PtraceWrapper(
+            PTRACE_PEEKUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), nullptr, 0, &data);
 
     if (error.Success())
-        value = data;
+        value = static_cast<lldb::addr_t>(data);
 
     if (log)
         log->Printf ("NativeRegisterContextLinux::%s() reg %s: 0x%" PRIx64, __FUNCTION__, reg_name, data);
 
     return error;
 }
 
 Error
 NativeRegisterContextLinux::DoWriteRegisterValue(uint32_t offset,
                                                  const char* reg_name,
                                                  const RegisterValue &value)
 {
     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
 
     void* buf = reinterpret_cast<void *>(value.GetAsUInt64());
 
     if (log)
         log->Printf ("NativeRegisterContextLinux::%s() reg %s: %p", __FUNCTION__, reg_name, buf);
 
-    Error error;
-    NativeProcessLinux::PtraceWrapper(
-            PTRACE_POKEUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), buf, 0, error);
-
-    return error;
+    return NativeProcessLinux::PtraceWrapper(
+            PTRACE_POKEUSER, m_thread.GetID(), reinterpret_cast<void *>(offset), buf);
 }
 
 Error
 NativeRegisterContextLinux::DoReadGPR(void *buf, size_t buf_size)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), nullptr, buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::DoWriteGPR(void *buf, size_t buf_size)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), nullptr, buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::DoReadFPR(void *buf, size_t buf_size)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_thread.GetID(), nullptr, buf, buf_size);
 }
 
 Error
 NativeRegisterContextLinux::DoWriteFPR(void *buf, size_t buf_size)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_thread.GetID(), nullptr, buf, buf_size);
 }

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

NativeRegisterContextLinux_arm64::ReadHardwareDebugInfo(unsigned int &watch_count,
     return process_p->DoOperation([&] {
         int regset = NT_ARM_HW_WATCH;
         struct iovec ioVec;
         struct user_hwdebug_state dreg_state;
         Error error;
 
         ioVec.iov_base = &dreg_state;
         ioVec.iov_len = sizeof (dreg_state);
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len, error);
+        error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len);
         watch_count = dreg_state.dbg_info & 0xff;
 
         regset = NT_ARM_HW_BREAK;
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len, error);
+        error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len);
         break_count = dreg_state.dbg_info & 0xff;
 
         return error;
     });
 }
 
 Error
 NativeRegisterContextLinux_arm64::WriteHardwareDebugRegs(lldb::addr_t *addr_buf,
return process_p->DoOperation([&] {
             type = NT_ARM_HW_BREAK;
 
         for (int i = 0; i < count; i++)
         {
             dreg_state.dbg_regs[i].addr = addr_buf[i];
             dreg_state.dbg_regs[i].ctrl = cntrl_buf[i];
         }
 
-        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &type, &ioVec, ioVec.iov_len, error);
-        return error;
+        return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &type, &ioVec, ioVec.iov_len);
     });
 }
 
 Error
 NativeRegisterContextLinux_arm64::DoReadRegisterValue(uint32_t offset,
                                                       const char* reg_name,
                                                       uint32_t size,
                                                       RegisterValue &value)
 {
     Error error;
     if (offset > sizeof(struct user_pt_regs))
     {
         uintptr_t offset = offset - sizeof(struct user_pt_regs);
         if (offset > sizeof(struct user_fpsimd_state))
         {
             error.SetErrorString("invalid offset value");
             return error;
         }
         elf_fpregset_t regs;
         int regset = NT_FPREGSET;
         struct iovec ioVec;
 
         ioVec.iov_base = &regs;
         ioVec.iov_len = sizeof regs;
-        NativeProcessLinux::PtraceWrapper(
-                PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, sizeof regs, error);
+        error = NativeProcessLinux::PtraceWrapper(
+                PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, sizeof regs);
         if (error.Success())
         {
             ArchSpec arch;
             if (m_thread.GetProcess()->GetArchitecture(arch))
                 value.SetBytes((void *)(((unsigned char *)(&regs)) + offset), 16, arch.GetByteOrder());
             else
                 error.SetErrorString("failed to get architecture");
         }
     }
     else
     {
         elf_gregset_t regs;
         int regset = NT_PRSTATUS;
         struct iovec ioVec;
 
         ioVec.iov_base = &regs;
         ioVec.iov_len = sizeof regs;
-        NativeProcessLinux::PtraceWrapper(
-                PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, sizeof regs, error);
+        error = NativeProcessLinux::PtraceWrapper(
+                PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, sizeof regs);
         if (error.Success())
         {
             ArchSpec arch;
             if (m_thread.GetProcess()->GetArchitecture(arch))
                 value.SetBytes((void *)(((unsigned char *)(regs)) + offset), 8, arch.GetByteOrder());
             else
                 error.SetErrorString("failed to get architecture");
         }
if (offset > sizeof(struct user_pt_regs))
             return error;
         }
         elf_fpregset_t regs;
         int regset = NT_FPREGSET;
         struct iovec ioVec;
 
         ioVec.iov_base = &regs;
         ioVec.iov_len = sizeof regs;
-        NativeProcessLinux::PtraceWrapper( PTRACE_GETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+        error = NativeProcessLinux::PtraceWrapper( PTRACE_GETREGSET, tid, &regset, &ioVec, sizeof regs);
 
         if (error.Success())
         {
             ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 16);
-            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+            error = NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs);
         }
     }
     else
     {
         elf_gregset_t regs;
         int regset = NT_PRSTATUS;
         struct iovec ioVec;
 
         ioVec.iov_base = &regs;
         ioVec.iov_len = sizeof regs;
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+        error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, sizeof regs);
         if (error.Success())
         {
             ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 8);
-            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+            error = NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs);
         }
     }
     return error;
 }
 
 Error
 NativeRegisterContextLinux_arm64::DoReadGPR(void *buf, size_t buf_size)
 {
     int regset = NT_PRSTATUS;
     struct iovec ioVec;
     Error error;
 
     ioVec.iov_base = buf;
     ioVec.iov_len = buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size);
 }
 
 Error
 NativeRegisterContextLinux_arm64::DoWriteGPR(void *buf, size_t buf_size)
 {
     int regset = NT_PRSTATUS;
     struct iovec ioVec;
     Error error;
 
     ioVec.iov_base = buf;
     ioVec.iov_len = buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size);
 }
 
 Error
 NativeRegisterContextLinux_arm64::DoReadFPR(void *buf, size_t buf_size)
 {
     int regset = NT_FPREGSET;
     struct iovec ioVec;
     Error error;
 
     ioVec.iov_base = buf;
     ioVec.iov_len = buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size);
 }
 
 Error
 NativeRegisterContextLinux_arm64::DoWriteFPR(void *buf, size_t buf_size)
 {
     int regset = NT_FPREGSET;
     struct iovec ioVec;
     Error error;
 
     ioVec.iov_base = buf;
     ioVec.iov_len = buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(), &regset, &ioVec, buf_size);
 }
 
 #endif // defined (__arm64__) || defined (__aarch64__)

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

NativeRegisterContextLinux_mips64::NumSupportedHardwareWatchpoints ()
     return num_valid;
 }
 Error
 NativeRegisterContextLinux_mips64::DoReadRegisterValue(uint32_t offset,
                                                        const char* reg_name,
                                                        uint32_t size,
                                                        RegisterValue &value)
 {
-    Error error;
     elf_gregset_t regs;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+    Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs);
     if (error.Success())
     {
         lldb_private::ArchSpec arch;
         if (m_thread.GetProcess()->GetArchitecture(arch))
             value.SetBytes((void *)(((unsigned char *)(regs)) + offset), 8, arch.GetByteOrder());
         else
             error.SetErrorString("failed to get architecture");
     }
     return error;
 }
 
 Error
 NativeRegisterContextLinux_mips64::DoWriteRegisterValue(uint32_t offset,
                                                         const char* reg_name,
                                                         const RegisterValue &value)
 {
-    Error error;
     elf_gregset_t regs;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+    Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs);
     if (error.Success())
     {
         ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 8);
-        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+        error = NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), NULL, &regs, sizeof regs);
     }
     return error;
 }
 
 Error
 NativeRegisterContextLinux_mips64::DoReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(
-            PTRACE_GET_WATCH_REGS, m_thread.GetID(), watch_readback, NULL, 0, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper( PTRACE_GET_WATCH_REGS, m_thread.GetID(), watch_readback);
 }
 
 Error
 NativeRegisterContextLinux_mips64::DoWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_reg_value)
 {
-    Error error;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SET_WATCH_REGS,
-            m_thread.GetID(), watch_reg_value, NULL, 0, error);
-    return error;
+    return NativeProcessLinux::PtraceWrapper(PTRACE_SET_WATCH_REGS, m_thread.GetID(), watch_reg_value);
 }
 
 #endif // defined (__mips__)