[NativeProcessLinux] Use lambdas in DoOperation calls

[labath]

Summary

This removes a lot of boilerplate, which was needed to execute monitor operations. Previously one
needed do declare a separate class for each operation which would manually capture all needed
arguments, which was very verbose. In addition to less code, I believe this also makes the code
more readable, since now the implementation of the operation can be physically closer to the code
that invokes it.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3171

Why not make this void * to begin with?

3178

Does it make sense to have PtraceWrapper return Error? To be consistent with some changes you made above.

3190

void *?

3728

Nit: extra space.

source/Plugins/Process/Linux/NativeProcessLinux.h

142

Nit: extra space.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3171

Whoops, didn't see the assignment right below. Please ignore this.

[labath]

• Remove extra spaces

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3171

This could be made simpler, but I did not want to do it here, as it is just copy-pasted.

3178

I've thought about that as well and I think it is a good idea. I propose to do it in a followup patch. I'll need to check if putting the current return value in a by-ref parameter will not make other things more awkward.

3728

Done.

source/Plugins/Process/Linux/NativeProcessLinux.h

142

On which side? :)
I'll remove the right one, as that seems to be most consistent with other uses.

[tberghammer]

Looks good, but please check it compiles on all supported architecture (x86_64, arm, aarch64, mips/mips64) because some of the code only used on one of these.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

253

(nit) You don't need this. ("return Error();")

259

(nit): You can do a "return Error();" here

713

(nit): I think "m_operation->operator()();" is cleaner but it is up to you

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

259

I don't think so. PtraceWrapper sets the error variable, and I need to test it. right?

713

I don't find either of the options particularly appealing, but I prefer this one a bit.

[tberghammer]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

259

Sorry, I missed that call

[chaoren]

LGTM.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3178

I think it might be better to pass a pointer instead, for consistency with the other arguments, and makes it optional.

source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         //------------------------------------------------------------------------------
         /// @class Operation
         /// @brief Represents a NativeProcessLinux operation.
         ///
         /// Under Linux, it is not possible to ptrace() from any other thread but the
         /// one that spawned or attached to the process from the start.  Therefore, when
         /// a NativeProcessLinux is asked to deliver or change the state of an inferior
         /// process the operation must be "funneled" to a specific thread to perform the
-        /// task.  The Operation class provides an abstract base for all services the
-        /// NativeProcessLinux must perform via the single virtual function Execute, thus
-        /// encapsulating the code that needs to run in the privileged context.
-        class Operation
-        {
-        public:
-            Operation () : m_error() { }
-
-            virtual
-            ~Operation() {}
-
-            virtual void
-            Execute (NativeProcessLinux *process) = 0;
-
-            const Error &
-            GetError () const { return m_error; }
-
-        protected:
-            Error m_error;
-        };
-
-        typedef std::unique_ptr<Operation> OperationUP;
+        /// task.
+        typedef std::function<Error()> Operation;
 
         // ---------------------------------------------------------------------
         // NativeProcessProtocol Interface
         // ---------------------------------------------------------------------
         Error
         Resume (const ResumeActionList &resume_actions) override;
 
         Error
public:
 
         Error
         GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) override;
 
         // ---------------------------------------------------------------------
         // Interface used by NativeRegisterContext-derived classes.
         // ---------------------------------------------------------------------
         Error
-        DoOperation(Operation* op);
-
-        Error
-        DoOperation(OperationUP op) { return DoOperation(op.get()); }
+        DoOperation(const Operation & op);
 
         static long
         PtraceWrapper(int req, lldb::pid_t pid, void *addr, void *data, size_t data_size, Error& error);
 
     protected:
         // ---------------------------------------------------------------------
         // NativeProcessProtocol protected interface
         // ---------------------------------------------------------------------

source/Plugins/Process/Linux/NativeProcessLinux.cpp

PtraceDisplayBytes(int &req, void *data, size_t data_size)
         }
     }
 
     //------------------------------------------------------------------------------
     // Static implementations of NativeProcessLinux::ReadMemory and
     // NativeProcessLinux::WriteMemory.  This enables mutual recursion between these
     // functions without needed to go thru the thread funnel.
 
-    size_t
+    Error
     DoReadMemory(
         lldb::pid_t pid,
         lldb::addr_t vm_addr,
         void *buf,
         size_t size,
-        Error &error)
+        size_t &bytes_read)
     {
         // ptrace word size is determined by the host, not the child
         static const unsigned word_size = sizeof(void*);
         unsigned char *dst = static_cast<unsigned char*>(buf);
-        size_t bytes_read;
         size_t remainder;
         long data;
 
         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL));
         if (log)
             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);
             if (error.Fail())
             {
                 if (log)
                     ProcessPOSIXLog::DecNestLevel();
-                return bytes_read;
+                return error;
             }
 
             remainder = size - bytes_read;
             remainder = remainder > word_size ? word_size : remainder;
 
             // Copy the data into our buffer
             for (unsigned i = 0; i < remainder; ++i)
                 dst[i] = ((data >> i*8) & 0xFF);
DoReadMemory(
                         (void*)vm_addr, print_dst, (unsigned long)data);
             }
             vm_addr += word_size;
             dst += word_size;
         }
 
         if (log)
             ProcessPOSIXLog::DecNestLevel();
-        return bytes_read;
+        return Error();
     }
 
-    size_t
+    Error
     DoWriteMemory(
         lldb::pid_t pid,
         lldb::addr_t vm_addr,
         const void *buf,
         size_t size,
-        Error &error)
+        size_t &bytes_written)
     {
         // ptrace word size is determined by the host, not the child
         static const unsigned word_size = sizeof(void*);
         const unsigned char *src = static_cast<const unsigned char*>(buf);
-        size_t bytes_written = 0;
         size_t remainder;
+        Error error;
 
         Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_ALL));
         if (log)
             ProcessPOSIXLog::IncNestLevel();
         if (log && ProcessPOSIXLog::AtTopNestLevel() && log->GetMask().Test(POSIX_LOG_MEMORY))
             log->Printf ("NativeProcessLinux::%s(%" PRIu64 ", %u, %p, %p, %" PRIu64 ")", __FUNCTION__,
                     pid, word_size, (void*)vm_addr, buf, size);
 
DoWriteMemory(
                                         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))
                 {
                     if (log)
                         ProcessPOSIXLog::DecNestLevel();
-                    return bytes_written;
+                    return error;
                 }
             }
             else
             {
                 unsigned char buff[8];
-                if (DoReadMemory(pid, vm_addr,
-                                buff, word_size, error) != word_size)
+                size_t bytes_read;
+                error = DoReadMemory(pid, vm_addr, buff, word_size, bytes_read);
+                if (error.Fail())
                 {
                     if (log)
                         ProcessPOSIXLog::DecNestLevel();
-                    return bytes_written;
+                    return error;
                 }
 
                 memcpy(buff, src, remainder);
 
-                if (DoWriteMemory(pid, vm_addr,
-                                buff, word_size, error) != word_size)
+                size_t bytes_written_rec;
+                error = DoWriteMemory(pid, vm_addr, buff, word_size, bytes_written_rec);
+                if (error.Fail())
                 {
                     if (log)
                         ProcessPOSIXLog::DecNestLevel();
-                    return bytes_written;
+                    return error;
                 }
 
                 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, *(unsigned long*)buff);
             }
 
             vm_addr += word_size;
             src += word_size;
         }
         if (log)
             ProcessPOSIXLog::DecNestLevel();
