1 //===-- RegisterContextPOSIXProcessMonitor_powerpc.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/Target/Thread.h"
11 #include "lldb/Utility/DataBufferHeap.h"
12 #include "lldb/Utility/RegisterValue.h"
13
14 #include "ProcessFreeBSD.h"
15 #include "ProcessMonitor.h"
16 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
17 #include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
18
19 using namespace lldb_private;
20 using namespace lldb;
21
22 #define REG_CONTEXT_SIZE (GetGPRSize())
23
24 RegisterContextPOSIXProcessMonitor_powerpc::
RegisterContextPOSIXProcessMonitor_powerpc(Thread & thread,uint32_t concrete_frame_idx,lldb_private::RegisterInfoInterface * register_info)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) {}
29
GetMonitor()30 ProcessMonitor &RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor() {
31 ProcessSP base = CalculateProcess();
32 ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
33 return process->GetMonitor();
34 }
35
ReadGPR()36 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR() {
37 ProcessMonitor &monitor = GetMonitor();
38 return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
39 }
40
ReadFPR()41 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR() {
42 ProcessMonitor &monitor = GetMonitor();
43 return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc,
44 sizeof(m_fpr_powerpc));
45 }
46
ReadVMX()47 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadVMX() {
48 // XXX: Need a way to read/write process VMX registers with ptrace.
49 return false;
50 }
51
WriteGPR()52 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR() {
53 ProcessMonitor &monitor = GetMonitor();
54 return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
55 }
56
WriteFPR()57 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR() {
58 ProcessMonitor &monitor = GetMonitor();
59 return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc,
60 sizeof(m_fpr_powerpc));
61 }
62
WriteVMX()63 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteVMX() {
64 // XXX: Need a way to read/write process VMX registers with ptrace.
65 return false;
66 }
67
ReadRegister(const unsigned reg,RegisterValue & value)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),
73 value);
74 }
75
WriteRegister(const unsigned reg,const RegisterValue & value)76 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
77 const unsigned reg, const RegisterValue &value) {
78 unsigned reg_to_write = reg;
79 RegisterValue value_to_write = value;
80
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);
88
89 // Read the full register.
90 if (ReadRegister(full_reg_info, full_value)) {
91 Status error;
92 ByteOrder byte_order = GetByteOrder();
93 uint8_t dst[RegisterValue::kMaxRegisterByteSize];
94
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];
100
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;
111 }
112 }
113 }
114 }
115
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
119 // offset.
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);
124 }
125
ReadRegister(const RegisterInfo * reg_info,RegisterValue & value)126 bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
127 const RegisterInfo *reg_info, RegisterValue &value) {
128 if (!reg_info)
129 return false;
130
131 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
132
133 if (IsFPR(reg)) {
134 if (!ReadFPR())
135 return false;
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);
140
141 if (success) {
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
144 // default
145 if (value.GetByteSize() > reg_info->byte_size)
146 value.SetType(reg_info);
147 }
148 return success;
149 }
150
151 return false;
152 }
153
WriteRegister(const RegisterInfo * reg_info,const RegisterValue & value)154 bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
155 const RegisterInfo *reg_info, const RegisterValue &value) {
156 const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
157
158 if (IsGPR(reg)) {
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();
164 return WriteFPR();
165 }
166
167 return false;
168 }
169
ReadAllRegisterValues(DataBufferSP & data_sp)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();
176 success = dst != 0;
177
178 if (success) {
179 ::memcpy(dst, &m_gpr_powerpc, GetGPRSize());
180 dst += GetGPRSize();
181 }
182 }
183 return success;
184 }
185
WriteAllRegisterValues(const DataBufferSP & data_sp)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();
191 if (src) {
192 ::memcpy(&m_gpr_powerpc, src, GetGPRSize());
193
194 if (WriteGPR()) {
195 src += GetGPRSize();
196 ::memcpy(&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
197
198 success = WriteFPR();
199 }
200 }
201 }
202 return success;
203 }
204
SetHardwareWatchpoint(addr_t addr,size_t size,bool read,bool write)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();
208 uint32_t hw_index;
209
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);
213 }
214
215 return LLDB_INVALID_INDEX32;
216 }
217
ClearHardwareWatchpoint(uint32_t hw_index)218 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(
219 uint32_t hw_index) {
220 return false;
221 }
222
HardwareSingleStep(bool enable)223 bool RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(
224 bool enable) {
225 return false;
226 }
227
UpdateAfterBreakpoint()228 bool RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint() {
229 lldb::addr_t pc;
230
231 if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
232 return false;
233
234 return true;
235 }
236
GetRegisterIndexFromOffset(unsigned offset)237 unsigned RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(
238 unsigned offset) {
239 unsigned reg;
240 for (reg = 0; reg < k_num_registers_powerpc; reg++) {
241 if (GetRegisterInfo()[reg].byte_offset == offset)
242 break;
243 }
244 assert(reg < k_num_registers_powerpc && "Invalid register offset.");
245 return reg;
246 }
247
IsWatchpointHit(uint32_t hw_index)248 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(
249 uint32_t hw_index) {
250 return false;
251 }
252
ClearWatchpointHits()253 bool RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits() {
254 return false;
255 }
256
GetWatchpointAddress(uint32_t hw_index)257 addr_t RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(
258 uint32_t hw_index) {
259 return LLDB_INVALID_ADDRESS;
260 }
261
IsWatchpointVacant(uint32_t hw_index)262 bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(
263 uint32_t hw_index) {
264 return false;
265 }
266
SetHardwareWatchpointWithIndex(addr_t addr,size_t size,bool read,bool write,uint32_t hw_index)267 bool RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(
268 addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
269 return false;
270 }
271
272 uint32_t
NumSupportedHardwareWatchpoints()273 RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints() {
274 return 0;
275 }
276