[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 ↗

(On Diff #24104)

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.

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

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, NULL);
+            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);

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 
 #ifndef lldb_NativeRegisterContextLinux_mips64_h
 #define lldb_NativeRegisterContextLinux_mips64_h
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
 #include "Plugins/Process/Utility/RegisterContext_mips64.h"
 #include "Plugins/Process/Utility/lldb-mips64-register-enums.h"
 
+#define MAX_NUM_WP 8
+
 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_mips64 : public NativeRegisterContextLinux
     {
     public:
public:
 
         Error
         WriteFPR() override;
 
         Error
         IsWatchpointHit (uint32_t wp_index, bool &is_hit) override;
 
         Error
+        GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr) override;
+
+        Error
         IsWatchpointVacant (uint32_t wp_index, bool &is_vacant) override;
 
         bool
         ClearHardwareWatchpoint (uint32_t wp_index) override;
 
         Error
         ClearAllHardwareWatchpoints () override;
 
protected:
                                       uint32_t size,
                                       RegisterValue &value) override;
 
         NativeProcessLinux::OperationUP
         GetWriteRegisterValueOperation(uint32_t offset,
                                        const char* reg_name,
                                        const RegisterValue &value) override;
 
+        NativeProcessLinux::OperationUP
+        GetReadWatchPointRegisterValue(lldb::tid_t tid,
+                                       void* watch_readback);
+
+        NativeProcessLinux::OperationUP
+        GetWriteWatchPointRegisterValue(lldb::tid_t tid,
+                                       void* watch_readback);
+
         bool
         IsFR0();
 
         bool
         IsFPR(uint32_t reg_index) const;
 
         void*
         GetGPRBuffer() override { return &m_gpr_mips64; }
private:
             uint32_t last_fpr;
         };
 
         RegInfo m_reg_info;
 
         uint64_t m_gpr_mips64[k_num_gpr_registers_mips64];
 
         FPR_mips m_fpr;
+
+        lldb::addr_t hw_addr_map[MAX_NUM_WP];
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_mips64_h
 
 #endif // defined (__mips__)

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips.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
+{
+    uint32_t watchlo[8];
+    uint16_t watchhi[8];
+    uint16_t watch_masks[8];
+    uint32_t num_valid;
+} __attribute__((aligned(8)));
+
+struct mips64_watch_regs
+{
+    uint64_t watchlo[8];
+    uint16_t watchhi[8];
+    uint16_t watch_masks[8];
+    uint32_t 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;
+    };
+};
+
+#define PTRACE_GET_WATCH_REGS 0xd0
+#define PTRACE_SET_WATCH_REGS 0xd1
+#endif
+
+#define W (1 << 0)
+#define R (1 << 1)
+#define I (1 << 2)
+
+#define IRW  (I | R | W)
+
+struct pt_watch_regs default_watch_regs;
+
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------
 // Private namespace.
 // ----------------------------------------------------------------------------
 
 namespace
namespace
 
     private:
         lldb::tid_t m_tid;
         uintptr_t m_offset;
         const char *m_reg_name;
         const RegisterValue &m_value;
     };
 
+    //------------------------------------------------------------------------------
+    /// @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;
+    };
+
+    //------------------------------------------------------------------------------
+    /// @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;
+    };
 } // 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())
WriteRegOperation::Execute(NativeProcessLinux *monitor)
     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);
 }
 
switch (target_arch.GetMachine ())
             break;
         default:
             assert(false && "Unhandled target architecture.");
             break;
     }
 
     // Clear out the FPR state.
     ::memset(&m_fpr, 0, sizeof(FPR_mips));
+
+    // init h/w watchpoint addr map
+    for (int index = 0;index <= MAX_NUM_WP; index++)
+        hw_addr_map[index] = LLDB_INVALID_ADDRESS;
 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::GetRegisterSetCount () const
 {
     return k_num_register_sets;
 }
 

 }
 
 bool
 NativeRegisterContextLinux_mips64::IsFPR(uint32_t reg_index) const
 {
     return (m_reg_info.first_fpr <= reg_index && reg_index <= m_reg_info.last_fpr);
 }
 