-        return bytes_written;
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class ReadOperation
-    /// @brief Implements NativeProcessLinux::ReadMemory.
-    class ReadOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        ReadOperation(
-            lldb::addr_t addr,
-            void *buff,
-            size_t size,
-            size_t &result) :
-            Operation (),
-            m_addr (addr),
-            m_buff (buff),
-            m_size (size),
-            m_result (result)
-            {
-            }
-
-        void Execute (NativeProcessLinux *process) override;
-
-    private:
-        lldb::addr_t m_addr;
-        void *m_buff;
-        size_t m_size;
-        size_t &m_result;
-    };
-
-    void
-    ReadOperation::Execute (NativeProcessLinux *process)
-    {
-        m_result = DoReadMemory (process->GetID (), m_addr, m_buff, m_size, m_error);
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class WriteOperation
-    /// @brief Implements NativeProcessLinux::WriteMemory.
-    class WriteOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        WriteOperation(
-            lldb::addr_t addr,
-            const void *buff,
-            size_t size,
-            size_t &result) :
-            Operation (),
-            m_addr (addr),
-            m_buff (buff),
-            m_size (size),
-            m_result (result)
-            {
-            }
-
-        void Execute (NativeProcessLinux *process) override;
-
-    private:
-        lldb::addr_t m_addr;
-        const void *m_buff;
-        size_t m_size;
-        size_t &m_result;
-    };
-
-    void
-    WriteOperation::Execute(NativeProcessLinux *process)
-    {
-        m_result = DoWriteMemory (process->GetID (), m_addr, m_buff, m_size, m_error);
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class ResumeOperation
-    /// @brief Implements NativeProcessLinux::Resume.
-    class ResumeOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        ResumeOperation(lldb::tid_t tid, uint32_t signo) :
-            m_tid(tid), m_signo(signo) { }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        uint32_t m_signo;
-    };
-
-    void
-    ResumeOperation::Execute(NativeProcessLinux *monitor)
-    {
-        intptr_t data = 0;
-
-        if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
-            data = m_signo;
-
-        NativeProcessLinux::PtraceWrapper(PTRACE_CONT, m_tid, nullptr, (void*)data, 0, m_error);
-        if (m_error.Fail())
-        {
-            Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-
-            if (log)
-                log->Printf ("ResumeOperation (%"  PRIu64 ") failed: %s", m_tid, m_error.AsCString());
-        }
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class SingleStepOperation
-    /// @brief Implements NativeProcessLinux::SingleStep.
-    class SingleStepOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        SingleStepOperation(lldb::tid_t tid, uint32_t signo)
-            : m_tid(tid), m_signo(signo) { }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        uint32_t m_signo;
-    };
-
-    void
-    SingleStepOperation::Execute(NativeProcessLinux *monitor)
-    {
-        intptr_t data = 0;
-
-        if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
-            data = m_signo;
-
-        NativeProcessLinux::PtraceWrapper(PTRACE_SINGLESTEP, m_tid, nullptr, (void*)data, 0, m_error);
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class SiginfoOperation
-    /// @brief Implements NativeProcessLinux::GetSignalInfo.
-    class SiginfoOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        SiginfoOperation(lldb::tid_t tid, void *info)
-            : m_tid(tid), m_info(info) { }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        void *m_info;
-    };
-
-    void
-    SiginfoOperation::Execute(NativeProcessLinux *monitor)
-    {
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETSIGINFO, m_tid, nullptr, m_info, 0, m_error);
-    }
-
-    //------------------------------------------------------------------------------
-    /// @class EventMessageOperation
-    /// @brief Implements NativeProcessLinux::GetEventMessage.
-    class EventMessageOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        EventMessageOperation(lldb::tid_t tid, unsigned long *message)
-            : m_tid(tid), m_message(message) { }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        unsigned long *m_message;
-    };
-
-    void
-    EventMessageOperation::Execute(NativeProcessLinux *monitor)
-    {
-        NativeProcessLinux::PtraceWrapper(PTRACE_GETEVENTMSG, m_tid, nullptr, m_message, 0, m_error);
-    }
-
-    class DetachOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        DetachOperation(lldb::tid_t tid) : m_tid(tid) { }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-    };
-
-    void
-    DetachOperation::Execute(NativeProcessLinux *monitor)
-    {
-        NativeProcessLinux::PtraceWrapper(PTRACE_DETACH, m_tid, nullptr, 0, 0, m_error);
+        return error;
     }
 } // end of anonymous namespace
 
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
 static Error
 EnsureFDFlags(int fd, int flags)
 {
private:
     NativeProcessLinux              * m_native_process;
 
     enum { READ, WRITE };
     int        m_pipefd[2] = {-1, -1};
     int        m_signal_fd = -1;
     HostThread m_thread;
 
     // current operation which must be executed on the priviliged thread
-    Mutex      m_operation_mutex;
-    Operation *m_operation = nullptr;
-    sem_t      m_operation_sem;
-    Error      m_operation_error;
+    Mutex            m_operation_mutex;
+    const Operation *m_operation = nullptr;
+    sem_t            m_operation_sem;
+    Error            m_operation_error;
 
     unsigned   m_operation_nesting_level = 0;
 
     static constexpr char operation_command   = 'o';
     static constexpr char begin_block_command = '{';
     static constexpr char end_block_command   = '}';
 
     void
public:
     ~Monitor();
 
     Error
     Initialize();
 
     void
     Terminate();
 
-    void
-    DoOperation(Operation *op);
+    Error
+    DoOperation(const Operation &op);
 
     class ScopedOperationLock {
         Monitor &m_monitor;
 
     public:
         ScopedOperationLock(Monitor &monitor)
             : m_monitor(monitor)
         { m_monitor.BeginOperationBlock(); }
NativeProcessLinux::Monitor::Initialize()
     m_thread = ThreadLauncher::LaunchThread(g_thread_name, Monitor::RunMonitor, this, nullptr);
     if (!m_thread.IsJoinable())
         return Error("Failed to create monitor thread for NativeProcessLinux.");
 
     // Wait for initial operation to complete.
     return WaitForAck();
 }
 
-void
-NativeProcessLinux::Monitor::DoOperation(Operation *op)
+Error
+NativeProcessLinux::Monitor::DoOperation(const Operation &op)
 {
     if (m_thread.EqualsThread(pthread_self())) {
         // If we're on the Monitor thread, we can simply execute the operation.
-        op->Execute(m_native_process);
-        return;
+        return op();
     }
 
     // Otherwise we need to pass the operation to the Monitor thread so it can handle it.
     Mutex::Locker lock(m_operation_mutex);
 
-    m_operation = op;
+    m_operation = &op;
 
     // notify the thread that an operation is ready to be processed
     write(m_pipefd[WRITE], &operation_command, sizeof operation_command);
 
-    WaitForAck();
+    return WaitForAck();
 }
 
 void
 NativeProcessLinux::Monitor::Terminate()
 {
     if (m_pipefd[WRITE] >= 0)
     {
         close(m_pipefd[WRITE]);
while (true)
                 log->Printf("NativeProcessLinux::Monitor::%s exit command received, exiting...", __FUNCTION__);
             assert(m_operation_nesting_level == 0 && "Unbalanced begin/end block commands detected");
             return true; // We are done.
         }
 
         switch (command)
         {
         case operation_command:
-            m_operation->Execute(m_native_process);
+            m_operation_error = (*m_operation)();
             break;
         case begin_block_command:
             ++m_operation_nesting_level;
             break;
         case end_block_command:
             assert(m_operation_nesting_level > 0);
             --m_operation_nesting_level;
             break;
if (ProcessVmReadvSupported()) {
                     __FUNCTION__, size, addr, success ? "Success" : strerror(errno));
 
         if (success)
             return Error();
         // else
         //     the call failed for some reason, let's retry the read using ptrace api.
     }
 
-    ReadOperation op(addr, buf, size, bytes_read);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError ();
+    return DoOperation([&] { return DoReadMemory(GetID(), addr, buf, size, bytes_read); });
 }
 
 Error
 NativeProcessLinux::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
 {
     Error error = ReadMemory(addr, buf, size, bytes_read);
     if (error.Fail()) return error;
     return m_breakpoint_list.RemoveTrapsFromBuffer(addr, buf, size);
 }
 
 Error
 NativeProcessLinux::WriteMemory(lldb::addr_t addr, const void *buf, size_t size, size_t &bytes_written)
 {
-    WriteOperation op(addr, buf, size, bytes_written);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError ();
+    return DoOperation([&] { return DoWriteMemory(GetID(), addr, buf, size, bytes_written); });
 }
 
 Error
 NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " with signal %s", __FUNCTION__, tid,
                                  GetUnixSignals().GetSignalAsCString (signo));
