[LLDB][MIPS] List and set hardware watchpoints for MIPS

[mohit.bhakkad]

Summary

This patch contains:

• Set H/W watchpoints
• List H/W watchpoints
• Check if watchpoint is hit Will roll out remaining functions if this looks good.

[clayborg]

Move code from NativeRegisterContextLinux_mips64.h to NativeRegisterContextLinux_mips64.cpp and this will be good to go.

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

18–70

Do we need this content in the header file? Seems like it could move to NativeRegisterContextLinux_mips64.cpp to make sure we aren't #define'ing simple names in header files (W_BIT, R_BIT, I_BIT, etc).

[mohit.bhakkad]

Changes in this revision:

• Addressed comment on previous revision
• Adding functionality to clear watchpoints.

[clayborg]

Looks good.

[mohit.bhakkad]

Changes in this revision:

• some mips based changes in both client and server side
• some code trimming.

[mohit.bhakkad]

Synced this patch with current ToT.
Should we go ahead and commit it?

[mohit.bhakkad]

Hi @clayborg, could you please review this?

[clayborg]

Looks good except we should simplify the logic for finding a watchpoint by address using the code suggested for WatchpointList::FindByAddress() in the inlined code.

source/Breakpoint/WatchpointList.cpp

76–84 ↗

(On Diff #26041)

Shouldn't this just be simpler:

lldb::addr_t watch_addr = (*pos)->GetLoadAddress();
lldb::addr_t watch_size = (*pos)->GetByteSize();
if (watch_addr <= addr && addr < watch_addr + watch_size)
...

[mohit.bhakkad]

Simplified WatchpointList::FindByAddress() as suggested.

[clayborg]

Much better.

[mohit.bhakkad]

Changes in this patch:

• Syncing it with rL238196
• Adding a local buffer to get exact address (As mips watch registers conatins a masked one)

[mohit.bhakkad]

My apologies for requesting review after acceptance, but ToT is changed significantly, can't commit directly.

[mohit.bhakkad]

Adding some corrections to previous patch.
Hi @clayborg, could you please review this?

[clayborg]

Looks good.

source/Plugins/Process/Linux/NativeProcessLinux.h

public:
         /// Reads the contents from the register identified by the given (architecture
         /// dependent) offset.
         ///
         /// This method is provided for use by RegisterContextLinux derivatives.
         Error
         ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
                           unsigned size, RegisterValue &value);
 
+        /// Reads the contents from the watch registers.
+        ///
+        /// This method is provided for use by RegisterContextLinux derivatives.
+        Error
+        ReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
+
+        /// Sets the contents of the watch registers.
+        ///
+        /// This method is provided for use by RegisterContextLinux derivatives.
+        Error
+        SetWatchPointRegisterValue(lldb::tid_t tid, void* watch_reg_value);
+
         /// Writes the given value to the register identified by the given
         /// (architecture dependent) offset.
         ///
         /// This method is provided for use by RegisterContextLinux derivatives.
         Error
         WriteRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
                            const RegisterValue &value);
 

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include <sys/socket.h>
 #include <sys/signalfd.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
+#ifndef PTRACE_GET_WATCH_REGS
+    #define PTRACE_GET_WATCH_REGS 0xd0
+    #define PTRACE_SET_WATCH_REGS 0xd1
+#endif
+
 #if defined (__arm64__) || defined (__aarch64__)
 // NT_PRSTATUS and NT_FPREGSET definition
 #include <elf.h>
 #endif
 
 #ifdef __ANDROID__
 #define __ptrace_request int
 #define PT_DETACH PTRACE_DETACH
#endif
 
     void
     WriteRegisterSetOperation::Execute(NativeProcessLinux *monitor)
     {
         PTRACE(PTRACE_SETREGSET, m_tid, (void *)&m_regset, m_buf, m_buf_size, m_error);
     }
 
     //------------------------------------------------------------------------------
