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

   1 //===-- RegisterContextPOSIXProcessMonitor_arm.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_arm.h"
  15 #include "ProcessPOSIX.h"
  16 #include "RegisterContextPOSIXProcessMonitor_arm.h"
  17 #include "ProcessMonitor.h"
  18
  19 using namespace lldb_private;
  20 using namespace lldb;
  21
  22 #define REG_CONTEXT_SIZE (GetGPRSize())
  23
  24 RegisterContextPOSIXProcessMonitor_arm::RegisterContextPOSIXProcessMonitor_arm(Thread &thread,
  25                                                                                      uint32_t concrete_frame_idx,
  26                                                                                      lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_arm(thread, concrete_frame_idx, register_info)
  28 {
  29 }
  30
  31 ProcessMonitor &
  32 RegisterContextPOSIXProcessMonitor_arm::GetMonitor()
  33 {
  34     ProcessSP base = CalculateProcess();
  35     ProcessPOSIX *process = static_cast<ProcessPOSIX*>(base.get());
  36     return process->GetMonitor();
  37 }
  38
  39 bool
  40 RegisterContextPOSIXProcessMonitor_arm::ReadGPR()
  41 {
  42      ProcessMonitor &monitor = GetMonitor();
  43      return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
  44 }
  45
  46 bool
  47 RegisterContextPOSIXProcessMonitor_arm::ReadFPR()
  48 {
  49     ProcessMonitor &monitor = GetMonitor();
  50     return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
  51 }
  52
  53 bool
  54 RegisterContextPOSIXProcessMonitor_arm::WriteGPR()
  55 {
  56     ProcessMonitor &monitor = GetMonitor();
  57     return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
  58 }
  59
  60 bool
  61 RegisterContextPOSIXProcessMonitor_arm::WriteFPR()
  62 {
  63     ProcessMonitor &monitor = GetMonitor();
  64     return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
  65 }
  66
  67 bool
  68 RegisterContextPOSIXProcessMonitor_arm::ReadRegister(const unsigned reg,
  69                                                        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_arm::WriteRegister(const unsigned reg,
  81                                                          const RegisterValue &value)
  82 {
  83     unsigned reg_to_write = reg;
  84     RegisterValue value_to_write = value;
  85
  86     // Check if this is a subregister of a full register.
  87     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
  88     if (reg_info->invalidate_regs && (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM))
  89     {
  90         RegisterValue full_value;
  91         uint32_t full_reg = reg_info->invalidate_regs[0];
  92         const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
  93
  94         // Read the full register.
  95         if (ReadRegister(full_reg_info, full_value))
  96         {
  97             Error error;
  98             ByteOrder byte_order = GetByteOrder();
  99             uint8_t dst[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[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_arm::ReadRegister(const RegisterInfo *reg_info, RegisterValue &value)
 135 {
 136     if (!reg_info)
 137         return false;
 138
 139     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 140
 141     if (IsFPR(reg))
 142     {
 143         if (!ReadFPR())
 144             return false;
 145     }
 146     else
 147     {
 148         return ReadRegister(reg, value);
 149     }
 150
 151     // Get pointer to m_fpr variable and set the data from it.
 152     assert (reg_info->byte_offset < sizeof m_fpr);
 153     uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
 154     switch (reg_info->byte_size)
 155     {
 156         case 2:
 157             value.SetUInt16(*(uint16_t *)src);
 158             return true;
 159         case 4:
 160             value.SetUInt32(*(uint32_t *)src);
 161             return true;
 162         case 8:
 163             value.SetUInt64(*(uint64_t *)src);
 164             return true;
 165         default:
 166             assert(false && "Unhandled data size.");
 167             return false;
 168     }
 169 }
 170
 171 bool
 172 RegisterContextPOSIXProcessMonitor_arm::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value)
 173 {
 174     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 175
 176     if (IsGPR(reg))
 177     {
 178         return WriteRegister(reg, value);
 179     }
 180     else if (IsFPR(reg))
 181     {
 182         return WriteFPR();
 183     }
 184
 185     return false;
 186 }
 187
 188 bool
 189 RegisterContextPOSIXProcessMonitor_arm::ReadAllRegisterValues(DataBufferSP &data_sp)
 190 {
 191     bool success = false;
 192     data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
 193     if (data_sp && ReadGPR () && ReadFPR ())
 194     {
 195         uint8_t *dst = data_sp->GetBytes();
 196         success = dst != 0;
 197
 198         if (success)
 199         {
 200             ::memcpy (dst, &m_gpr_arm, GetGPRSize());
 201             dst += GetGPRSize();
 202             ::memcpy (dst, &m_fpr, sizeof(m_fpr));
 203         }
 204     }
 205     return success;
 206 }
 207
 208 bool
 209 RegisterContextPOSIXProcessMonitor_arm::WriteAllRegisterValues(const DataBufferSP &data_sp)
 210 {
 211     bool success = false;
 212     if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
 213     {
 214         uint8_t *src = data_sp->GetBytes();
 215         if (src)
 216         {
 217             ::memcpy (&m_gpr_arm, src, GetGPRSize());
 218
 219             if (WriteGPR())
 220             {
 221                 src += GetGPRSize();
 222                 ::memcpy (&m_fpr, src, sizeof(m_fpr));
 223
 224                 success = WriteFPR();
 225             }
 226         }
 227     }
 228     return success;
 229 }
 230
 231 uint32_t
 232 RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpoint(addr_t addr, size_t size,
 233                                                                 bool read, bool write)
 234 {
 235     const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 236     uint32_t hw_index;
 237
 238     for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
 239     {
 240         if (IsWatchpointVacant(hw_index))
 241             return SetHardwareWatchpointWithIndex(addr, size,
 242                                                   read, write,
 243                                                   hw_index);
 244     }
 245
 246     return LLDB_INVALID_INDEX32;
 247 }
 248
 249 bool
 250 RegisterContextPOSIXProcessMonitor_arm::ClearHardwareWatchpoint(uint32_t hw_index)
 251 {
 252     return false;
 253 }
 254
 255 bool
 256 RegisterContextPOSIXProcessMonitor_arm::HardwareSingleStep(bool enable)
 257 {
 258     return false;
 259 }
 260
 261 bool
 262 RegisterContextPOSIXProcessMonitor_arm::UpdateAfterBreakpoint()
 263 {
 264     lldb::addr_t pc;
 265
 266     if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 267         return false;
 268
 269     return true;
 270 }
 271
 272 unsigned
 273 RegisterContextPOSIXProcessMonitor_arm::GetRegisterIndexFromOffset(unsigned offset)
 274 {
 275     unsigned reg;
 276     for (reg = 0; reg < k_num_registers_arm; reg++)
 277     {
 278         if (GetRegisterInfo()[reg].byte_offset == offset)
 279             break;
 280     }
 281     assert(reg < k_num_registers_arm && "Invalid register offset.");
 282     return reg;
 283 }
 284
 285 bool
 286 RegisterContextPOSIXProcessMonitor_arm::IsWatchpointHit(uint32_t hw_index)
 287 {
 288     return false;
 289 }
 290
 291 bool
 292 RegisterContextPOSIXProcessMonitor_arm::ClearWatchpointHits()
 293 {
 294     return false;
 295 }
 296
 297 addr_t
 298 RegisterContextPOSIXProcessMonitor_arm::GetWatchpointAddress(uint32_t hw_index)
 299 {
 300     return LLDB_INVALID_ADDRESS;
 301 }
 302
 303 bool
 304 RegisterContextPOSIXProcessMonitor_arm::IsWatchpointVacant(uint32_t hw_index)
 305 {
 306     return false;
 307 }
 308
 309 bool
 310 RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpointWithIndex(addr_t addr, size_t size,
 311                                                                          bool read, bool write,
 312                                                                          uint32_t hw_index)
 313 {
 314     return false;
 315 }
 316
 317 uint32_t
 318 RegisterContextPOSIXProcessMonitor_arm::NumSupportedHardwareWatchpoints()
 319 {
 320     return 0;
 321 }
 322