-    ResumeOperation op (tid, signo);
-    m_monitor_up->DoOperation (&op);
+
+
+
+    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;
+    });
+
     if (log)
-        log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " result = %s", __FUNCTION__, tid, op.GetError().Success() ? "true" : "false");
-    return op.GetError();
+        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)
 {
-    SingleStepOperation op(tid, signo);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError();
+    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;
+    });
 }
 
 Error
 NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo)
 {
-    SiginfoOperation op(tid, siginfo);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError();
+    return DoOperation([&] {
+        Error error;
+        NativeProcessLinux::PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo, 0, error);
+        return error;
+    });
 }
 
 Error
 NativeProcessLinux::GetEventMessage(lldb::tid_t tid, unsigned long *message)
 {
-    EventMessageOperation op(tid, message);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError();
+    return DoOperation([&] {
+        Error error;
+        NativeProcessLinux::PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message, 0, error);
+        return error;
+    });
 }
 
 Error
 NativeProcessLinux::Detach(lldb::tid_t tid)
 {
     if (tid == LLDB_INVALID_THREAD_ID)
         return Error();
 
-    DetachOperation op(tid);
-    m_monitor_up->DoOperation(&op);
-    return op.GetError();
+    return DoOperation([&] {
+        Error error;
+        NativeProcessLinux::PtraceWrapper(PTRACE_DETACH, tid, nullptr, 0, 0, error);
+        return error;
+    });
 }
 
 bool
 NativeProcessLinux::DupDescriptor(const FileSpec &file_spec, int fd, int flags)
 {
     int target_fd = open(file_spec.GetCString(), flags, 0666);
 
     if (target_fd == -1)
if (m_pending_notification_up && StateIsRunningState(thread_sp->GetState()))
         // We will need to wait for this new thread to stop as well before firing the
         // notification.
         m_pending_notification_up->wait_for_stop_tids.insert(tid);
         thread_sp->RequestStop();
     }
 }
 
 Error
-NativeProcessLinux::DoOperation(Operation* op)
+NativeProcessLinux::DoOperation(const Operation & op)
 {
-    m_monitor_up->DoOperation(op);
-    return op->GetError();
+    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)
 {
     long int result;

source/Plugins/Process/Linux/NativeRegisterContextLinux.h

protected:
     GetGPRSize() { return GetRegisterInfoInterface().GetGPRSize(); }
 
     virtual void*
     GetFPRBuffer() { return nullptr; }
 
     virtual size_t
     GetFPRSize() { return 0; }
 
-    virtual NativeProcessLinux::OperationUP
-    GetReadRegisterValueOperation(uint32_t offset,
-                                  const char* reg_name,
-                                  uint32_t size,
-                                  RegisterValue &value);
+
+    // The Do*** functions are executed on the privileged thread and can perform ptrace
+    // operations directly.
+    virtual Error
+    DoReadRegisterValue(uint32_t offset,
 
-    virtual NativeProcessLinux::OperationUP
-    GetWriteRegisterValueOperation(uint32_t offset,
-                                   const char* reg_name,
-                                   const RegisterValue &value);
+    virtual Error
+    DoWriteRegisterValue(uint32_t offset,
 
-    virtual NativeProcessLinux::OperationUP
-    GetReadGPROperation(void *buf, size_t buf_size);
+    virtual Error
+    DoReadGPR(void *buf, size_t buf_size);
 
-    virtual NativeProcessLinux::OperationUP
-    GetWriteGPROperation(void *buf, size_t buf_size);
+    virtual Error
+    DoWriteGPR(void *buf, size_t buf_size);
 
-    virtual NativeProcessLinux::OperationUP
-    GetReadFPROperation(void *buf, size_t buf_size);
+    virtual Error
+    DoReadFPR(void *buf, size_t buf_size);
 
-    virtual NativeProcessLinux::OperationUP
-    GetWriteFPROperation(void *buf, size_t buf_size);
+    virtual Error
+    DoWriteFPR(void *buf, size_t buf_size);
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_h
 

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Host/linux/Ptrace.h"
 
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
-namespace
-{
-
-class ReadRegOperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadRegOperation(lldb::tid_t tid, uint32_t offset, const char *reg_name, RegisterValue &value) :
-      m_tid(tid),
-        m_offset(static_cast<uintptr_t>(offset)),
-        m_reg_name(reg_name),
-        m_value(value)
-    { }
-
-    void
-    Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    uintptr_t m_offset;
-    const char *m_reg_name;
-    RegisterValue &m_value;
-};
-
-class WriteRegOperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteRegOperation(lldb::tid_t tid, unsigned offset, const char *reg_name, const RegisterValue &value) :
-      m_tid(tid),
-        m_offset(offset),
-        m_reg_name(reg_name),
-        m_value(value)
-    { }
-
-    void
-    Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    uintptr_t m_offset;
-    const char *m_reg_name;
-    const RegisterValue &m_value;
-};
-
-class ReadGPROperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadGPROperation(lldb::tid_t tid, void *buf, size_t buf_size) :
-      m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class WriteGPROperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteGPROperation(lldb::tid_t tid, void *buf, size_t buf_size) :
-      m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class ReadFPROperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadFPROperation(lldb::tid_t tid, void *buf, size_t buf_size) :
-        m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class WriteFPROperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteFPROperation(lldb::tid_t tid, void *buf, size_t buf_size) :
-        m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class ReadRegisterSetOperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadRegisterSetOperation(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) :
-        m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_regset(regset)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-    const unsigned int m_regset;
-};
-
-class WriteRegisterSetOperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteRegisterSetOperation(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset) :
-        m_tid(tid), m_buf(buf), m_buf_size(buf_size), m_regset(regset)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-    const unsigned int m_regset;
-};
-
-} // end of anonymous namespace
-
-void
-ReadRegOperation::Execute(NativeProcessLinux *monitor)
-{
-  Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
-
-    lldb::addr_t data = static_cast<unsigned long>(NativeProcessLinux::PtraceWrapper(PTRACE_PEEKUSER, m_tid, (void*)m_offset, nullptr, 0, m_error));
-    if (m_error.Success())
-        m_value = data;
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s() reg %s: 0x%" PRIx64, __FUNCTION__, m_reg_name, data);
-}
-
-void
-WriteRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_REGISTERS));
-
-    void* buf = (void*)m_value.GetAsUInt64();
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s() reg %s: %p", __FUNCTION__, m_reg_name, buf);
-    NativeProcessLinux::PtraceWrapper(PTRACE_POKEUSER, m_tid, (void*)m_offset, buf, 0, m_error);
-}
-
-void
-ReadGPROperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_tid, nullptr, m_buf, m_buf_size, m_error);
-}
-
-void
-WriteGPROperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_tid, nullptr, m_buf, m_buf_size, m_error);
-}
-
-void
-ReadFPROperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_tid, nullptr, m_buf, m_buf_size, m_error);
-}
-
-void
-WriteFPROperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_tid, nullptr, m_buf, m_buf_size, m_error);
-}
-
-void
-ReadRegisterSetOperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_tid, (void *)&m_regset, m_buf, m_buf_size, m_error);
-}
-
-void
-WriteRegisterSetOperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, (void *)&m_regset, m_buf, m_buf_size, m_error);
-}
-
 NativeRegisterContextLinux::NativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                        uint32_t concrete_frame_idx,
                                                        RegisterInfoInterface *reg_info_interface_p) :
   NativeRegisterContextRegisterInfo(native_thread, concrete_frame_idx, reg_info_interface_p)
 {}
 
 lldb::ByteOrder
 NativeRegisterContextLinux::GetByteOrder() const