+    /// @class ReadWatchPointRegOperation
+    /// @brief Implements NativeProcessLinux::ReadWatchPointRegisterValue.
+    class ReadWatchPointRegOperation : public 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;
+    };
+
+    void
+    ReadWatchPointRegOperation::Execute(NativeProcessLinux *monitor)
+    {
+        PTRACE(PTRACE_GET_WATCH_REGS, m_tid, m_watch_readback, NULL, NULL, m_error);
+    }
+
+    //------------------------------------------------------------------------------
+    /// @class SetWatchPointRegOperation
+    /// @brief Implements NativeProcessLinux::SetWatchPointRegisterValue.
+    class SetWatchPointRegOperation : public 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;
+    };
+
+    void
+    SetWatchPointRegOperation::Execute(NativeProcessLinux *monitor)
+    {
+      PTRACE(PTRACE_SET_WATCH_REGS, m_tid, m_watch_reg_value, NULL, NULL, m_error);
+    }
+
+    //------------------------------------------------------------------------------
     /// @class ResumeOperation
     /// @brief Implements NativeProcessLinux::Resume.
     class ResumeOperation : public Operation
     {
     public:
         ResumeOperation(lldb::tid_t tid, uint32_t signo) :
             m_tid(tid), m_signo(signo) { }
 
case TRAP_HWBKPT: // We receive this on watchpoint hit
                 break;
             }
         }
         // Otherwise, report step over
         MonitorTrace(pid, thread_sp);
         break;
 
     case SI_KERNEL:
+#if defined __mips__
+        // For mips there is no special signal for watchpoint
+        // So we check for watchpoint in kernel trap
+        if (thread_sp)
+        {
+            // If a watchpoint was hit, report it
+            uint32_t wp_index;
+            Error error = thread_sp->GetRegisterContext()->GetWatchpointHitIndex(wp_index);
+            if (error.Fail() && log)
+                log->Printf("NativeProcessLinux::%s() "
+                            "received error while checking for watchpoint hits, "
+                            "pid = %" PRIu64 " error = %s",
+                            __FUNCTION__, pid, error.AsCString());
+            if (wp_index != LLDB_INVALID_INDEX32)
+            {
+                MonitorWatchpoint(pid, thread_sp, wp_index);
+                break;
+            }
+        }
+        // NO BREAK
+#endif
     case TRAP_BRKPT:
         MonitorBreakpoint(pid, thread_sp);
         break;
 
     case SIGTRAP:
     case (SIGTRAP | 0x80):
         if (log)
             log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), pid);

 NativeProcessLinux::WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size, unsigned int regset)
 {
     WriteRegisterSetOperation op(tid, buf, buf_size, regset);
     m_monitor_up->DoOperation(&op);
     return op.GetError();
 }
 
 Error