+static uint32_t
+GetWatchHi (struct pt_watch_regs *regs, uint32_t index)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        return regs->mips32.watchhi[index];
+    else if (regs->style == pt_watch_style_mips64)
+        return regs->mips64.watchhi[index];
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static void
+SetWatchHi (struct pt_watch_regs *regs, uint32_t index, uint16_t value)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        regs->mips32.watchhi[index] = value;
+    else if (regs->style == pt_watch_style_mips64)
+        regs->mips64.watchhi[index] = value;
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static lldb::addr_t
+GetWatchLo (struct pt_watch_regs *regs, uint32_t index)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        return regs->mips32.watchlo[index];
+    else if (regs->style == pt_watch_style_mips64)
+        return regs->mips64.watchlo[index];
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static void
+SetWatchLo (struct pt_watch_regs *regs, uint32_t index, uint64_t value)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        regs->mips32.watchlo[index] = (uint32_t) value;
+    else if (regs->style == pt_watch_style_mips64)
+        regs->mips64.watchlo[index] = value;
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static uint32_t
+GetIRWMask (struct pt_watch_regs *regs, uint32_t index)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        return regs->mips32.watch_masks[index] & IRW;
+    else if (regs->style == pt_watch_style_mips64)
+        return regs->mips64.watch_masks[index] & IRW;
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static uint32_t
+GetRegMask (struct pt_watch_regs *regs, uint32_t index)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    if (regs->style == pt_watch_style_mips32)
+        return regs->mips32.watch_masks[index] & ~IRW;
+    else if (regs->style == pt_watch_style_mips64)
+        return regs->mips64.watch_masks[index] & ~IRW;
+    else
+        log->Printf("Invalid watch register style");
+}
+
+static lldb::addr_t
+GetRangeMask (lldb::addr_t mask)
+{
+    lldb::addr_t mask_bit = 1;
+    while (mask_bit < mask)
+    {
+        mask = mask | mask_bit;
+        mask_bit <<= 1;
+    }
+    return mask;
+}
+
+static int
+GetVacantWatchIndex (struct pt_watch_regs *regs, lldb::addr_t addr, uint32_t size, uint32_t irw, uint32_t num_valid)
+{
+    lldb::addr_t last_byte = addr + size - 1;
+    lldb::addr_t mask = GetRangeMask (addr ^ last_byte) | IRW;
+    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;
+    uint32_t vacant_watches = 0;
+    for (uint32_t index = 0; index < num_valid; index++)
+    {
+        lo = GetWatchLo (regs, index);
+        if (lo != 0 && irw == ((uint32_t) lo & irw))
+        {
+            hi = GetWatchHi (regs, index) | IRW;
+            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 (uint32_t index = 0; index < num_valid; index++)
+        {
+            lo = GetWatchLo (regs, index);
+            if (lo == 0
+              && irw == (GetIRWMask (regs, index) & irw))
+            {
+                if (mask <= (GetRegMask (regs, index) | IRW))
+                {
+                    // It fits, we can use it. 
+                    SetWatchLo (regs, index, base_addr | irw);
+                    SetWatchHi (regs, index, mask & ~IRW);
+                    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;
+            uint32_t segment_size;
+            for (uint32_t index = 0; index < num_valid; index++)
+            {
+                lo = GetWatchLo (&regs_copy, index);
+                hi = GetRegMask (&regs_copy, index) | IRW;
+                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 = GetRangeMask (addr ^ (addr + segment_size - 1));
+                    SetWatchLo (&regs_copy, index, (addr & ~mask) | irw);
+                    SetWatchHi (&regs_copy, index, mask & ~IRW);
+                    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->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(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));
+     
+        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, lldb::addr_t trap_addr) {
+    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;
+        } 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->DoOperation(GetReadWatchPointRegisterValueOperation(m_thread.GetID(),(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));
+    if(!error.Fail())
+    {
+        hw_addr_map[wp_index] = LLDB_INVALID_ADDRESS;
+        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->DoOperation(GetWriteWatchPointRegisterValueOperation(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->DoOperation(GetReadWatchPointRegisterValueOperation(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->DoOperation(GetWriteWatchPointRegisterValueOperation(m_thread.GetID(), (void*)&regs));
+
+    // Storing exact address  
+    hw_addr_map[index] = addr; 
+    return index;
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_mips64::GetWatchpointAddress (uint32_t wp_index)
 {
+    if (wp_index >= NumSupportedHardwareWatchpoints())
         return LLDB_INVALID_ADDRESS;
+
+    return hw_addr_map[wp_index];
 }
 
 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->DoOperation(GetReadWatchPointRegisterValueOperation(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;
+}
+
 NativeProcessLinux::OperationUP
 NativeRegisterContextLinux_mips64::GetReadRegisterValueOperation(uint32_t offset,
                                                                  const char* reg_name,
                                                                  uint32_t size,
                                                                  RegisterValue &value)
 {
     return NativeProcessLinux::OperationUP(new ReadRegOperation(m_thread.GetID(), offset, value));
 }
 
 NativeProcessLinux::OperationUP
 NativeRegisterContextLinux_mips64::GetWriteRegisterValueOperation(uint32_t offset,
                                                                   const char* reg_name,
                                                                   const RegisterValue &value)
 {
     return NativeProcessLinux::OperationUP(new WriteRegOperation(m_thread.GetID(), offset, reg_name, value));
 }
 
+NativeProcessLinux::OperationUP
+NativeRegisterContextLinux_mips64::GetReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback)
+{
+    return NativeProcessLinux::OperationUP(new ReadWatchPointRegOperation(m_thread.GetID(), watch_readback));
+}
+
+NativeProcessLinux::OperationUP
+NativeRegisterContextLinux_mips64::GetWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_reg_value)
+{
+    return NativeProcessLinux::OperationUP(new SetWatchPointRegOperation(m_thread.GetID(), watch_readback));
+}
+
 #endif // defined (__mips__)

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

#if defined(__APPLE__)
     if (sub != LLDB_INVALID_CPUTYPE)
         response.Printf ("cpusubtype:%u;", sub);
 
     if (cpu == ArchSpec::kCore_arm_any)
         response.Printf("watchpoint_exceptions_received:before;");   // On armv7 we use "synchronous" watchpoints which means the exception is delivered before the instruction executes.
     else
         response.Printf("watchpoint_exceptions_received:after;");
 #else
+    if (host_arch.GetMachine() == llvm::Triple::mips64 ||
+        host_arch.GetMachine() == llvm::Triple::mips64el)
+        response.Printf("watchpoint_exceptions_received:before;");
+    else
         response.Printf("watchpoint_exceptions_received:after;");
 #endif
 
     switch (lldb::endian::InlHostByteOrder())
     {
     case eByteOrderBig:     response.PutCString ("endian:big;"); break;
     case eByteOrderLittle:  response.PutCString ("endian:little;"); break;
     case eByteOrderPDP:     response.PutCString ("endian:pdp;"); break;
     default:                response.PutCString ("endian:unknown;"); break;