NativeRegisterContextLinux::ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value)
     if (!reg_info)
       return Error("register %" PRIu32 " not found", reg_index);
 
     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(GetReadRegisterValueOperation(reg_info->byte_offset,
-                                                                reg_info->name,
-                                                                reg_info->byte_size,
-                                                                reg_value));
+    return process_p->DoOperation([&] {
+        return DoReadRegisterValue(reg_info->byte_offset, reg_info->name, reg_info->byte_size, reg_value);
+    });
 }
 
 Error
 NativeRegisterContextLinux::WriteRegisterRaw(uint32_t reg_index, const RegisterValue &reg_value)
 {
     uint32_t reg_to_write = reg_index;
     RegisterValue value_to_write = reg_value;
 
if (!process_sp)
       return Error("NativeProcessProtocol is NULL");
 
     const RegisterInfo *const register_to_write_info_p = GetRegisterInfoAtIndex (reg_to_write);
     assert (register_to_write_info_p && "register to write does not have valid RegisterInfo");
     if (!register_to_write_info_p)
         return Error("NativeRegisterContextLinux::%s failed to get RegisterInfo for write register index %" PRIu32, __FUNCTION__, reg_to_write);
 
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*> (process_sp.get ());
-    return process_p->DoOperation(GetWriteRegisterValueOperation(reg_info->byte_offset,
-                                                                 reg_info->name,
-                                                                 reg_value));
+    return process_p->DoOperation([&] {
+        return DoWriteRegisterValue(reg_info->byte_offset, reg_info->name, reg_value);
+    });
 }
 
 Error
 NativeRegisterContextLinux::ReadGPR()
 {
   NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
 
     void* buf = GetGPRBuffer();
     if (!buf)
       return Error("GPR buffer is NULL");
     size_t buf_size = GetGPRSize();
 
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
-    return process_p->DoOperation(GetReadGPROperation(buf, buf_size));
+    return process_p->DoOperation([&] { return DoReadGPR(buf, buf_size); });
 }
 
 Error
 NativeRegisterContextLinux::WriteGPR()
 {
   NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
 
     void* buf = GetGPRBuffer();
     if (!buf)
       return Error("GPR buffer is NULL");
     size_t buf_size = GetGPRSize();
 
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
-    return process_p->DoOperation(GetWriteGPROperation(buf, buf_size));
+    return process_p->DoOperation([&] { return DoWriteGPR(buf, buf_size); });
 }
 
 Error
 NativeRegisterContextLinux::ReadFPR()
 {
   NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
 
     void* buf = GetFPRBuffer();
     if (!buf)
       return Error("GPR buffer is NULL");
     size_t buf_size = GetFPRSize();
 
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
-    return process_p->DoOperation(GetReadFPROperation(buf, buf_size));
+    return process_p->DoOperation([&] { return DoReadFPR(buf, buf_size); });
 }
 
 Error
 NativeRegisterContextLinux::WriteFPR()
 {
   NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
 
     void* buf = GetFPRBuffer();
     if (!buf)
       return Error("GPR buffer is NULL");
     size_t buf_size = GetFPRSize();
 
     NativeProcessLinux* process_p = static_cast<NativeProcessLinux*>(process_sp.get());
-    return process_p->DoOperation(GetWriteFPROperation(buf, buf_size));
+    return process_p->DoOperation([&] { return DoWriteFPR(buf, buf_size); });
 }
 
 Error
 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());
 
-    ReadRegisterSetOperation op(m_thread.GetID(), buf, buf_size, regset);
-    return process_p->DoOperation(&op);
+    return process_p->DoOperation([&] {
+        Error error;
+        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_thread.GetID(),
+                static_cast<void *>(&regset), buf, buf_size, error);
+        return error;
+    });
 }
 
 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());
 
