source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp

   1 //===-- RegisterContextPOSIXProcessMonitor_mips64.h ------------*- 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_mips64.h"
  15 #include "ProcessFreeBSD.h"
  16 #include "ProcessMonitor.h"
  17 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
  18
  19 using namespace lldb_private;
  20 using namespace lldb;
  21
  22 #define REG_CONTEXT_SIZE (GetGPRSize())
  23
  24 RegisterContextPOSIXProcessMonitor_mips64::RegisterContextPOSIXProcessMonitor_mips64(Thread &thread,
  25                                                                                      uint32_t concrete_frame_idx,
  26                                                                                      lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_mips64(thread, concrete_frame_idx, register_info)
  28 {
  29 }
  30
  31 ProcessMonitor &
  32 RegisterContextPOSIXProcessMonitor_mips64::GetMonitor()
  33 {
  34     ProcessSP base = CalculateProcess();
  35     ProcessFreeBSD *process = static_cast<ProcessFreeBSD*>(base.get());
  36     return process->GetMonitor();
  37 }
  38
  39 bool
  40 RegisterContextPOSIXProcessMonitor_mips64::ReadGPR()
  41 {
  42      ProcessMonitor &monitor = GetMonitor();
  43      return monitor.ReadGPR(m_thread.GetID(), &m_gpr_mips64, GetGPRSize());
  44 }
  45
  46 bool
  47 RegisterContextPOSIXProcessMonitor_mips64::ReadFPR()
  48 {
  49     // XXX not yet implemented
  50     return false;
  51 }
  52
  53 bool
  54 RegisterContextPOSIXProcessMonitor_mips64::WriteGPR()
  55 {
  56     ProcessMonitor &monitor = GetMonitor();
  57     return monitor.WriteGPR(m_thread.GetID(), &m_gpr_mips64, GetGPRSize());
  58 }
  59
  60 bool
  61 RegisterContextPOSIXProcessMonitor_mips64::WriteFPR()
  62 {
  63     // XXX not yet implemented
  64     return false;
  65 }
  66
  67 bool
  68 RegisterContextPOSIXProcessMonitor_mips64::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_mips64::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_mips64::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         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
 157         bool success = ReadRegister(full_reg, value);
 158
 159         if (success)
 160         {
 161             // If our read was not aligned (for ah,bh,ch,dh), shift our returned value one byte to the right.
 162             if (is_subreg && (reg_info->byte_offset & 0x1))
 163                 value.SetUInt64(value.GetAsUInt64() >> 8);
 164
 165             // If our return byte size was greater than the return value reg size, then
 166             // use the type specified by reg_info rather than the uint64_t default
 167             if (value.GetByteSize() > reg_info->byte_size)
 168                 value.SetType(reg_info);
 169         }
 170         return success;
 171     }
 172
 173     return false;
 174 }
 175
 176 bool
 177 RegisterContextPOSIXProcessMonitor_mips64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value)
 178 {
 179     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 180
 181     if (IsGPR(reg))
 182         return WriteRegister(reg, value);
 183
 184     return false;
 185 }
 186
 187 bool
 188 RegisterContextPOSIXProcessMonitor_mips64::ReadAllRegisterValues(DataBufferSP &data_sp)
 189 {
 190     bool success = false;
 191     data_sp.reset (new DataBufferHeap (REG_CONTEXT_SIZE, 0));
 192     if (data_sp && ReadGPR () && ReadFPR ())
 193     {
 194         uint8_t *dst = data_sp->GetBytes();
 195         success = dst != 0;
 196
 197         if (success)
 198         {
 199             ::memcpy (dst, &m_gpr_mips64, GetGPRSize());
 200         }
 201     }
 202     return success;
 203 }
 204
 205 bool
 206 RegisterContextPOSIXProcessMonitor_mips64::WriteAllRegisterValues(const DataBufferSP &data_sp)
 207 {
 208     bool success = false;
 209     if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE)
 210     {
 211         uint8_t *src = data_sp->GetBytes();
 212         if (src)
 213         {
 214             ::memcpy (&m_gpr_mips64, src, GetGPRSize());
 215
 216             if (WriteGPR())
 217             {
 218                 src += GetGPRSize();
 219             }
 220         }
 221     }
 222     return success;
 223 }
 224
 225 uint32_t
 226 RegisterContextPOSIXProcessMonitor_mips64::SetHardwareWatchpoint(addr_t addr, size_t size,
 227                                               bool read, bool write)
 228 {
 229     const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 230     uint32_t hw_index;
 231
 232     for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index)
 233     {
 234         if (IsWatchpointVacant(hw_index))
 235             return SetHardwareWatchpointWithIndex(addr, size,
 236                                                   read, write,
 237                                                   hw_index);
 238     }
 239
 240     return LLDB_INVALID_INDEX32;
 241 }
 242
 243 bool
 244 RegisterContextPOSIXProcessMonitor_mips64::ClearHardwareWatchpoint(uint32_t hw_index)
 245 {
 246     return false;
 247 }
 248
 249 bool
 250 RegisterContextPOSIXProcessMonitor_mips64::HardwareSingleStep(bool enable)
 251 {
 252     return false;
 253 }
 254
 255 bool
 256 RegisterContextPOSIXProcessMonitor_mips64::UpdateAfterBreakpoint()
 257 {
 258     // PC points one byte past the int3 responsible for the breakpoint.
 259     lldb::addr_t pc;
 260
 261     if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 262         return false;
 263
 264     SetPC(pc - 1);
 265     return true;
 266 }
 267
 268 unsigned
 269 RegisterContextPOSIXProcessMonitor_mips64::GetRegisterIndexFromOffset(unsigned offset)
 270 {
 271     unsigned reg;
 272     for (reg = 0; reg < k_num_registers_mips64; reg++)
 273     {
 274         if (GetRegisterInfo()[reg].byte_offset == offset)
 275             break;
 276     }
 277     assert(reg < k_num_registers_mips64 && "Invalid register offset.");
 278     return reg;
 279 }
 280
 281 bool
 282 RegisterContextPOSIXProcessMonitor_mips64::IsWatchpointHit(uint32_t hw_index)
 283 {
 284     return false;
 285 }
 286
 287 bool
 288 RegisterContextPOSIXProcessMonitor_mips64::ClearWatchpointHits()
 289 {
 290     return false;
 291 }
 292
 293 addr_t
 294 RegisterContextPOSIXProcessMonitor_mips64::GetWatchpointAddress(uint32_t hw_index)
 295 {
 296     return LLDB_INVALID_ADDRESS;
 297 }
 298
 299 bool
 300 RegisterContextPOSIXProcessMonitor_mips64::IsWatchpointVacant(uint32_t hw_index)
 301 {
 302     return false;
 303 }
 304
 305 bool
 306 RegisterContextPOSIXProcessMonitor_mips64::SetHardwareWatchpointWithIndex(addr_t addr, size_t size,
 307                                                        bool read, bool write,
 308                                                        uint32_t hw_index)
 309 {
 310     return false;
 311 }
 312
 313 uint32_t
 314 RegisterContextPOSIXProcessMonitor_mips64::NumSupportedHardwareWatchpoints()
 315 {
 316     return 0;
 317 }
 318