Allow unaligned byte/word selection watchpoints for arm- linux/android targets.

[omjavaid]

Summary

We recently committed a patch for AArch64 targets that allows us to watch any byte address individually in a 8 byte aligned region.

This patch implements the same for arm targets with region being watched is a 4 byte region.

We cannot watch 8 consecutive bytes using a single watchpoint resource on Arm targets so maximum we can do is 4 bytes.

As a results TestWatchpointSize tests pass on arm targets which were previously failing.

[tberghammer]

Looks good

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.h

public:
 
         Error
         ClearAllHardwareWatchpoints () override;
 
         Error
         GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr) override;
 
         lldb::addr_t
+        GetWatchpointHitAddress (uint32_t wp_index) override;
+
+        lldb::addr_t
         GetWatchpointAddress (uint32_t wp_index) override;
 
         uint32_t
         GetWatchpointSize(uint32_t wp_index);
 
         bool
         WatchpointIsEnabled(uint32_t wp_index);
 
private:
         uint32_t m_gpr_arm[k_num_gpr_registers_arm];
         RegInfo  m_reg_info;
         FPU m_fpr; 
 
         // Debug register info for hardware breakpoints and watchpoints management.
         struct DREG
         {
             lldb::addr_t address;  // Breakpoint/watchpoint address value.
+            lldb::addr_t hit_addr; // Address at which last watchpoint trigger exception occurred.
+            lldb::addr_t real_addr;  // Address value that should cause target to stop.
             uint32_t control;  // Breakpoint/watchpoint control value.
             uint32_t refcount;  // Serves as enable/disable and refernce counter.
         };
 
         struct DREG m_hbr_regs[16];  // Arm native linux hardware breakpoints
         struct DREG m_hwp_regs[16];  // Arm native linux hardware watchpoints
 
         uint32_t m_max_hwp_supported;

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

NativeRegisterContextLinux_arm::SetHardwareWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags)
 
     // Read hardware breakpoint and watchpoint information.
     error = ReadHardwareDebugInfo ();
 
     if (error.Fail())
         return LLDB_INVALID_INDEX32;
     
     uint32_t control_value = 0, wp_index = 0, addr_word_offset = 0, byte_mask = 0;
+    lldb::addr_t real_addr = addr;
 
     // Check if we are setting watchpoint other than read/write/access
     // Also update watchpoint flag to match Arm write-read bit configuration.
     switch (watch_flags)
     {
         case 1:
             watch_flags = 2;
             break;
         case 2:
             watch_flags = 1;
             break;
         case 3:
             break;
         default:
             return LLDB_INVALID_INDEX32;
     }
 
     // Can't watch zero bytes
     // Can't watch more than 4 bytes per WVR/WCR pair
 
     if (size == 0 || size > 4)
         return LLDB_INVALID_INDEX32;
 
-    // We can only watch up to four bytes that follow a 4 byte aligned address
+    // Check 4-byte alignment for hardware watchpoint target address.
+    // Below is a hack to recalculate address and size in order to
+    // make sure we can watch non 4-byte alligned addresses as well.
+    if (addr & 0x03)
+    {
+        uint8_t watch_mask = (addr & 0x03) + size;
+
+        if (watch_mask > 0x04)
+            return LLDB_INVALID_INDEX32;
+        else if (watch_mask <= 0x02)
+            size = 2;
+        else if (watch_mask <= 0x04)
+            size = 4;
+
+        addr = addr & (~0x03);
+    }
+
+  // We can only watch up to four bytes that follow a 4 byte aligned address
     // per watchpoint register pair, so make sure we can properly encode this.
     addr_word_offset = addr % 4;
     byte_mask = ((1u << size) - 1u) << addr_word_offset;
 
     // Check if we need multiple watchpoint register
     if (byte_mask > 0xfu)
         return LLDB_INVALID_INDEX32;
 
// We can only watch up to four bytes that follow a 4 byte aligned address
 
      if (wp_index == LLDB_INVALID_INDEX32)
         return LLDB_INVALID_INDEX32;
 
     // Add new or update existing watchpoint
     if ((m_hwp_regs[wp_index].control & 1) == 0)
     {
         // Update watchpoint in local cache
+        m_hwp_regs[wp_index].real_addr = real_addr;
         m_hwp_regs[wp_index].address = addr;
         m_hwp_regs[wp_index].control = control_value;
         m_hwp_regs[wp_index].refcount = 1;
 
         // PTRACE call to set corresponding watchpoint register.
         error = WriteHardwareDebugRegs(eDREGTypeWATCH, wp_index);
 
         if (error.Fail())
NativeRegisterContextLinux_arm::GetWatchpointHitIndex(uint32_t &wp_index, lldb::addr_t trap_addr)
     for (wp_index = 0; wp_index < m_max_hwp_supported; ++wp_index)
     {
         watch_size = GetWatchpointSize (wp_index);
         watch_addr = m_hwp_regs[wp_index].address;
 
         if (m_hwp_regs[wp_index].refcount >= 1 && WatchpointIsEnabled(wp_index)
             && trap_addr >= watch_addr && trap_addr < watch_addr + watch_size)
         {
+            m_hwp_regs[wp_index].hit_addr = trap_addr;
             return Error();
         }
     }
 
     wp_index = LLDB_INVALID_INDEX32;
     return Error();
 }
 
 lldb::addr_t
 NativeRegisterContextLinux_arm::GetWatchpointAddress (uint32_t wp_index)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
 
     if (log)
         log->Printf ("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
 
     if (wp_index >= m_max_hwp_supported)
         return LLDB_INVALID_ADDRESS;
 
     if (WatchpointIsEnabled(wp_index))
-        return m_hwp_regs[wp_index].address;
+        return m_hwp_regs[wp_index].real_addr;
+    else
+        return LLDB_INVALID_ADDRESS;
+}
+
+lldb::addr_t
+NativeRegisterContextLinux_arm::GetWatchpointHitAddress (uint32_t wp_index)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
+
+    if (log)
+        log->Printf ("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
+
+    if (wp_index >= m_max_hwp_supported)
+        return LLDB_INVALID_ADDRESS;
+
+    if (WatchpointIsEnabled(wp_index))
+        return m_hwp_regs[wp_index].hit_addr;
     else
         return LLDB_INVALID_ADDRESS;
 }
 
 Error
 NativeRegisterContextLinux_arm::ReadHardwareDebugInfo()
 {
     Error error;

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

if (tid != LLDB_INVALID_THREAD_ID)
                             uint32_t wp_index = desc_extractor.GetU32(LLDB_INVALID_INDEX32);
                             addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
                             watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
                             if (wp_addr != LLDB_INVALID_ADDRESS)
                             {
                                 WatchpointSP wp_sp;
                                 ArchSpec::Core core = GetTarget().GetArchitecture().GetCore();
                                 if ((core >= ArchSpec::kCore_mips_first && core <= ArchSpec::kCore_mips_last) ||
-                                    (core >= ArchSpec::eCore_arm_arm64 && core <= ArchSpec::eCore_arm_aarch64))
+                                    (core >= ArchSpec::eCore_arm_generic && core <= ArchSpec::eCore_arm_aarch64))
                                     wp_sp = GetTarget().GetWatchpointList().FindByAddress(wp_hit_addr);
                                 if (!wp_sp)
                                     wp_sp = GetTarget().GetWatchpointList().FindByAddress(wp_addr);
                                 if (wp_sp)
                                 {
                                     wp_sp->SetHardwareIndex(wp_index);
                                     watch_id = wp_sp->GetID();
                                 }