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

   1 //===-- RegisterContextPOSIXProcessMonitor_powerpc.cpp ----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Target/Thread.h"
  10 #include "lldb/Utility/DataBufferHeap.h"
  11 #include "lldb/Utility/RegisterValue.h"
  12
  13 #include "ProcessFreeBSD.h"
  14 #include "ProcessMonitor.h"
  15 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
  16 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
  17
  18 using namespace lldb_private;
  19 using namespace lldb;
  20
  21 #define REG_CONTEXT_SIZE (GetGPRSize())
  22
  23 RegisterContextPOSIXProcessMonitor_powerpc::
  24     RegisterContextPOSIXProcessMonitor_powerpc(
  25         Thread &thread, uint32_t concrete_frame_idx,
  26         lldb_private::RegisterInfoInterface *register_info)
  27     : RegisterContextPOSIX_powerpc(thread, concrete_frame_idx, register_info) {}
  28
  29 ProcessMonitor &RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor() {
  30   ProcessSP base = CalculateProcess();
  31   ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
  32   return process->GetMonitor();
  33 }
  34
  35 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR() {
  36   ProcessMonitor &monitor = GetMonitor();
  37   return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
  38 }
  39
  40 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR() {
  41   ProcessMonitor &monitor = GetMonitor();
  42   return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc,
  43                          sizeof(m_fpr_powerpc));
  44 }
  45
  46 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadVMX() {
  47   // XXX: Need a way to read/write process VMX registers with ptrace.
  48   return false;
  49 }
  50
  51 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR() {
  52   ProcessMonitor &monitor = GetMonitor();
  53   return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
  54 }
  55
  56 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR() {
  57   ProcessMonitor &monitor = GetMonitor();
  58   return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc,
  59                           sizeof(m_fpr_powerpc));
  60 }
  61
  62 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteVMX() {
  63   // XXX: Need a way to read/write process VMX registers with ptrace.
  64   return false;
  65 }
  66
  67 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
  68     const unsigned reg, RegisterValue &value) {
  69   ProcessMonitor &monitor = GetMonitor();
  70   return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
  71                                    GetRegisterName(reg), GetRegisterSize(reg),
  72                                    value);
  73 }
  74
  75 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
  76     const unsigned reg, const RegisterValue &value) {
  77   unsigned reg_to_write = reg;
  78   RegisterValue value_to_write = value;
  79
  80   // Check if this is a subregister of a full register.
  81   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
  82   if (reg_info->invalidate_regs &&
  83       (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
  84     RegisterValue full_value;
  85     uint32_t full_reg = reg_info->invalidate_regs[0];
  86     const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
  87
  88     // Read the full register.
  89     if (ReadRegister(full_reg_info, full_value)) {
  90       Status error;
  91       ByteOrder byte_order = GetByteOrder();
  92       uint8_t dst[RegisterValue::kMaxRegisterByteSize];
  93
  94       // Get the bytes for the full register.
  95       const uint32_t dest_size = full_value.GetAsMemoryData(
  96           full_reg_info, dst, sizeof(dst), byte_order, error);
  97       if (error.Success() && dest_size) {
  98         uint8_t src[RegisterValue::kMaxRegisterByteSize];
  99
 100         // Get the bytes for the source data.
 101         const uint32_t src_size = value.GetAsMemoryData(
 102             reg_info, src, sizeof(src), byte_order, error);
 103         if (error.Success() && src_size && (src_size < dest_size)) {
 104           // Copy the src bytes to the destination.
 105           memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
 106           // Set this full register as the value to write.
 107           value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
 108           value_to_write.SetType(full_reg_info);
 109           reg_to_write = full_reg;
 110         }
 111       }
 112     }
 113   }
 114
 115   ProcessMonitor &monitor = GetMonitor();
 116   // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
 117   // registers in ptrace, but expose here 32-bit registers with a higher
 118   // offset.
 119   uint64_t offset = GetRegisterOffset(reg_to_write);
 120   offset &= ~(sizeof(uintptr_t) - 1);
 121   return monitor.WriteRegisterValue(
 122       m_thread.GetID(), offset, GetRegisterName(reg_to_write), value_to_write);
 123 }
 124
 125 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
 126     const RegisterInfo *reg_info, RegisterValue &value) {
 127   if (!reg_info)
 128     return false;
 129
 130   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 131
 132   if (IsFPR(reg)) {
 133     if (!ReadFPR())
 134       return false;
 135     uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
 136     value.SetUInt64(*(uint64_t *)src);
 137   } else if (IsGPR(reg)) {
 138     bool success = ReadRegister(reg, value);
 139
 140     if (success) {
 141       // If our return byte size was greater than the return value reg size,
 142       // then use the type specified by reg_info rather than the uint64_t
 143       // default
 144       if (value.GetByteSize() > reg_info->byte_size)
 145         value.SetType(reg_info);
 146     }
 147     return success;
 148   }
 149
 150   return false;
 151 }
 152
 153 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
 154     const RegisterInfo *reg_info, const RegisterValue &value) {
 155   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 156
 157   if (IsGPR(reg)) {
 158     return WriteRegister(reg, value);
 159   } else if (IsFPR(reg)) {
 160     assert(reg_info->byte_offset < sizeof(m_fpr_powerpc));
 161     uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
 162     *(uint64_t *)dst = value.GetAsUInt64();
 163     return WriteFPR();
 164   }
 165
 166   return false;
 167 }
 168
 169 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(
 170     DataBufferSP &data_sp) {
 171   bool success = false;
 172   data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
 173   if (ReadGPR() && ReadFPR()) {
 174     uint8_t *dst = data_sp->GetBytes();
 175     success = dst != 0;
 176
 177     if (success) {
 178       ::memcpy(dst, &m_gpr_powerpc, GetGPRSize());
 179       dst += GetGPRSize();
 180     }
 181   }
 182   return success;
 183 }
 184
 185 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteAllRegisterValues(
 186     const DataBufferSP &data_sp) {
 187   bool success = false;
 188   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
 189     uint8_t *src = data_sp->GetBytes();
 190     if (src) {
 191       ::memcpy(&m_gpr_powerpc, src, GetGPRSize());
 192
 193       if (WriteGPR()) {
 194         src += GetGPRSize();
 195         ::memcpy(&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
 196
 197         success = WriteFPR();
 198       }
 199     }
 200   }
 201   return success;
 202 }
 203
 204 uint32_t RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(
 205     addr_t addr, size_t size, bool read, bool write) {
 206   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 207   uint32_t hw_index;
 208
 209   for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
 210     if (IsWatchpointVacant(hw_index))
 211       return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
 212   }
 213
 214   return LLDB_INVALID_INDEX32;
 215 }
 216
 217 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(
 218     uint32_t hw_index) {
 219   return false;
 220 }
 221
 222 bool RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(
 223     bool enable) {
 224   return false;
 225 }
 226
 227 bool RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint() {
 228   lldb::addr_t pc;
 229
 230   if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 231     return false;
 232
 233   return true;
 234 }
 235
 236 unsigned RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(
 237     unsigned offset) {
 238   unsigned reg;
 239   for (reg = 0; reg < k_num_registers_powerpc; reg++) {
 240     if (GetRegisterInfo()[reg].byte_offset == offset)
 241       break;
 242   }
 243   assert(reg < k_num_registers_powerpc && "Invalid register offset.");
 244   return reg;
 245 }
 246
 247 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(
 248     uint32_t hw_index) {
 249   return false;
 250 }
 251
 252 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits() {
 253   return false;
 254 }
 255
 256 addr_t RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(
 257     uint32_t hw_index) {
 258   return LLDB_INVALID_ADDRESS;
 259 }
 260
 261 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(
 262     uint32_t hw_index) {
 263   return false;
 264 }
 265
 266 bool RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(
 267     addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
 268   return false;
 269 }
 270
 271 uint32_t
 272 RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints() {
 273   return 0;
 274 }