-    WriteRegisterSetOperation op(m_thread.GetID(), buf, buf_size, regset);
-    return process_p->DoOperation(&op);
+    return process_p->DoOperation([&] {
+        Error error;
+        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(),
+                static_cast<void *>(&regset), buf, buf_size, error);
+        return error;
+    });
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetReadRegisterValueOperation(uint32_t offset,
-                                                          const char* reg_name,
-                                                        uint32_t size,
-                                                        RegisterValue &value)
+Error
+NativeRegisterContextLinux::DoReadRegisterValue(uint32_t offset,
 {
-  return NativeProcessLinux::OperationUP(new ReadRegOperation(m_thread.GetID(), offset, reg_name, 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);
+
+    if (error.Success())
+        value = data;
+
+    if (log)
+        log->Printf ("NativeRegisterContextLinux::%s() reg %s: 0x%" PRIx64, __FUNCTION__, reg_name, data);
+
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetWriteRegisterValueOperation(uint32_t offset,
-                                                           const char* reg_name,
-                                                         const RegisterValue &value)
+Error
+NativeRegisterContextLinux::DoWriteRegisterValue(uint32_t offset,
 {
-  return NativeProcessLinux::OperationUP(new WriteRegOperation(m_thread.GetID(), offset, reg_name, 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;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetReadGPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux::DoReadGPR(void *buf, size_t buf_size)
 {
-  return NativeProcessLinux::OperationUP(new ReadGPROperation(m_thread.GetID(), buf, buf_size));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetWriteGPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux::DoWriteGPR(void *buf, size_t buf_size)
 {
-  return NativeProcessLinux::OperationUP(new WriteGPROperation(m_thread.GetID(), buf, buf_size));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetReadFPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux::DoReadFPR(void *buf, size_t buf_size)
 {
-  return NativeProcessLinux::OperationUP(new ReadFPROperation(m_thread.GetID(), buf, buf_size));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(PTRACE_GETFPREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux::GetWriteFPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux::DoWriteFPR(void *buf, size_t buf_size)
 {
-  return NativeProcessLinux::OperationUP(new WriteFPROperation(m_thread.GetID(), buf, buf_size));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(PTRACE_SETFPREGS, m_thread.GetID(), nullptr, buf, buf_size, error);
+    return error;
 }

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

public:
 
         uint32_t
         GetWatchpointSize(uint32_t wp_index);
 
         bool
         WatchpointIsEnabled(uint32_t wp_index);
 
     protected:
-        NativeProcessLinux::OperationUP
-        GetReadRegisterValueOperation(uint32_t offset,
-                                      const char* reg_name,
-                                      uint32_t size,
-                                      RegisterValue &value) override;
+        Error
+        DoReadRegisterValue(uint32_t offset,
 
-        NativeProcessLinux::OperationUP
-        GetWriteRegisterValueOperation(uint32_t offset,
-                                       const char* reg_name,
-                                       const RegisterValue &value) override;
+        Error
+        DoWriteRegisterValue(uint32_t offset,
 
-        NativeProcessLinux::OperationUP
-        GetReadGPROperation(void *buf, size_t buf_size) override;
+        Error
+        DoReadGPR(void *buf, size_t buf_size) override;
 
-        NativeProcessLinux::OperationUP
-        GetWriteGPROperation(void *buf, size_t buf_size) override;
+        Error
+        DoWriteGPR(void *buf, size_t buf_size) override;
 
-        NativeProcessLinux::OperationUP
-        GetReadFPROperation(void *buf, size_t buf_size) override;
+        Error
+        DoReadFPR(void *buf, size_t buf_size) override;
 
-        NativeProcessLinux::OperationUP
-        GetWriteFPROperation(void *buf, size_t buf_size) override;
+        Error
+        DoWriteFPR(void *buf, size_t buf_size) override;
 
         void*
         GetGPRBuffer() override { return &m_gpr_arm64; }
 
         void*
         GetFPRBuffer() override { return &m_fpr; }
 
         size_t

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 // Register sets for ARM64.
 static const RegisterSet
 g_reg_sets_arm64[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_arm64, g_gpr_regnums_arm64 },
     { "Floating Point Registers",   "fpu", k_num_fpr_registers_arm64, g_fpu_regnums_arm64 }
 };
 
-namespace
-{
-
-class ReadRegOperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadRegOperation(lldb::tid_t tid, uint32_t offset, const char *reg_name, RegisterValue &value) :
-        m_tid(tid),
-        m_offset(static_cast<uintptr_t>(offset)),
-        m_reg_name(reg_name),
-        m_value(value)
-    { }
-
-    void
-    Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    uintptr_t m_offset;
-    const char *m_reg_name;
-    RegisterValue &m_value;
-};
-
-class WriteRegOperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteRegOperation(lldb::tid_t tid, unsigned offset, const char *reg_name, const RegisterValue &value) :
-        m_tid(tid),
-        m_offset(offset),
-        m_reg_name(reg_name),
-        m_value(value)
-    { }
-
-    void
-    Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    uintptr_t m_offset;
-    const char *m_reg_name;
-    const RegisterValue &m_value;
-};
-
-class ReadGPROperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadGPROperation(lldb::tid_t tid, void *buf, size_t buf_size)
-        : m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-        { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class WriteGPROperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteGPROperation(lldb::tid_t tid, void *buf, size_t buf_size) :
-        m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-    { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class ReadFPROperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadFPROperation(lldb::tid_t tid, void *buf, size_t buf_size)
-        : m_tid(tid),
-          m_buf(buf),
-          m_buf_size(buf_size)
-        { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class WriteFPROperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteFPROperation(lldb::tid_t tid, void *buf, size_t buf_size)
-        : m_tid(tid), m_buf(buf), m_buf_size(buf_size)
-        { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    void *m_buf;
-    size_t m_buf_size;
-};
-
-class ReadDBGROperation : public NativeProcessLinux::Operation
-{
-public:
-    ReadDBGROperation(lldb::tid_t tid, unsigned int &count_wp, unsigned int &count_bp)
-        : m_tid(tid),
-          m_count_wp(count_wp),
-          m_count_bp(count_bp)
-        { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    unsigned int &m_count_wp;
-    unsigned int &m_count_bp;
-};
-
-class WriteDBGROperation : public NativeProcessLinux::Operation
-{
-public:
-    WriteDBGROperation(lldb::tid_t tid, lldb::addr_t *addr_buf,
-                       uint32_t *cntrl_buf, int type, int count)
-        : m_tid(tid),
-          m_address(addr_buf),
-          m_control(cntrl_buf),
-          m_type(type),
-          m_count(count)
-        { }
-
-    void Execute(NativeProcessLinux *monitor) override;
-
-private:
-    lldb::tid_t m_tid;
-    lldb::addr_t * m_address;
-    uint32_t * m_control;
-    int m_type;
-    int m_count;
-};
-
-} // end of anonymous namespace
-
-void
-ReadRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    if (m_offset > sizeof(struct user_pt_regs))
-    {
-        uintptr_t offset = m_offset - sizeof(struct user_pt_regs);
-        if (offset > sizeof(struct user_fpsimd_state))
-        {
-            m_error.SetErrorString("invalid offset value");
-            return;
-        }
-        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_tid, &regset, &ioVec, sizeof regs, m_error);
-        if (m_error.Success())
-        {
-            ArchSpec arch;
-            if (monitor->GetArchitecture(arch))
-                m_value.SetBytes((void *)(((unsigned char *)(&regs)) + offset), 16, arch.GetByteOrder());
-            else
-                m_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_tid, &regset, &ioVec, sizeof regs, m_error);
-        if (m_error.Success())
-        {
-            ArchSpec arch;
-            if (monitor->GetArchitecture(arch))
-                m_value.SetBytes((void *)(((unsigned char *)(regs)) + m_offset), 8, arch.GetByteOrder());
-            else
-                m_error.SetErrorString("failed to get architecture");
-        }
-    }
-}
-
-void
-WriteRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    if (m_offset > sizeof(struct user_pt_regs))
-    {
-        uintptr_t offset = m_offset - sizeof(struct user_pt_regs);
-        if (offset > sizeof(struct user_fpsimd_state))
-        {
-            m_error.SetErrorString("invalid offset value");
-            return;
-        }
-        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_tid, &regset, &ioVec, sizeof regs, m_error);
-        if (m_error.Success())
-        {
-            ::memcpy((void *)(((unsigned char *)(&regs)) + offset), m_value.GetBytes(), 16);
-            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, &regset, &ioVec, sizeof regs, m_error);
-        }
-    }
-    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_tid, &regset, &ioVec, sizeof regs, m_error);
-        if (m_error.Success())
-        {
-            ::memcpy((void *)(((unsigned char *)(&regs)) + m_offset), m_value.GetBytes(), 8);
-            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, &regset, &ioVec, sizeof regs, m_error);
-        }
-    }
-}
-
-void
-ReadGPROperation::Execute(NativeProcessLinux *monitor)
-{
-    int regset = NT_PRSTATUS;
-    struct iovec ioVec;
-
-    ioVec.iov_base = m_buf;
-    ioVec.iov_len = m_buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_tid, &regset, &ioVec, m_buf_size, m_error);
-}
-
-void
-WriteGPROperation::Execute(NativeProcessLinux *monitor)
-{
-    int regset = NT_PRSTATUS;
-    struct iovec ioVec;
-
-    ioVec.iov_base = m_buf;
-    ioVec.iov_len = m_buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, &regset, &ioVec, m_buf_size, m_error);
-}
-
-void
-ReadFPROperation::Execute(NativeProcessLinux *monitor)
-{
-    int regset = NT_FPREGSET;
-    struct iovec ioVec;
-
-    ioVec.iov_base = m_buf;
-    ioVec.iov_len = m_buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_tid, &regset, &ioVec, m_buf_size, m_error);
-}
-
-void
-WriteFPROperation::Execute(NativeProcessLinux *monitor)
-{
-    int regset = NT_FPREGSET;
-    struct iovec ioVec;
-
-    ioVec.iov_base = m_buf;
-    ioVec.iov_len = m_buf_size;
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, &regset, &ioVec, m_buf_size, m_error);
-}
-
-void
-ReadDBGROperation::Execute(NativeProcessLinux *monitor)
-{
-   int regset = NT_ARM_HW_WATCH;
-   struct iovec ioVec;
-   struct user_hwdebug_state dreg_state;
-
-   ioVec.iov_base = &dreg_state;
-   ioVec.iov_len = sizeof (dreg_state);
-
-   NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_tid, &regset, &ioVec, ioVec.iov_len, m_error);
-
-   m_count_wp = dreg_state.dbg_info & 0xff;
-   regset = NT_ARM_HW_BREAK;
-
-   NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, m_tid, &regset, &ioVec, ioVec.iov_len, m_error);
-   m_count_bp = dreg_state.dbg_info & 0xff;
-}
-
-void
-WriteDBGROperation::Execute(NativeProcessLinux *monitor)
-{
-    struct iovec ioVec;
-    struct user_hwdebug_state dreg_state;
-
-    memset (&dreg_state, 0, sizeof (dreg_state));
-    ioVec.iov_base = &dreg_state;
-    ioVec.iov_len = sizeof (dreg_state);
-
-    if (m_type == 0)
-        m_type = NT_ARM_HW_WATCH;
-    else
-        m_type = NT_ARM_HW_BREAK;
-
-    for (int i = 0; i < m_count; i++)
-    {
-        dreg_state.dbg_regs[i].addr = m_address[i];
-        dreg_state.dbg_regs[i].ctrl = m_control[i];
-    }
-
-    NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_tid, &m_type, &ioVec, ioVec.iov_len, m_error);
-}
-
 NativeRegisterContextLinux*
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
                                                                  NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
     return new NativeRegisterContextLinux_arm64(target_arch, native_thread, concrete_frame_idx);
 }
 

 Error
 NativeRegisterContextLinux_arm64::ReadHardwareDebugInfo(unsigned int &watch_count,
                                                         unsigned int &break_count)
 {
     NativeProcessProtocolSP process_sp (m_thread.GetProcess());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
     NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*>(process_sp.get());
+    ::pid_t tid = m_thread.GetID();
+
+    return process_p->DoOperation([&] {
+        int regset = NT_ARM_HW_WATCH;
+        struct iovec ioVec;
+        struct user_hwdebug_state dreg_state;
+        Error error;
 
-    ReadDBGROperation op(m_thread.GetID(), watch_count, break_count);
-    return process_p->DoOperation(&op);
+        ioVec.iov_base = &dreg_state;
+        ioVec.iov_len = sizeof (dreg_state);
+        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len, error);
+        watch_count = dreg_state.dbg_info & 0xff;
+
+        regset = NT_ARM_HW_BREAK;
+        NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, ioVec.iov_len, error);
+        break_count = dreg_state.dbg_info & 0xff;
+
+        return error;
+    });
 }
 
 Error
 NativeRegisterContextLinux_arm64::WriteHardwareDebugRegs(lldb::addr_t *addr_buf,
                                                          uint32_t *cntrl_buf,
                                                          int type,
                                                          int count)
 {
     NativeProcessProtocolSP process_sp (m_thread.GetProcess());
     if (!process_sp)
         return Error("NativeProcessProtocol is NULL");
     NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*>(process_sp.get());
 
-    WriteDBGROperation op(m_thread.GetID(), addr_buf, cntrl_buf, type, count);
-    return process_p->DoOperation(&op);
+    return process_p->DoOperation([&] {
+        struct iovec ioVec;
+        struct user_hwdebug_state dreg_state;
+        Error error;
+
+        memset (&dreg_state, 0, sizeof (dreg_state));
+        ioVec.iov_base = &dreg_state;
+        ioVec.iov_len = sizeof (dreg_state);
+
+        if (type == 0)
+            type = NT_ARM_HW_WATCH;
+        else
+            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;
+    });
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetReadRegisterValueOperation(uint32_t offset,
-                                                                const char* reg_name,
-                                                                uint32_t size,
-                                                                RegisterValue &value)
+Error
+NativeRegisterContextLinux_arm64::DoReadRegisterValue(uint32_t offset,
 {
-    return NativeProcessLinux::OperationUP(new ReadRegOperation(m_thread.GetID(), offset, reg_name, 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;
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetWriteRegisterValueOperation(uint32_t offset,
-                                                                 const char* reg_name,
-                                                                 const RegisterValue &value)
+        ioVec.iov_base = &regs;
+        ioVec.iov_len = sizeof regs;
+        NativeProcessLinux::PtraceWrapper(
+                PTRACE_GETREGSET, m_thread.GetID(), &regset, &ioVec, sizeof regs, error);
+        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);
+        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");
+        }
+    }
+    return error;
+}
+
+Error
+NativeRegisterContextLinux_arm64::DoWriteRegisterValue(uint32_t offset,
 {
-    return NativeProcessLinux::OperationUP(new WriteRegOperation(m_thread.GetID(), offset, reg_name, value));
+    Error error;
+    ::pid_t tid = m_thread.GetID();
+    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, tid, &regset, &ioVec, sizeof regs, error);
+
+        if (error.Success())
+        {
+            ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 16);
+            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+        }
+    }
+    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);
+        if (error.Success())
+        {
+            ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 8);
+            NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, tid, &regset, &ioVec, sizeof regs, error);
+        }
+    }
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetReadGPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux_arm64::DoReadGPR(void *buf, size_t buf_size)
 {
-    return NativeProcessLinux::OperationUP(new ReadGPROperation(m_thread.GetID(), buf, 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;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetWriteGPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux_arm64::DoWriteGPR(void *buf, size_t buf_size)
 {
-    return NativeProcessLinux::OperationUP(new WriteGPROperation(m_thread.GetID(), buf, 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;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetReadFPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux_arm64::DoReadFPR(void *buf, size_t buf_size)
 {
-    return NativeProcessLinux::OperationUP(new ReadFPROperation(m_thread.GetID(), buf, 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;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_arm64::GetWriteFPROperation(void *buf, size_t buf_size)
+Error
+NativeRegisterContextLinux_arm64::DoWriteFPR(void *buf, size_t buf_size)
 {
-    return NativeProcessLinux::OperationUP(new WriteFPROperation(m_thread.GetID(), buf, 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;
 }
 
 #endif // defined (__arm64__) || defined (__aarch64__)

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

public:
 
         lldb::addr_t
         GetWatchpointAddress (uint32_t wp_index) override;
 
         uint32_t
         NumSupportedHardwareWatchpoints () override;
 
     protected:
-        NativeProcessLinux::OperationUP
-        GetReadRegisterValueOperation(uint32_t offset,
-                                      const char* reg_name,
-                                      uint32_t size,
-                                      RegisterValue &value) override;
+        Error
+        DoReadRegisterValue(uint32_t offset,
 
-        NativeProcessLinux::OperationUP
-        GetWriteRegisterValueOperation(uint32_t offset,
-                                       const char* reg_name,
-                                       const RegisterValue &value) override;
+        Error
+        DoWriteRegisterValue(uint32_t offset,
 
-        NativeProcessLinux::OperationUP
-        GetReadWatchPointRegisterValueOperation(lldb::tid_t tid,
-                                                void* watch_readback);
-
-        NativeProcessLinux::OperationUP
-        GetWriteWatchPointRegisterValueOperation(lldb::tid_t tid,
-                                                 void* watch_readback);
+        Error
+        DoReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
+
+        Error
+        DoWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
 
         bool
         IsFR0();
 
         bool
         IsFPR(uint32_t reg_index) const;
 
         void*

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

namespace
     // Register sets for mips64.
     static const RegisterSet
     g_reg_sets_mips64[k_num_register_sets] =
     {
         { "General Purpose Registers",  "gpr", k_num_gpr_registers_mips64, g_gp_regnums_mips64 },
         { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 }
     };
 
-    class ReadRegOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        ReadRegOperation(lldb::tid_t tid, uint32_t offset, RegisterValue &value) :
-            m_tid(tid),
-            m_offset(static_cast<uintptr_t>(offset)),
-            m_value(value)
-        { }
-
-        void
-        Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        uintptr_t m_offset;
-        RegisterValue &m_value;
-    };
-
-    class WriteRegOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        WriteRegOperation(lldb::tid_t tid, unsigned offset, const char *reg_name, const RegisterValue &value) :
-            m_tid(tid),
-            m_offset(offset),
-            m_reg_name(reg_name),
-            m_value(value)
-        { }
-
-        void
-        Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        uintptr_t m_offset;
-        const char *m_reg_name;
-        const RegisterValue &m_value;
-    };
-
-    //------------------------------------------------------------------------------
-    /// @class ReadWatchPointRegOperation
-    /// @brief Implements NativeRegisterContextLinux_mips64::ReadWatchPointRegisterValue.
-    class ReadWatchPointRegOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        ReadWatchPointRegOperation (
-            lldb::tid_t tid,
-            void* watch_readback) :
-            m_tid(tid),
-            m_watch_readback(watch_readback)
-            {
-            }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        void* m_watch_readback;
-    };
-
-    //------------------------------------------------------------------------------
-    /// @class SetWatchPointRegOperation
-    /// @brief Implements NativeRegisterContextLinux_mips64::SetWatchPointRegisterValue.
-    class SetWatchPointRegOperation : public NativeProcessLinux::Operation
-    {
-    public:
-        SetWatchPointRegOperation (
-            lldb::tid_t tid,
-            void* watch_reg_value) :
-            m_tid(tid),
-            m_watch_reg_value(watch_reg_value)
-            {
-            }
-
-        void Execute(NativeProcessLinux *monitor) override;
-
-    private:
-        lldb::tid_t m_tid;
-        void* m_watch_reg_value;
-    };
 } // end of anonymous namespace
 
-void
-ReadRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    elf_gregset_t regs;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_tid, NULL, &regs, sizeof regs, m_error);
-    if (m_error.Success())
-    {
-        lldb_private::ArchSpec arch;
-        if (monitor->GetArchitecture(arch))
-            m_value.SetBytes((void *)(((unsigned char *)(regs)) + m_offset), 8, arch.GetByteOrder());
-        else
-            m_error.SetErrorString("failed to get architecture");
-    }
-}
-
-void
-WriteRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    elf_gregset_t regs;
-    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_tid, NULL, &regs, sizeof regs, m_error);
-    if (m_error.Success())
-    {
-        ::memcpy((void *)(((unsigned char *)(&regs)) + m_offset), m_value.GetBytes(), 8);
-        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_tid, NULL, &regs, sizeof regs, m_error);
-    }
-}
-
-void
-ReadWatchPointRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_GET_WATCH_REGS, m_tid, m_watch_readback, NULL, NULL, m_error);
-}
-
-void
-SetWatchPointRegOperation::Execute(NativeProcessLinux *monitor)
-{
-    NativeProcessLinux::PtraceWrapper(PTRACE_SET_WATCH_REGS, m_tid, m_watch_reg_value, NULL, NULL, m_error);
-}
-
 NativeRegisterContextLinux*
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
                                                                  NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
     return new NativeRegisterContextLinux_mips64(target_arch, native_thread, concrete_frame_idx);
 }
 

 NativeRegisterContextLinux_mips64::IsWatchpointHit (uint32_t wp_index, bool &is_hit)
 {
     if (wp_index >= NumSupportedHardwareWatchpoints())
         return Error("Watchpoint index out of range");
 
     // reading the current state of watch regs
     struct pt_watch_regs watch_readback;
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
-    NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
-    Error error = process_p->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(void*)&watch_readback));
+    NativeProcessLinux *const process_p = static_cast<NativeProcessLinux*> (process_sp.get ());
+    Error error = process_p->DoOperation([&] {
+        return DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&watch_readback));
+    });
 
     if (GetWatchHi (&watch_readback, wp_index) & (IRW))
     {
         // clear hit flag in watchhi 
         SetWatchHi (&watch_readback, wp_index, (GetWatchHi (&watch_readback, wp_index) & ~(IRW)));
-        process_p->DoOperation(GetWriteWatchPointRegisterValueOperation(m_thread.GetID(), (void*)&watch_readback));
+        process_p->DoOperation([&] {
+            return DoWriteWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&watch_readback));
+        });
      
         is_hit = true;
         return error;
     }
     is_hit = false;
     return error;
 }
 

 NativeRegisterContextLinux_mips64::ClearHardwareWatchpoint(uint32_t wp_index)
 {
     if (wp_index >= NumSupportedHardwareWatchpoints())
         return false;
 
     struct pt_watch_regs regs;
     // First reading the current state of watch regs
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
-    NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
-    process_p->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(void*)&regs));
+    NativeProcessLinux *const process_p = static_cast<NativeProcessLinux*> (process_sp.get ());
+    process_p->DoOperation([&] {
+        return DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void*>(&regs));
+    });
 
     if (regs.style == pt_watch_style_mips32)
     {
         regs.mips32.watchlo[wp_index] = default_watch_regs.mips32.watchlo[wp_index];
         regs.mips32.watchhi[wp_index] = default_watch_regs.mips32.watchhi[wp_index];
         regs.mips32.watch_masks[wp_index] = default_watch_regs.mips32.watch_masks[wp_index];
     }
     else // pt_watch_style_mips64
     {
         regs.mips64.watchlo[wp_index] = default_watch_regs.mips64.watchlo[wp_index];
         regs.mips64.watchhi[wp_index] = default_watch_regs.mips64.watchhi[wp_index];
         regs.mips64.watch_masks[wp_index] = default_watch_regs.mips64.watch_masks[wp_index];
     }
 
