[LLDB][MIPS] Provide actual number of watchpoints supported

[mohit.bhakkad]

Summary

In MIPS, hardware registers for hardware watchpoints and hardware breakpoints are in same set named watch registers.
So adding another function to distinguish between no. of watch registers and actual number of registers which can be used for hardware watchpoints.

[Eugene.Zelenko]

Looks like patch was not committed. Please rebase with trunk and run Clang-format.

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

public:
                 uint32_t watch_flags) override;
 
         lldb::addr_t
         GetWatchpointAddress (uint32_t wp_index) override;
 
         uint32_t
         NumSupportedHardwareWatchpoints () override;
 
+        uint32_t
+        NumHardwareWatchRegisters ();
+
     protected:
         Error
         DoReadRegisterValue(uint32_t offset,
                             const char* reg_name,
                             uint32_t size,
                             RegisterValue &value) override;
 
         Error

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 #define PTRACE_SET_WATCH_REGS 0xd1
 #endif
 
 #define W (1 << 0)
 #define R (1 << 1)
 #define I (1 << 2)
 
 #define IRW  (I | R | W)
+#define RW   (R | W)
 
 struct pt_watch_regs default_watch_regs;
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------
 // Private namespace.
NativeRegisterContextLinux_mips64::IsMSAAvailable()
     }
 
     return false;
 }
 
 Error
 NativeRegisterContextLinux_mips64::IsWatchpointHit (uint32_t wp_index, bool &is_hit)
 {
-    if (wp_index >= NumSupportedHardwareWatchpoints())
+    if (wp_index >= NumHardwareWatchRegisters())
         return Error("Watchpoint index out of range");
 
     // reading the current state of watch regs
     struct pt_watch_regs watch_readback;
     Error error =  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)));
         DoWriteWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&watch_readback));
      
         is_hit = true;
         return error;
     }
     is_hit = false;
     return error;
 }
 
 Error
 NativeRegisterContextLinux_mips64::GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr) {
-    uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
+    uint32_t num_hw_wps = NumHardwareWatchRegisters();
     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)
 {
-    if (wp_index >= NumSupportedHardwareWatchpoints())
+    if (wp_index >= NumHardwareWatchRegisters())
         return false;
 
     struct pt_watch_regs regs;
     // First reading the current state of watch regs
     DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void*>(&regs));
 
     if (regs.style == pt_watch_style_mips32)
     {
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
     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());
+    int index = GetVacantWatchIndex (&regs, addr, size, watch_flags, NumHardwareWatchRegisters());
 
     // New watchpoint doesn't fit
     if (index == LLDB_INVALID_INDEX32)
     return LLDB_INVALID_INDEX32;
 
 
     // It fits, so we go ahead with updating the state of watch regs 
     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)
 {
-    if (wp_index >= NumSupportedHardwareWatchpoints())
+    if (wp_index >= NumHardwareWatchRegisters())
         return LLDB_INVALID_ADDRESS;
 
     return hw_addr_map[wp_index];
 }
 
 struct EmulatorBaton
 {
     lldb::addr_t m_watch_hit_addr;

  * on this address. Emulate instruction at PC and find the base address of
  * the load/store instruction. This will give the exact address used to
  * read/write the variable. Send this exact address to client so that
  * it can decide to stop or continue the thread.
 */
 lldb::addr_t
 NativeRegisterContextLinux_mips64::GetWatchpointHitAddress (uint32_t wp_index)
 {
-    if (wp_index >= NumSupportedHardwareWatchpoints())
+    if (wp_index >= NumHardwareWatchRegisters())
         return LLDB_INVALID_ADDRESS;
 
     lldb_private::ArchSpec arch;
     arch = GetRegisterInfoInterface().GetTargetArchitecture();
     std::unique_ptr<EmulateInstruction> emulator_ap(
         EmulateInstruction::FindPlugin(arch, lldb_private::eInstructionTypeAny, nullptr));
 
     if (emulator_ap == nullptr)
NativeRegisterContextLinux_mips64::GetWatchpointHitAddress (uint32_t wp_index)
 
     if (emulator_ap->EvaluateInstruction(lldb::eEmulateInstructionOptionNone))
         return baton.m_watch_hit_addr;
 
     return LLDB_INVALID_ADDRESS;
 }
 
 uint32_t
+NativeRegisterContextLinux_mips64::NumHardwareWatchRegisters ()
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+    struct pt_watch_regs regs;
+    static int num_valid = 0;
+    if (!num_valid)
+    {
+        DoReadWatchPointRegisterValue(m_thread.GetID(), static_cast<void *>(&regs));
+        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:
+                if(log)
+                    log->Printf("NativeRegisterContextLinux_mips64::%s Error: Unrecognized watch register style", __FUNCTION__);
+        }
+        return 0;
+    }
+    return num_valid;
+}
+
+uint32_t
 NativeRegisterContextLinux_mips64::NumSupportedHardwareWatchpoints ()
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
     struct pt_watch_regs regs;
     static int num_valid = 0;
     if (!num_valid)
     {
         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
+                for (int index = 0; index < num_valid; index++)
+                {
+                    if ((regs.mips32.watch_masks[index] & RW)== 0) // check last 2 bits of mask(read, write)  
+                        num_valid--;
+                }
                 return num_valid;
             case pt_watch_style_mips64:
                 num_valid = regs.mips64.num_valid;
+                for (int index = 0; index < num_valid; index++)
+                {
+                    if ((regs.mips64.watch_masks[index] & RW) == 0)
+                        num_valid--;
+                }
                 return num_valid;
             default:
                 if(log)
                     log->Printf("NativeRegisterContextLinux_mips64::%s Error: Unrecognized watch register style", __FUNCTION__);
         }
         return 0;
     }
     return num_valid;