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