-    Error error = process_p->DoOperation(GetWriteWatchPointRegisterValueOperation(m_thread.GetID(), (void*)&regs));
+    Error error = process_p->DoOperation([&] {
+        return DoWriteWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&regs));
+    });
     if(!error.Fail())
     {
         hw_addr_map[wp_index] = LLDB_INVALID_ADDRESS;
         return true;
     }
     return false;
 }
 
 Error
 NativeRegisterContextLinux_mips64::ClearAllHardwareWatchpoints()
 {
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
-    NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
-    return process_p->DoOperation(GetWriteWatchPointRegisterValueOperation(m_thread.GetID(), (void*)&default_watch_regs));
+    NativeProcessLinux *const process_p = static_cast<NativeProcessLinux *> (process_sp.get ());
+    return process_p->DoOperation([&] {
+        return DoWriteWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&default_watch_regs));
+    });
 }
 
 Error
 NativeRegisterContextLinux_mips64::SetHardwareWatchpointWithIndex (
         lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) 
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::SetHardwareWatchpointWithIndex not implemented");
     return error;
 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::SetHardwareWatchpoint (
         lldb::addr_t addr, size_t size, uint32_t watch_flags)
 {
     struct pt_watch_regs regs;
 
     // First reading the current state of watch regs
     NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
-    NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
-    process_p->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(void*)&regs));
+    NativeProcessLinux *const process_p = static_cast<NativeProcessLinux*> (process_sp.get ());
+    process_p->DoOperation([&] {
+        return DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&regs));
+    });
 
     // Try if a new watch point fits in this state
     int index = GetVacantWatchIndex (&regs, addr, size, watch_flags, NumSupportedHardwareWatchpoints());
 
     // New watchpoint doesn't fit
     if (!index)
     return LLDB_INVALID_INDEX32;
 
 
     // It fits, so we go ahead with updating the state of watch regs 
