contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp

   1 //===-- RegisterContextPOSIXProcessMonitor_arm64.cpp -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===---------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/DataBufferHeap.h"
  11 #include "lldb/Core/RegisterValue.h"
  12 #include "lldb/Target/Thread.h"
  13
  14 #include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
  15 #include "ProcessFreeBSD.h"
  16 #include "ProcessMonitor.h"
  17 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
  18
  19 #define REG_CONTEXT_SIZE (GetGPRSize())
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 RegisterContextPOSIXProcessMonitor_arm64::RegisterContextPOSIXProcessMonitor_arm64(lldb_private::Thread &thread,
  25                                                                                    uint32_t concrete_frame_idx,
  26                                                                                    lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_arm64(thread, concrete_frame_idx, register_info)
  28 {
  29 }
  30
  31 ProcessMonitor &
  32 RegisterContextPOSIXProcessMonitor_arm64::GetMonitor()
  33 {
  34     lldb::ProcessSP base = CalculateProcess();
  35     ProcessFreeBSD *process = static_cast<ProcessFreeBSD*>(base.get());
  36     return process->GetMonitor();
  37 }
  38
  39 bool
  40 RegisterContextPOSIXProcessMonitor_arm64::ReadGPR()
  41 {
  42      ProcessMonitor &monitor = GetMonitor();
  43      return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
  44 }
  45
  46 bool
  47 RegisterContextPOSIXProcessMonitor_arm64::ReadFPR()
  48 {
  49     ProcessMonitor &monitor = GetMonitor();
  50     return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
  51 }
  52
  53 bool
  54 RegisterContextPOSIXProcessMonitor_arm64::WriteGPR()
  55 {
  56     ProcessMonitor &monitor = GetMonitor();
  57     return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
  58 }
  59
  60 bool
  61 RegisterContextPOSIXProcessMonitor_arm64::WriteFPR()
  62 {
  63     ProcessMonitor &monitor = GetMonitor();
  64     return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
  65 }
  66
  67 bool
  68 RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(const unsigned reg,
  69                                                        lldb_private::RegisterValue &value)
  70 {
  71     ProcessMonitor &monitor = GetMonitor();
  72     return monitor.ReadRegisterValue(m_thread.GetID(),
  73                                      GetRegisterOffset(reg),
  74                                      GetRegisterName(reg),
  75                                      GetRegisterSize(reg),
  76                                      value);
  77 }
  78
  79 bool
  80 RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(const unsigned reg,
  81                                                          const lldb_private::RegisterValue &value)
  82 {
  83     unsigned reg_to_write = reg;
  84     lldb_private::RegisterValue value_to_write = value;
  85
  86     // Check if this is a subregister of a full register.
  87     const lldb_private::RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
  88     if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
  89     {
  90         lldb_private::RegisterValue full_value;
  91         uint32_t full_reg = reg_info->invalidate_regs[0];
  92         const lldb_private::RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
  93
  94         // Read the full register.
  95         if (ReadRegister(full_reg_info, full_value))
  96         {
  97             lldb_private::Error error;
  98             lldb::ByteOrder byte_order = GetByteOrder();
  99             uint8_t dst[lldb_private::RegisterValue::kMaxRegisterByteSize];
 100
 101             // Get the bytes for the full register.
 102             const uint32_t dest_size = full_value.GetAsMemoryData (full_reg_info,
 103                                                                    dst,
 104                                                                    sizeof(dst),
 105                                                                    byte_order,
 106                                                                    error);
 107             if (error.Success() && dest_size)
 108             {
 109                 uint8_t src[lldb_private::RegisterValue::kMaxRegisterByteSize];
 110
 111                 // Get the bytes for the source data.
 112                 const uint32_t src_size = value.GetAsMemoryData (reg_info, src, sizeof(src), byte_order, error);
 113                 if (error.Success() && src_size && (src_size < dest_size))
 114                 {
 115                     // Copy the src bytes to the destination.
 116                     ::memcpy (dst + (reg_info->byte_offset & 0x1), src, src_size);
 117                     // Set this full register as the value to write.
 118                     value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
 119                     value_to_write.SetType(full_reg_info);
 120                     reg_to_write = full_reg;
 121                 }
 122             }
 123         }
 124     }
 125
 126     ProcessMonitor &monitor = GetMonitor();
 127     return monitor.WriteRegisterValue(m_thread.GetID(),
 128                                       GetRegisterOffset(reg_to_write),
 129                                       GetRegisterName(reg_to_write),
 130                                       value_to_write);
 131 }
 132
 133 bool
 134 RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(const lldb_private::RegisterInfo *reg_info, lldb_private::RegisterValue &value)
 135 {
 136     if (!reg_info)
 137         return false;
 138
 139     const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 140
 141     if (IsFPR(reg))
 142     {
 143         if (!ReadFPR())
 144             return false;
 145     }
 146     else
 147     {
 148         uint32_t full_reg = reg;
 149         bool is_subreg = reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
 150
 151         if (is_subreg)
 152         {
 153             // Read the full aligned 64-bit register.
 154             full_reg = reg_info->invalidate_regs[0];
 155         }
 156         return ReadRegister(full_reg, value);
 157     }
 158
 159     // Get pointer to m_fpr variable and set the data from it.
 160     assert (reg_info->byte_offset < sizeof m_fpr);
 161     uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
 162     switch (reg_info->byte_size)
 163     {
 164         case 2:
 165             value.SetUInt16(*(uint16_t *)src);
 166             return true;
 167         case 4:
 168             value.SetUInt32(*(uint32_t *)src);
 169             return true;
 170         case 8:
 171             value.SetUInt64(*(uint64_t *)src);
 172             return true;
 173         default:
 174             assert(false && "Unhandled data size.");
 175             return false;
 176     }
 177 }
 178
 179 bool
 180 RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value)
 181 {
 182     const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 183
 184     if (IsGPR(reg))
 185         return WriteRegister(reg, value);
 186
 187     return false;
 188 }
 189
 190 bool
 191 RegisterContextPOSIXProcessMonitor_arm64::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
 192 {
 193     bool success = false;
 194     data_sp.reset (new lldb_private::DataBufferHeap (REG_CONTEXT_SIZE, 0));
 195     if (data_sp && ReadGPR () && ReadFPR ())
 196     {
 197         uint8_t *dst = data_sp->GetBytes();
 198         success = dst != 0;
 199
 200         if (success)
 201         {
 202             ::memcpy (dst, &m_gpr_arm64, GetGPRSize());
 203             dst += GetGPRSize();
 204             ::memcpy (dst, &m_fpr, sizeof m_fpr);
 205         }
 206     }
 207     return success;
 208 }
 209
 210 bool
 211 RegisterContextPOSIXProcessMonitor_arm64::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
 212 {
 213     bool success = false;
 214     if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
 215     {
 216         uint8_t *src = data_sp->GetBytes();
 217         if (src)
 218         {
 219             ::memcpy (&m_gpr_arm64, src, GetGPRSize());
 220             if (WriteGPR()) {
 221                 src += GetGPRSize();
 222                 ::memcpy (&m_fpr, src, sizeof m_fpr);
 223                 success = WriteFPR();
 224             }
 225         }
 226     }
 227     return success;
 228 }
 229
 230 uint32_t
 231 RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
 232                                                                 bool read, bool write)
 233 {
 234     const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 235     uint32_t hw_index;
 236
 237     for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
 238     {
 239         if (IsWatchpointVacant(hw_index))
 240             return SetHardwareWatchpointWithIndex(addr, size,
 241                                                   read, write,
 242                                                   hw_index);
 243     }
 244
 245     return LLDB_INVALID_INDEX32;
 246 }
 247
 248 bool
 249 RegisterContextPOSIXProcessMonitor_arm64::ClearHardwareWatchpoint(uint32_t hw_index)
 250 {
 251     return false;
 252 }
 253
 254 bool
 255 RegisterContextPOSIXProcessMonitor_arm64::HardwareSingleStep(bool enable)
 256 {
 257     return false;
 258 }
 259
 260 bool
 261 RegisterContextPOSIXProcessMonitor_arm64::UpdateAfterBreakpoint()
 262 {
 263     if (GetPC() == LLDB_INVALID_ADDRESS)
 264         return false;
 265
 266     return true;
 267 }
 268
 269 unsigned
 270 RegisterContextPOSIXProcessMonitor_arm64::GetRegisterIndexFromOffset(unsigned offset)
 271 {
 272     unsigned reg;
 273     for (reg = 0; reg < k_num_registers_arm64; reg++)
 274     {
 275         if (GetRegisterInfo()[reg].byte_offset == offset)
 276             break;
 277     }
 278     assert(reg < k_num_registers_arm64 && "Invalid register offset.");
 279     return reg;
 280 }
 281
 282 bool
 283 RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointHit(uint32_t hw_index)
 284 {
 285     return false;
 286 }
 287
 288 bool
 289 RegisterContextPOSIXProcessMonitor_arm64::ClearWatchpointHits()
 290 {
 291     return false;
 292 }
 293
 294 lldb::addr_t
 295 RegisterContextPOSIXProcessMonitor_arm64::GetWatchpointAddress(uint32_t hw_index)
 296 {
 297     return LLDB_INVALID_ADDRESS;
 298 }
 299
 300 bool
 301 RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointVacant(uint32_t hw_index)
 302 {
 303     return false;
 304 }
 305
 306 bool
 307 RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size,
 308                                                                          bool read, bool write,
 309                                                                          uint32_t hw_index)
 310 {
 311     return false;
 312 }
 313
 314 uint32_t
 315 RegisterContextPOSIXProcessMonitor_arm64::NumSupportedHardwareWatchpoints()
 316 {
 317     return 0;
 318 }