+NativeProcessLinux::ReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback)
+{
+    ReadWatchPointRegOperation op(tid, watch_readback);
+    DoOperation(&op);
+    return op.GetError();
+}
+
+Error
+NativeProcessLinux::SetWatchPointRegisterValue(lldb::tid_t tid, void* watch_reg_value)
+{
+    SetWatchPointRegOperation op(tid, watch_reg_value);
+    DoOperation(&op);
+    return op.GetError();
+}
+
+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);

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 
 #ifndef lldb_NativeRegisterContextLinux_mips64_h
 #define lldb_NativeRegisterContextLinux_mips64_h
 
 #include "lldb/Host/common/NativeRegisterContextRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContext_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 
 
 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     // ---------------------------------------------------------------------------
     // Internal codes for mips64 GP registers.
     // ---------------------------------------------------------------------------
     enum
     {
         k_first_gp_reg_mips64,
         gp_reg_r0_mips64 = k_first_gp_reg_mips64,
         gp_reg_r1_mips64,
         gp_reg_r2_mips64,
         gp_reg_r3_mips64,
         gp_reg_r4_mips64,
         gp_reg_r5_mips64,
         gp_reg_r6_mips64,
         gp_reg_r7_mips64,
         gp_reg_r8_mips64,
         gp_reg_r9_mips64,
         gp_reg_r10_mips64,
         gp_reg_r11_mips64,
         gp_reg_r12_mips64,
         gp_reg_r13_mips64,
         gp_reg_r14_mips64,
         gp_reg_r15_mips64,
         gp_reg_r16_mips64,
         gp_reg_r17_mips64,
         gp_reg_r18_mips64,
         gp_reg_r19_mips64,
         gp_reg_r20_mips64,
         gp_reg_r21_mips64,
         gp_reg_r22_mips64,
         gp_reg_r23_mips64,
         gp_reg_r24_mips64,
         gp_reg_r25_mips64,
         gp_reg_r26_mips64,
         gp_reg_r27_mips64,
         gp_reg_r28_mips64,
         gp_reg_r29_mips64,
         gp_reg_r30_mips64,
         gp_reg_r31_mips64,
         gp_reg_mullo_mips64,
         gp_reg_mulhi_mips64,
         gp_reg_pc_mips64,
         gp_reg_badvaddr_mips64,
         gp_reg_sr_mips64,
         gp_reg_cause_mips64,
         k_num_gp_reg_mips64,
     };
 
     class NativeRegisterContextLinux_mips64 : public NativeRegisterContextRegisterInfo
     {
     public:
         NativeRegisterContextLinux_mips64 (NativeThreadProtocol &native_thread, 
             uint32_t concrete_frame_idx, RegisterInfoInterface *reg_info_interface_p);
 
         uint32_t
         GetRegisterSetCount () const override;
public:
 
         Error
         WriteAllRegisterValues (const lldb::DataBufferSP &data_sp) override;
 
         Error
         IsWatchpointHit (uint32_t wp_index, bool &is_hit) override;
 
         Error
+        GetWatchpointHitIndex(uint32_t &wp_index) override;
+
+        Error
         IsWatchpointVacant (uint32_t wp_index, bool &is_vacant) override;
 
         bool
         ClearHardwareWatchpoint (uint32_t wp_index) override;
 
         Error
         ClearAllHardwareWatchpoints () override;
 

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 //===-- NativeRegisterContextLinux_mips64.cpp ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeRegisterContextLinux_mips64.h"
-
+#include "lldb/Core/Log.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 
+#include <sys/ptrace.h>
+#include <asm/ptrace.h>
+
+#ifndef PTRACE_GET_WATCH_REGS
+enum pt_watch_style
+{
+    pt_watch_style_mips32,
+    pt_watch_style_mips64
+};
+struct mips32_watch_regs
+{
+    unsigned int watchlo[8];
+    /* Lower 16 bits of watchhi. */
+    unsigned short watchhi[8];
+    /* Valid mask and I R W bits.
+     * bit 0 -- 1 if W bit is usable.
+     * bit 1 -- 1 if R bit is usable.
+     * bit 2 -- 1 if I bit is usable.
+     * bits 3 - 11 -- Valid watchhi mask bits.
+    */
+    unsigned short watch_masks[8];
+    /* The number of valid watch register pairs.  */
+    unsigned int num_valid;
+} __attribute__((aligned(8)));
+
+struct mips64_watch_regs
+{
+    unsigned long long watchlo[8];
+    unsigned short watchhi[8];
+    unsigned short watch_masks[8];
+    unsigned int num_valid;
+} __attribute__((aligned(8)));
+
+struct pt_watch_regs
+{
+    enum pt_watch_style style;
+    union
+    {
+        struct mips32_watch_regs mips32;
+        struct mips64_watch_regs mips64;
+    };
+};
+#endif
+
+#define W_BIT 0
+#define R_BIT 1
+#define I_BIT 2
+
+#define W_MASK (1 << W_BIT)
+#define R_MASK (1 << R_BIT)
+#define I_MASK (1 << I_BIT)
+
+#define IRW_MASK (I_MASK | R_MASK | W_MASK)
+
+struct pt_watch_regs default_watch_regs;
+
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------
 // Private namespace.
 // ----------------------------------------------------------------------------
 
 namespace

 Error
 NativeRegisterContextLinux_mips64::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 {
     Error error;
     error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::WriteAllRegisterValues not implemented");
     return error;
 }
 
+uint32_t
+GetWatchHi (struct pt_watch_regs *regs, int n)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            return regs->mips32.watchhi[n];
+        case pt_watch_style_mips64:
+            return regs->mips64.watchhi[n];
+        default:
+            log->Printf("Unrecognized watch register style");
+    }
+}
+
+void
+SetWatchHi (struct pt_watch_regs *regs, int n, uint16_t value)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            regs->mips32.watchhi[n] = value;
+            break;
+        case pt_watch_style_mips64:
+            regs->mips64.watchhi[n] = value;
+            break;
+        default:
+            log->Printf("Unrecognized watch register style");   
+    }
+}
+
+lldb::addr_t
+GetWatchLo (struct pt_watch_regs *regs, int n)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            return regs->mips32.watchlo[n];
+        case pt_watch_style_mips64:
+            return regs->mips64.watchlo[n];
+        default:
+            log->Printf("Unrecognized watch register style");
+    }
+}
+
+void
+SetWatchLo (struct pt_watch_regs *regs, int n, uint64_t value)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            regs->mips32.watchlo[n] = (uint32_t) value;
+            break;
+        case pt_watch_style_mips64:
+            regs->mips64.watchlo[n] = value;
+            break;
+        default:
+            log->Printf("Unrecognized watch register style");
+    }
+}
+
+uint32_t
+GetIRWMask (struct pt_watch_regs *regs, int n)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            return regs->mips32.watch_masks[n] & IRW_MASK;
+        case pt_watch_style_mips64:
+            return regs->mips64.watch_masks[n] & IRW_MASK;
+        default:
+            log->Printf("Unrecognized watch register style");
+    }
+}
+
+static uint32_t
+GetRegMask (struct pt_watch_regs *regs, int n)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    switch (regs->style)
+    {
+        case pt_watch_style_mips32:
+            return regs->mips32.watch_masks[n] & ~IRW_MASK;
+        case pt_watch_style_mips64:
+            return regs->mips64.watch_masks[n] & ~IRW_MASK;
+        default:
+            log->Printf("Unrecognized watch register style");
+    }
+}
+
+static lldb::addr_t
+FillMask (lldb::addr_t mask)
+{
+    lldb::addr_t f = 1;
+
+    while (f && f < mask)
+    {
+        mask |= f;
+        f <<= 1;
+    }
+    return mask;
+}
+
+int
+GetVacantWatchIndex (struct pt_watch_regs *regs, lldb::addr_t addr, int size, uint32_t irw, int num_valid)
+{
+    lldb::addr_t last_byte = addr + size - 1;
+    lldb::addr_t mask = FillMask (addr ^ last_byte) | IRW_MASK;
+    lldb::addr_t base_addr = addr & ~mask;
+
+    // Check if this address is already watched by previous watch points.
+    lldb::addr_t lo;
+    uint16_t hi;
+    int vacant_watches = 0;
+    for (int index = 0; index < num_valid; index++)
+    {
+        lo = GetWatchLo (regs, index);
+        if (lo != 0 && irw == ((uint32_t) lo & irw))
+        {
+            hi = GetWatchHi (regs, index) | IRW_MASK;
+            lo &= ~(lldb::addr_t) hi;
+            if (addr >= lo && last_byte <= (lo + hi))
+                return index;
+        }
+        else
+            vacant_watches++;
+    }
+
+    // Now try to find a vacant index
+    if(vacant_watches > 0)
+    {
+        vacant_watches = 0;
+        for (int index = 0; index < num_valid; index++)
+        {
+            lo = GetWatchLo (regs, index);
+            if (lo == 0
+              && irw == (GetIRWMask (regs, index) & irw))
+            {
+                if (mask <= (GetRegMask (regs, index) | IRW_MASK))
+                {
+                    // It fits, we can use it. 
+                    SetWatchLo (regs, index, base_addr | irw);
+                    SetWatchHi (regs, index, mask & ~IRW_MASK);
+                    return index;
+                }
+                else
+                {
+                    // It doesn't fit, but has the proper IRW capabilities
+                    vacant_watches++;
+                }
+            }
+        }
+
+        if (vacant_watches > 1)
+        {
+            // Split this watchpoint accross several registers
+            struct pt_watch_regs regs_copy;
+            regs_copy = *regs;
+            lldb::addr_t break_addr;
+            int segment_size;
+            for (int index = 0; index < num_valid; index++)
+            {
+                lo = GetWatchLo (&regs_copy, index);
+                hi = GetRegMask (&regs_copy, index) | IRW_MASK;
+                if (lo == 0 && irw == (hi & irw))
+                {
+                    lo = addr & ~(lldb::addr_t) hi;
+                    break_addr = lo + hi + 1;
+                    if (break_addr >= addr + size)
+                        segment_size = size;
+                    else
+                        segment_size = break_addr - addr;
+                    mask = FillMask (addr ^ (addr + segment_size - 1));
+                    SetWatchLo (&regs_copy, index, (addr & ~mask) | irw);
+                    SetWatchHi (&regs_copy, index, mask & ~IRW_MASK);
+                    if (break_addr >= addr + size)
+                    {
+                        *regs = regs_copy;
+                        return index;
+                    }
+                    size = addr + size - break_addr;
+                    addr = break_addr;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
 Error
 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->ReadWatchPointRegisterValue(m_thread.GetID(),(void*)&watch_readback);
+
+
+    if (GetWatchHi (&watch_readback, wp_index) & (IRW_MASK))
+    {
+        // clear hit flag in watchhi 
+        SetWatchHi (&watch_readback, wp_index, (GetWatchHi (&watch_readback, wp_index) & ~(IRW_MASK)));
+        process_p->SetWatchPointRegisterValue(m_thread.GetID(), (void*)&watch_readback);
+
+        is_hit = true;
+        return error;
+    }
     is_hit = false;
-    return Error("MIPS TODO: NativeRegisterContextLinux_mips64::IsWatchpointHit not implemented");
+    return error;
+}
+
+Error
+NativeRegisterContextLinux_mips64::GetWatchpointHitIndex(uint32_t &wp_index) {
+    uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
+    for (wp_index = 0; wp_index < num_hw_wps; ++wp_index)
+    {
+        bool is_hit;
+        Error error = IsWatchpointHit(wp_index, is_hit);
+        if (error.Fail()) {
+            wp_index = LLDB_INVALID_INDEX32;
+            return error;
+        } else if (is_hit) {
+            return error;
+        }
+    }
+    wp_index = LLDB_INVALID_INDEX32;
+    return Error();
 }
 
 Error
 NativeRegisterContextLinux_mips64::IsWatchpointVacant (uint32_t wp_index, bool &is_vacant)
 {
     is_vacant = false;
     return Error("MIPS TODO: NativeRegisterContextLinux_mips64::IsWatchpointVacant not implemented");
 }
 
 bool
-NativeRegisterContextLinux_mips64::ClearHardwareWatchpoint (uint32_t wp_index)
+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->ReadWatchPointRegisterValue(m_thread.GetID(),(void*)&regs);
+
+    switch (regs.style)
+    {
+        case 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];
+            break;
+        case 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];
+            break;
+        default:
+            ;// This will never get hit 
+    }
+
+    Error error = process_p->SetWatchPointRegisterValue(m_thread.GetID(), (void*)&regs);
+    if(!error.Fail())
+        return true;
     return false;
 }
 
 Error
-NativeRegisterContextLinux_mips64::ClearAllHardwareWatchpoints ()
+NativeRegisterContextLinux_mips64::ClearAllHardwareWatchpoints()
 {
-    Error error;
-    error.SetErrorString ("MIPS TODO: NativeRegisterContextLinux_mips64::ClearAllHardwareWatchpoints not implemented");
-    return error;
+    NativeProcessProtocolSP process_sp (m_thread.GetProcess ());
+    NativeProcessLinux *const process_p = reinterpret_cast<NativeProcessLinux*> (process_sp.get ());
+    return process_p->SetWatchPointRegisterValue(m_thread.GetID(), (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->ReadWatchPointRegisterValue(m_thread.GetID(),(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->SetWatchPointRegisterValue(m_thread.GetID(),(void*)&regs); 
+    return index;
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_mips64::GetWatchpointAddress (uint32_t wp_index)
 {
     return LLDB_INVALID_ADDRESS;
 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::NumSupportedHardwareWatchpoints ()
 {
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    struct pt_watch_regs regs;
+    static int num_valid = 0;
+    if (!num_valid)
+    {
+        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->ReadWatchPointRegisterValue(m_thread.GetID(),(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;
+}

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

if (want_breakpoint)
                     " failed to set breakpoint: %s",
                     __FUNCTION__,
                     m_debugged_process_sp->GetID (),
                     error.AsCString ());
         return SendErrorResponse (0x09);
     }
     else
     {
-        uint32_t watch_flags =
-            stoppoint_type == eWatchpointWrite
-            ? 0x1  // Write
-            : 0x3; // ReadWrite
+        uint32_t watch_flags;
+        switch(stoppoint_type)
+        {
+            case eWatchpointWrite:
+                watch_flags = 0x1;
+                break;
+            case eWatchpointRead:
+#if defined(__x86_64__)
+                watch_flags = 0x3;
+#else
+                watch_flags = 0x2;
+#endif
+                break;
+            case eWatchpointReadWrite:
+                watch_flags = 0x3;
+                break;
+            default:
+                watch_flags = 0x1;
+        }
 
         // Try to set the watchpoint.
         const Error error = m_debugged_process_sp->SetWatchpoint (
                 addr, size, watch_flags, want_hardware);
         if (error.Success ())
             return SendOKResponse ();
         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
         if (log)