-    process_p->DoOperation(GetWriteWatchPointRegisterValueOperation(m_thread.GetID(), (void*)&regs));
+    process_p->DoOperation([&] {
+        return DoWriteWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&regs));
+    });
 
     // Storing exact address  
     hw_addr_map[index] = addr; 
     return index;
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_mips64::GetWatchpointAddress (uint32_t wp_index)
NativeRegisterContextLinux_mips64::NumSupportedHardwareWatchpoints ()
     {
         NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
         if (!process_sp)
         {
             printf ("NativeProcessProtocol is NULL");
             return 0;
         }
 
-        NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
-        process_p->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(void*)&regs));
+        NativeProcessLinux *const process_p = static_cast<NativeProcessLinux*> (process_sp.get ());
+        process_p->DoOperation([&] {
+            return DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&regs));
+        });
         default_watch_regs = regs; // Keeping default watch regs values for future use
         switch (regs.style)
         {
             case pt_watch_style_mips32:
                 num_valid = regs.mips32.num_valid; // Using num_valid as cache
                 return num_valid;
             case pt_watch_style_mips64:
                 num_valid = regs.mips64.num_valid;
                 return num_valid;
             default:
                 log->Printf("NativeRegisterContextLinux_mips64::%s Error: Unrecognized watch register style", __FUNCTION__);
         }
         return 0;
     }
     return num_valid;
 }
