1 //===-- RegisterContextPOSIXProcessMonitor_powerpc.cpp ----------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/RegisterValue.h"
11 #include "lldb/Target/Thread.h"
12 #include "lldb/Utility/DataBufferHeap.h"
14 #include "ProcessFreeBSD.h"
15 #include "ProcessMonitor.h"
16 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
17 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
19 using namespace lldb_private;
22 #define REG_CONTEXT_SIZE (GetGPRSize())
24 RegisterContextPOSIXProcessMonitor_powerpc::
25 RegisterContextPOSIXProcessMonitor_powerpc(
26 Thread &thread, uint32_t concrete_frame_idx,
27 lldb_private::RegisterInfoInterface *register_info)
28 : RegisterContextPOSIX_powerpc(thread, concrete_frame_idx, register_info) {}
30 ProcessMonitor &RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor() {
31 ProcessSP base = CalculateProcess();
32 ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
33 return process->GetMonitor();
36 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR() {
37 ProcessMonitor &monitor = GetMonitor();
38 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
41 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR() {
42 ProcessMonitor &monitor = GetMonitor();
43 return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc,
44 sizeof(m_fpr_powerpc));
47 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadVMX() {
48 // XXX: Need a way to read/write process VMX registers with ptrace.
52 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR() {
53 ProcessMonitor &monitor = GetMonitor();
54 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
57 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR() {
58 ProcessMonitor &monitor = GetMonitor();
59 return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc,
60 sizeof(m_fpr_powerpc));
63 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteVMX() {
64 // XXX: Need a way to read/write process VMX registers with ptrace.
68 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
69 const unsigned reg, RegisterValue &value) {
70 ProcessMonitor &monitor = GetMonitor();
71 return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
72 GetRegisterName(reg), GetRegisterSize(reg),
76 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
77 const unsigned reg, const RegisterValue &value) {
78 unsigned reg_to_write = reg;
79 RegisterValue value_to_write = value;
81 // Check if this is a subregister of a full register.
82 const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
83 if (reg_info->invalidate_regs &&
84 (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
85 RegisterValue full_value;
86 uint32_t full_reg = reg_info->invalidate_regs[0];
87 const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
89 // Read the full register.
90 if (ReadRegister(full_reg_info, full_value)) {
92 ByteOrder byte_order = GetByteOrder();
93 uint8_t dst[RegisterValue::kMaxRegisterByteSize];
95 // Get the bytes for the full register.
96 const uint32_t dest_size = full_value.GetAsMemoryData(
97 full_reg_info, dst, sizeof(dst), byte_order, error);
98 if (error.Success() && dest_size) {
99 uint8_t src[RegisterValue::kMaxRegisterByteSize];
101 // Get the bytes for the source data.
102 const uint32_t src_size = value.GetAsMemoryData(
103 reg_info, src, sizeof(src), byte_order, error);
104 if (error.Success() && src_size && (src_size < dest_size)) {
105 // Copy the src bytes to the destination.
106 memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
107 // Set this full register as the value to write.
108 value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
109 value_to_write.SetType(full_reg_info);
110 reg_to_write = full_reg;
116 ProcessMonitor &monitor = GetMonitor();
117 // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
118 // registers in ptrace, but expose here 32-bit registers with a higher
120 uint64_t offset = GetRegisterOffset(reg_to_write);
121 offset &= ~(sizeof(uintptr_t) - 1);
122 return monitor.WriteRegisterValue(
123 m_thread.GetID(), offset, GetRegisterName(reg_to_write), value_to_write);
126 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
127 const RegisterInfo *reg_info, RegisterValue &value) {
131 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
136 uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
137 value.SetUInt64(*(uint64_t *)src);
138 } else if (IsGPR(reg)) {
139 bool success = ReadRegister(reg, value);
142 // If our return byte size was greater than the return value reg size,
143 // then use the type specified by reg_info rather than the uint64_t
145 if (value.GetByteSize() > reg_info->byte_size)
146 value.SetType(reg_info);
154 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
155 const RegisterInfo *reg_info, const RegisterValue &value) {
156 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
159 return WriteRegister(reg, value);
160 } else if (IsFPR(reg)) {
161 assert(reg_info->byte_offset < sizeof(m_fpr_powerpc));
162 uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
163 *(uint64_t *)dst = value.GetAsUInt64();
170 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(
171 DataBufferSP &data_sp) {
172 bool success = false;
173 data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
174 if (data_sp && ReadGPR() && ReadFPR()) {
175 uint8_t *dst = data_sp->GetBytes();
179 ::memcpy(dst, &m_gpr_powerpc, GetGPRSize());
186 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteAllRegisterValues(
187 const DataBufferSP &data_sp) {
188 bool success = false;
189 if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
190 uint8_t *src = data_sp->GetBytes();
192 ::memcpy(&m_gpr_powerpc, src, GetGPRSize());
196 ::memcpy(&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
198 success = WriteFPR();
205 uint32_t RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(
206 addr_t addr, size_t size, bool read, bool write) {
207 const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
210 for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
211 if (IsWatchpointVacant(hw_index))
212 return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
215 return LLDB_INVALID_INDEX32;
218 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(
223 bool RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(
228 bool RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint() {
231 if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
237 unsigned RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(
240 for (reg = 0; reg < k_num_registers_powerpc; reg++) {
241 if (GetRegisterInfo()[reg].byte_offset == offset)
244 assert(reg < k_num_registers_powerpc && "Invalid register offset.");
248 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(
253 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits() {
257 addr_t RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(
259 return LLDB_INVALID_ADDRESS;
262 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(
267 bool RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(
268 addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
273 RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints() {