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