-
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_mips64::GetReadRegisterValueOperation(uint32_t offset,
-                                                                 const char* reg_name,
-                                                                 uint32_t size,
-                                                                 RegisterValue &value)
+Error
+NativeRegisterContextLinux_mips64::DoReadRegisterValue(uint32_t offset,
 {
-    return NativeProcessLinux::OperationUP(new ReadRegOperation(m_thread.GetID(), offset, value));
+    Error error;
+    elf_gregset_t regs;
+    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+    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;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_mips64::GetWriteRegisterValueOperation(uint32_t offset,
-                                                                  const char* reg_name,
-                                                                  const RegisterValue &value)
+Error
+NativeRegisterContextLinux_mips64::DoWriteRegisterValue(uint32_t offset,
 {
-    return NativeProcessLinux::OperationUP(new WriteRegOperation(m_thread.GetID(), offset, reg_name, value));
+    Error error;
+    elf_gregset_t regs;
+    NativeProcessLinux::PtraceWrapper(PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+    if (error.Success())
+    {
+        ::memcpy((void *)(((unsigned char *)(&regs)) + offset), value.GetBytes(), 8);
+        NativeProcessLinux::PtraceWrapper(PTRACE_SETREGS, m_thread.GetID(), NULL, &regs, sizeof regs, error);
+    }
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_mips64::GetReadWatchPointRegisterValueOperation(lldb::tid_t tid, void* watch_readback)
+Error
+NativeRegisterContextLinux_mips64::DoReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback)
 {
-    return NativeProcessLinux::OperationUP(new ReadWatchPointRegOperation(m_thread.GetID(), watch_readback));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(
+            PTRACE_GET_WATCH_REGS, m_thread.GetID(), watch_readback, NULL, 0, error);
+    return error;
 }
 
-NativeProcessLinux::OperationUP
-NativeRegisterContextLinux_mips64::GetWriteWatchPointRegisterValueOperation(lldb::tid_t tid, void* watch_reg_value)
+Error
+NativeRegisterContextLinux_mips64::DoWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_reg_value)
 {
-    return NativeProcessLinux::OperationUP(new SetWatchPointRegOperation(m_thread.GetID(), watch_reg_value));
+    Error error;
+    NativeProcessLinux::PtraceWrapper(PTRACE_SET_WATCH_REGS,
+            m_thread.GetID(), watch_reg_value, NULL, 0, error);
+    return error;
 }
 
 #endif // defined (__mips__)