1 //===-- EmulationStateARM.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 "EmulationStateARM.h"
11 
12 #include "lldb/Interpreter/OptionValueArray.h"
13 #include "lldb/Interpreter/OptionValueDictionary.h"
14 #include "lldb/Target/RegisterContext.h"
15 #include "lldb/Target/StackFrame.h"
16 #include "lldb/Utility/RegisterValue.h"
17 #include "lldb/Utility/Scalar.h"
18 
19 #include "Utility/ARM_DWARF_Registers.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
24 EmulationStateARM::EmulationStateARM() : m_gpr(), m_vfp_regs(), m_memory() {
25   ClearPseudoRegisters();
26 }
27 
28 EmulationStateARM::~EmulationStateARM() {}
29 
30 bool EmulationStateARM::LoadPseudoRegistersFromFrame(StackFrame &frame) {
31   RegisterContext *reg_ctx = frame.GetRegisterContext().get();
32   bool success = true;
33   uint32_t reg_num;
34 
35   for (int i = dwarf_r0; i < dwarf_r0 + 17; ++i) {
36     reg_num =
37         reg_ctx->ConvertRegisterKindToRegisterNumber(eRegisterKindDWARF, i);
38     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
39     RegisterValue reg_value;
40     if (reg_ctx->ReadRegister(reg_info, reg_value)) {
41       m_gpr[i - dwarf_r0] = reg_value.GetAsUInt32();
42     } else
43       success = false;
44   }
45 
46   for (int i = dwarf_d0; i < dwarf_d0 + 32; ++i) {
47     reg_num =
48         reg_ctx->ConvertRegisterKindToRegisterNumber(eRegisterKindDWARF, i);
49     RegisterValue reg_value;
50     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
51 
52     if (reg_ctx->ReadRegister(reg_info, reg_value)) {
53       uint64_t value = reg_value.GetAsUInt64();
54       uint32_t idx = i - dwarf_d0;
55       if (i < 16) {
56         m_vfp_regs.s_regs[idx * 2] = (uint32_t)value;
57         m_vfp_regs.s_regs[idx * 2 + 1] = (uint32_t)(value >> 32);
58       } else
59         m_vfp_regs.d_regs[idx - 16] = value;
60     } else
61       success = false;
62   }
63 
64   return success;
65 }
66 
67 bool EmulationStateARM::StorePseudoRegisterValue(uint32_t reg_num,
68                                                  uint64_t value) {
69   if (reg_num <= dwarf_cpsr)
70     m_gpr[reg_num - dwarf_r0] = (uint32_t)value;
71   else if ((dwarf_s0 <= reg_num) && (reg_num <= dwarf_s31)) {
72     uint32_t idx = reg_num - dwarf_s0;
73     m_vfp_regs.s_regs[idx] = (uint32_t)value;
74   } else if ((dwarf_d0 <= reg_num) && (reg_num <= dwarf_d31)) {
75     uint32_t idx = reg_num - dwarf_d0;
76     if (idx < 16) {
77       m_vfp_regs.s_regs[idx * 2] = (uint32_t)value;
78       m_vfp_regs.s_regs[idx * 2 + 1] = (uint32_t)(value >> 32);
79     } else
80       m_vfp_regs.d_regs[idx - 16] = value;
81   } else
82     return false;
83 
84   return true;
85 }
86 
87 uint64_t EmulationStateARM::ReadPseudoRegisterValue(uint32_t reg_num,
88                                                     bool &success) {
89   uint64_t value = 0;
90   success = true;
91 
92   if (reg_num <= dwarf_cpsr)
93     value = m_gpr[reg_num - dwarf_r0];
94   else if ((dwarf_s0 <= reg_num) && (reg_num <= dwarf_s31)) {
95     uint32_t idx = reg_num - dwarf_s0;
96     value = m_vfp_regs.d_regs[idx];
97   } else if ((dwarf_d0 <= reg_num) && (reg_num <= dwarf_d31)) {
98     uint32_t idx = reg_num - dwarf_d0;
99     if (idx < 16)
100       value = (uint64_t)m_vfp_regs.s_regs[idx * 2] |
101               ((uint64_t)m_vfp_regs.s_regs[idx * 2 + 1] >> 32);
102     else
103       value = m_vfp_regs.d_regs[idx - 16];
104   } else
105     success = false;
106 
107   return value;
108 }
109 
110 void EmulationStateARM::ClearPseudoRegisters() {
111   for (int i = 0; i < 17; ++i)
112     m_gpr[i] = 0;
113 
114   for (int i = 0; i < 32; ++i)
115     m_vfp_regs.s_regs[i] = 0;
116 
117   for (int i = 0; i < 16; ++i)
118     m_vfp_regs.d_regs[i] = 0;
119 }
120 
121 void EmulationStateARM::ClearPseudoMemory() { m_memory.clear(); }
122 
123 bool EmulationStateARM::StoreToPseudoAddress(lldb::addr_t p_address,
124                                              uint32_t value) {
125   m_memory[p_address] = value;
126   return true;
127 }
128 
129 uint32_t EmulationStateARM::ReadFromPseudoAddress(lldb::addr_t p_address,
130                                                   bool &success) {
131   std::map<lldb::addr_t, uint32_t>::iterator pos;
132   uint32_t ret_val = 0;
133 
134   success = true;
135   pos = m_memory.find(p_address);
136   if (pos != m_memory.end())
137     ret_val = pos->second;
138   else
139     success = false;
140 
141   return ret_val;
142 }
143 
144 size_t EmulationStateARM::ReadPseudoMemory(
145     EmulateInstruction *instruction, void *baton,
146     const EmulateInstruction::Context &context, lldb::addr_t addr, void *dst,
147     size_t length) {
148   if (!baton)
149     return 0;
150 
151   bool success = true;
152   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
153   if (length <= 4) {
154     uint32_t value = pseudo_state->ReadFromPseudoAddress(addr, success);
155     if (!success)
156       return 0;
157 
158     if (endian::InlHostByteOrder() == lldb::eByteOrderBig)
159       value = llvm::ByteSwap_32(value);
160     *((uint32_t *)dst) = value;
161   } else if (length == 8) {
162     uint32_t value1 = pseudo_state->ReadFromPseudoAddress(addr, success);
163     if (!success)
164       return 0;
165 
166     uint32_t value2 = pseudo_state->ReadFromPseudoAddress(addr + 4, success);
167     if (!success)
168       return 0;
169 
170     if (endian::InlHostByteOrder() == lldb::eByteOrderBig) {
171       value1 = llvm::ByteSwap_32(value1);
172       value2 = llvm::ByteSwap_32(value2);
173     }
174     ((uint32_t *)dst)[0] = value1;
175     ((uint32_t *)dst)[1] = value2;
176   } else
177     success = false;
178 
179   if (success)
180     return length;
181 
182   return 0;
183 }
184 
185 size_t EmulationStateARM::WritePseudoMemory(
186     EmulateInstruction *instruction, void *baton,
187     const EmulateInstruction::Context &context, lldb::addr_t addr,
188     const void *dst, size_t length) {
189   if (!baton)
190     return 0;
191 
192   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
193 
194   if (length <= 4) {
195     uint32_t value;
196     memcpy (&value, dst, sizeof (uint32_t));
197     if (endian::InlHostByteOrder() == lldb::eByteOrderBig)
198       value = llvm::ByteSwap_32(value);
199 
200     pseudo_state->StoreToPseudoAddress(addr, value);
201     return length;
202   } else if (length == 8) {
203     uint32_t value1;
204     uint32_t value2;
205     memcpy (&value1, dst, sizeof (uint32_t));
206     memcpy(&value2, static_cast<const uint8_t *>(dst) + sizeof(uint32_t),
207            sizeof(uint32_t));
208     if (endian::InlHostByteOrder() == lldb::eByteOrderBig) {
209       value1 = llvm::ByteSwap_32(value1);
210       value2 = llvm::ByteSwap_32(value2);
211     }
212 
213     pseudo_state->StoreToPseudoAddress(addr, value1);
214     pseudo_state->StoreToPseudoAddress(addr + 4, value2);
215     return length;
216   }
217 
218   return 0;
219 }
220 
221 bool EmulationStateARM::ReadPseudoRegister(
222     EmulateInstruction *instruction, void *baton,
223     const lldb_private::RegisterInfo *reg_info,
224     lldb_private::RegisterValue &reg_value) {
225   if (!baton || !reg_info)
226     return false;
227 
228   bool success = true;
229   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
230   const uint32_t dwarf_reg_num = reg_info->kinds[eRegisterKindDWARF];
231   assert(dwarf_reg_num != LLDB_INVALID_REGNUM);
232   uint64_t reg_uval =
233       pseudo_state->ReadPseudoRegisterValue(dwarf_reg_num, success);
234 
235   if (success)
236     success = reg_value.SetUInt(reg_uval, reg_info->byte_size);
237   return success;
238 }
239 
240 bool EmulationStateARM::WritePseudoRegister(
241     EmulateInstruction *instruction, void *baton,
242     const EmulateInstruction::Context &context,
243     const lldb_private::RegisterInfo *reg_info,
244     const lldb_private::RegisterValue &reg_value) {
245   if (!baton || !reg_info)
246     return false;
247 
248   EmulationStateARM *pseudo_state = (EmulationStateARM *)baton;
249   const uint32_t dwarf_reg_num = reg_info->kinds[eRegisterKindDWARF];
250   assert(dwarf_reg_num != LLDB_INVALID_REGNUM);
251   return pseudo_state->StorePseudoRegisterValue(dwarf_reg_num,
252                                                 reg_value.GetAsUInt64());
253 }
254 
255 bool EmulationStateARM::CompareState(EmulationStateARM &other_state) {
256   bool match = true;
257 
258   for (int i = 0; match && i < 17; ++i) {
259     if (m_gpr[i] != other_state.m_gpr[i])
260       match = false;
261   }
262 
263   for (int i = 0; match && i < 32; ++i) {
264     if (m_vfp_regs.s_regs[i] != other_state.m_vfp_regs.s_regs[i])
265       match = false;
266   }
267 
268   for (int i = 0; match && i < 16; ++i) {
269     if (m_vfp_regs.d_regs[i] != other_state.m_vfp_regs.d_regs[i])
270       match = false;
271   }
272 
273   return match;
274 }
275 
276 bool EmulationStateARM::LoadStateFromDictionary(
277     OptionValueDictionary *test_data) {
278   static ConstString memory_key("memory");
279   static ConstString registers_key("registers");
280 
281   if (!test_data)
282     return false;
283 
284   OptionValueSP value_sp = test_data->GetValueForKey(memory_key);
285 
286   // Load memory, if present.
287 
288   if (value_sp.get() != NULL) {
289     static ConstString address_key("address");
290     static ConstString data_key("data");
291     uint64_t start_address = 0;
292 
293     OptionValueDictionary *mem_dict = value_sp->GetAsDictionary();
294     value_sp = mem_dict->GetValueForKey(address_key);
295     if (value_sp.get() == NULL)
296       return false;
297     else
298       start_address = value_sp->GetUInt64Value();
299 
300     value_sp = mem_dict->GetValueForKey(data_key);
301     OptionValueArray *mem_array = value_sp->GetAsArray();
302     if (!mem_array)
303       return false;
304 
305     uint32_t num_elts = mem_array->GetSize();
306     uint32_t address = (uint32_t)start_address;
307 
308     for (uint32_t i = 0; i < num_elts; ++i) {
309       value_sp = mem_array->GetValueAtIndex(i);
310       if (value_sp.get() == NULL)
311         return false;
312       uint64_t value = value_sp->GetUInt64Value();
313       StoreToPseudoAddress(address, value);
314       address = address + 4;
315     }
316   }
317 
318   value_sp = test_data->GetValueForKey(registers_key);
319   if (value_sp.get() == NULL)
320     return false;
321 
322   // Load General Registers
323 
324   OptionValueDictionary *reg_dict = value_sp->GetAsDictionary();
325 
326   StreamString sstr;
327   for (int i = 0; i < 16; ++i) {
328     sstr.Clear();
329     sstr.Printf("r%d", i);
330     ConstString reg_name(sstr.GetString());
331     value_sp = reg_dict->GetValueForKey(reg_name);
332     if (value_sp.get() == NULL)
333       return false;
334     uint64_t reg_value = value_sp->GetUInt64Value();
335     StorePseudoRegisterValue(dwarf_r0 + i, reg_value);
336   }
337 
338   static ConstString cpsr_name("cpsr");
339   value_sp = reg_dict->GetValueForKey(cpsr_name);
340   if (value_sp.get() == NULL)
341     return false;
342   StorePseudoRegisterValue(dwarf_cpsr, value_sp->GetUInt64Value());
343 
344   // Load s/d Registers
345   for (int i = 0; i < 32; ++i) {
346     sstr.Clear();
347     sstr.Printf("s%d", i);
348     ConstString reg_name(sstr.GetString());
349     value_sp = reg_dict->GetValueForKey(reg_name);
350     if (value_sp.get() == NULL)
351       return false;
352     uint64_t reg_value = value_sp->GetUInt64Value();
353     StorePseudoRegisterValue(dwarf_s0 + i, reg_value);
354   }
355 
356   return true;
357 }
358