1 //===-- RegisterContext.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 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project includes
14 #include "lldb/Target/RegisterContext.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/RegisterValue.h"
17 #include "lldb/Core/Scalar.h"
18 #include "lldb/Core/Value.h"
19 #include "lldb/Expression/DWARFExpression.h"
20 #include "lldb/Target/ExecutionContext.h"
21 #include "lldb/Target/Process.h"
22 #include "lldb/Target/StackFrame.h"
23 #include "lldb/Target/Target.h"
24 #include "lldb/Target/Thread.h"
25 #include "lldb/Utility/DataExtractor.h"
26 #include "lldb/Utility/Endian.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 RegisterContext::RegisterContext(Thread &thread, uint32_t concrete_frame_idx)
32     : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx),
33       m_stop_id(thread.GetProcess()->GetStopID()) {}
34 
35 RegisterContext::~RegisterContext() = default;
36 
37 void RegisterContext::InvalidateIfNeeded(bool force) {
38   ProcessSP process_sp(m_thread.GetProcess());
39   bool invalidate = force;
40   uint32_t process_stop_id = UINT32_MAX;
41 
42   if (process_sp)
43     process_stop_id = process_sp->GetStopID();
44   else
45     invalidate = true;
46 
47   if (!invalidate)
48     invalidate = process_stop_id != GetStopID();
49 
50   if (invalidate) {
51     InvalidateAllRegisters();
52     SetStopID(process_stop_id);
53   }
54 }
55 
56 const RegisterInfo *
57 RegisterContext::GetRegisterInfoByName(llvm::StringRef reg_name,
58                                        uint32_t start_idx) {
59   if (reg_name.empty())
60     return nullptr;
61 
62   const uint32_t num_registers = GetRegisterCount();
63   for (uint32_t reg = start_idx; reg < num_registers; ++reg) {
64     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
65 
66     if (reg_name.equals_lower(reg_info->name) ||
67         reg_name.equals_lower(reg_info->alt_name))
68       return reg_info;
69   }
70   return nullptr;
71 }
72 
73 uint32_t
74 RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
75                                            RegisterInfo *reg_info) {
76   ExecutionContext exe_ctx(CalculateThread());
77 
78   // In MIPS, the floating point registers size is depends on FR bit of SR
79   // register.
80   // if SR.FR  == 1 then all floating point registers are 64 bits.
81   // else they are all 32 bits.
82 
83   int expr_result;
84   uint32_t addr_size = arch.GetAddressByteSize();
85   const uint8_t *dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
86   const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
87 
88   DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
89                            arch.GetByteOrder(), addr_size);
90   ModuleSP opcode_ctx;
91   DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr, 0,
92                              dwarf_opcode_len);
93   Value result;
94   Status error;
95   const lldb::offset_t offset = 0;
96   if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, nullptr,
97                           offset, dwarf_opcode_len, eRegisterKindDWARF, nullptr,
98                           nullptr, result, &error)) {
99     expr_result = result.GetScalar().SInt(-1);
100     switch (expr_result) {
101     case 0:
102       return 4;
103     case 1:
104       return 8;
105     default:
106       return reg_info->byte_size;
107     }
108   } else {
109     printf("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
110     return reg_info->byte_size;
111   }
112 }
113 
114 const RegisterInfo *RegisterContext::GetRegisterInfo(lldb::RegisterKind kind,
115                                                      uint32_t num) {
116   const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
117   if (reg_num == LLDB_INVALID_REGNUM)
118     return nullptr;
119   return GetRegisterInfoAtIndex(reg_num);
120 }
121 
122 const char *RegisterContext::GetRegisterName(uint32_t reg) {
123   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
124   if (reg_info)
125     return reg_info->name;
126   return nullptr;
127 }
128 
129 uint64_t RegisterContext::GetPC(uint64_t fail_value) {
130   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
131                                                      LLDB_REGNUM_GENERIC_PC);
132   uint64_t pc = ReadRegisterAsUnsigned(reg, fail_value);
133 
134   if (pc != fail_value) {
135     TargetSP target_sp = m_thread.CalculateTarget();
136     if (target_sp) {
137       Target *target = target_sp.get();
138       if (target)
139         pc = target->GetOpcodeLoadAddress(pc, eAddressClassCode);
140     }
141   }
142 
143   return pc;
144 }
145 
146 bool RegisterContext::SetPC(uint64_t pc) {
147   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
148                                                      LLDB_REGNUM_GENERIC_PC);
149   bool success = WriteRegisterFromUnsigned(reg, pc);
150   if (success) {
151     StackFrameSP frame_sp(
152         m_thread.GetFrameWithConcreteFrameIndex(m_concrete_frame_idx));
153     if (frame_sp)
154       frame_sp->ChangePC(pc);
155     else
156       m_thread.ClearStackFrames();
157   }
158   return success;
159 }
160 
161 bool RegisterContext::SetPC(Address addr) {
162   TargetSP target_sp = m_thread.CalculateTarget();
163   Target *target = target_sp.get();
164 
165   lldb::addr_t callAddr = addr.GetCallableLoadAddress(target);
166   if (callAddr == LLDB_INVALID_ADDRESS)
167     return false;
168 
169   return SetPC(callAddr);
170 }
171 
172 uint64_t RegisterContext::GetSP(uint64_t fail_value) {
173   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
174                                                      LLDB_REGNUM_GENERIC_SP);
175   return ReadRegisterAsUnsigned(reg, fail_value);
176 }
177 
178 bool RegisterContext::SetSP(uint64_t sp) {
179   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
180                                                      LLDB_REGNUM_GENERIC_SP);
181   return WriteRegisterFromUnsigned(reg, sp);
182 }
183 
184 uint64_t RegisterContext::GetFP(uint64_t fail_value) {
185   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
186                                                      LLDB_REGNUM_GENERIC_FP);
187   return ReadRegisterAsUnsigned(reg, fail_value);
188 }
189 
190 bool RegisterContext::SetFP(uint64_t fp) {
191   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
192                                                      LLDB_REGNUM_GENERIC_FP);
193   return WriteRegisterFromUnsigned(reg, fp);
194 }
195 
196 uint64_t RegisterContext::GetReturnAddress(uint64_t fail_value) {
197   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
198                                                      LLDB_REGNUM_GENERIC_RA);
199   return ReadRegisterAsUnsigned(reg, fail_value);
200 }
201 
202 uint64_t RegisterContext::GetFlags(uint64_t fail_value) {
203   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
204                                                      LLDB_REGNUM_GENERIC_FLAGS);
205   return ReadRegisterAsUnsigned(reg, fail_value);
206 }
207 
208 uint64_t RegisterContext::ReadRegisterAsUnsigned(uint32_t reg,
209                                                  uint64_t fail_value) {
210   if (reg != LLDB_INVALID_REGNUM)
211     return ReadRegisterAsUnsigned(GetRegisterInfoAtIndex(reg), fail_value);
212   return fail_value;
213 }
214 
215 uint64_t RegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
216                                                  uint64_t fail_value) {
217   if (reg_info) {
218     RegisterValue value;
219     if (ReadRegister(reg_info, value))
220       return value.GetAsUInt64();
221   }
222   return fail_value;
223 }
224 
225 bool RegisterContext::WriteRegisterFromUnsigned(uint32_t reg, uint64_t uval) {
226   if (reg == LLDB_INVALID_REGNUM)
227     return false;
228   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
229 }
230 
231 bool RegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
232                                                 uint64_t uval) {
233   if (reg_info) {
234     RegisterValue value;
235     if (value.SetUInt(uval, reg_info->byte_size))
236       return WriteRegister(reg_info, value);
237   }
238   return false;
239 }
240 
241 bool RegisterContext::CopyFromRegisterContext(lldb::RegisterContextSP context) {
242   uint32_t num_register_sets = context->GetRegisterSetCount();
243   // We don't know that two threads have the same register context, so require
244   // the threads to be the same.
245   if (context->GetThreadID() != GetThreadID())
246     return false;
247 
248   if (num_register_sets != GetRegisterSetCount())
249     return false;
250 
251   RegisterContextSP frame_zero_context = m_thread.GetRegisterContext();
252 
253   for (uint32_t set_idx = 0; set_idx < num_register_sets; ++set_idx) {
254     const RegisterSet *const reg_set = GetRegisterSet(set_idx);
255 
256     const uint32_t num_registers = reg_set->num_registers;
257     for (uint32_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
258       const uint32_t reg = reg_set->registers[reg_idx];
259       const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
260       if (!reg_info || reg_info->value_regs)
261         continue;
262       RegisterValue reg_value;
263 
264       // If we can reconstruct the register from the frame we are copying from,
265       // then do so, otherwise
266       // use the value from frame 0.
267       if (context->ReadRegister(reg_info, reg_value)) {
268         WriteRegister(reg_info, reg_value);
269       } else if (frame_zero_context->ReadRegister(reg_info, reg_value)) {
270         WriteRegister(reg_info, reg_value);
271       }
272     }
273   }
274   return true;
275 }
276 
277 lldb::tid_t RegisterContext::GetThreadID() const { return m_thread.GetID(); }
278 
279 uint32_t RegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
280 
281 uint32_t RegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
282                                                 size_t size) {
283   return LLDB_INVALID_INDEX32;
284 }
285 
286 bool RegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) { return false; }
287 
288 uint32_t RegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
289 
290 uint32_t RegisterContext::SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
291                                                 bool read, bool write) {
292   return LLDB_INVALID_INDEX32;
293 }
294 
295 bool RegisterContext::ClearHardwareWatchpoint(uint32_t hw_index) {
296   return false;
297 }
298 
299 bool RegisterContext::HardwareSingleStep(bool enable) { return false; }
300 
301 Status RegisterContext::ReadRegisterValueFromMemory(
302     const RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len,
303     RegisterValue &reg_value) {
304   Status error;
305   if (reg_info == nullptr) {
306     error.SetErrorString("invalid register info argument.");
307     return error;
308   }
309 
310   // Moving from addr into a register
311   //
312   // Case 1: src_len == dst_len
313   //
314   //   |AABBCCDD| Address contents
315   //   |AABBCCDD| Register contents
316   //
317   // Case 2: src_len > dst_len
318   //
319   //   Status!  (The register should always be big enough to hold the data)
320   //
321   // Case 3: src_len < dst_len
322   //
323   //   |AABB| Address contents
324   //   |AABB0000| Register contents [on little-endian hardware]
325   //   |0000AABB| Register contents [on big-endian hardware]
326   if (src_len > RegisterValue::kMaxRegisterByteSize) {
327     error.SetErrorString("register too small to receive memory data");
328     return error;
329   }
330 
331   const uint32_t dst_len = reg_info->byte_size;
332 
333   if (src_len > dst_len) {
334     error.SetErrorStringWithFormat(
335         "%u bytes is too big to store in register %s (%u bytes)", src_len,
336         reg_info->name, dst_len);
337     return error;
338   }
339 
340   ProcessSP process_sp(m_thread.GetProcess());
341   if (process_sp) {
342     uint8_t src[RegisterValue::kMaxRegisterByteSize];
343 
344     // Read the memory
345     const uint32_t bytes_read =
346         process_sp->ReadMemory(src_addr, src, src_len, error);
347 
348     // Make sure the memory read succeeded...
349     if (bytes_read != src_len) {
350       if (error.Success()) {
351         // This might happen if we read _some_ bytes but not all
352         error.SetErrorStringWithFormat("read %u of %u bytes", bytes_read,
353                                        src_len);
354       }
355       return error;
356     }
357 
358     // We now have a memory buffer that contains the part or all of the register
359     // value. Set the register value using this memory data.
360     // TODO: we might need to add a parameter to this function in case the byte
361     // order of the memory data doesn't match the process. For now we are
362     // assuming
363     // they are the same.
364     reg_value.SetFromMemoryData(reg_info, src, src_len,
365                                 process_sp->GetByteOrder(), error);
366   } else
367     error.SetErrorString("invalid process");
368 
369   return error;
370 }
371 
372 Status RegisterContext::WriteRegisterValueToMemory(
373     const RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len,
374     const RegisterValue &reg_value) {
375   uint8_t dst[RegisterValue::kMaxRegisterByteSize];
376 
377   Status error;
378 
379   ProcessSP process_sp(m_thread.GetProcess());
380   if (process_sp) {
381 
382     // TODO: we might need to add a parameter to this function in case the byte
383     // order of the memory data doesn't match the process. For now we are
384     // assuming
385     // they are the same.
386 
387     const uint32_t bytes_copied = reg_value.GetAsMemoryData(
388         reg_info, dst, dst_len, process_sp->GetByteOrder(), error);
389 
390     if (error.Success()) {
391       if (bytes_copied == 0) {
392         error.SetErrorString("byte copy failed.");
393       } else {
394         const uint32_t bytes_written =
395             process_sp->WriteMemory(dst_addr, dst, bytes_copied, error);
396         if (bytes_written != bytes_copied) {
397           if (error.Success()) {
398             // This might happen if we read _some_ bytes but not all
399             error.SetErrorStringWithFormat("only wrote %u of %u bytes",
400                                            bytes_written, bytes_copied);
401           }
402         }
403       }
404     }
405   } else
406     error.SetErrorString("invalid process");
407 
408   return error;
409 }
410 
411 bool RegisterContext::ReadAllRegisterValues(
412     lldb_private::RegisterCheckpoint &reg_checkpoint) {
413   return ReadAllRegisterValues(reg_checkpoint.GetData());
414 }
415 
416 bool RegisterContext::WriteAllRegisterValues(
417     const lldb_private::RegisterCheckpoint &reg_checkpoint) {
418   return WriteAllRegisterValues(reg_checkpoint.GetData());
419 }
420 
421 TargetSP RegisterContext::CalculateTarget() {
422   return m_thread.CalculateTarget();
423 }
424 
425 ProcessSP RegisterContext::CalculateProcess() {
426   return m_thread.CalculateProcess();
427 }
428 
429 ThreadSP RegisterContext::CalculateThread() {
430   return m_thread.shared_from_this();
431 }
432 
433 StackFrameSP RegisterContext::CalculateStackFrame() {
434   // Register contexts might belong to many frames if we have inlined
435   // functions inside a frame since all inlined functions share the
436   // same registers, so we can't definitively say which frame we come from...
437   return StackFrameSP();
438 }
439 
440 void RegisterContext::CalculateExecutionContext(ExecutionContext &exe_ctx) {
441   m_thread.CalculateExecutionContext(exe_ctx);
442 }
443 
444 bool RegisterContext::ConvertBetweenRegisterKinds(lldb::RegisterKind source_rk,
445                                                   uint32_t source_regnum,
446                                                   lldb::RegisterKind target_rk,
447                                                   uint32_t &target_regnum) {
448   const uint32_t num_registers = GetRegisterCount();
449   for (uint32_t reg = 0; reg < num_registers; ++reg) {
450     const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
451 
452     if (reg_info->kinds[source_rk] == source_regnum) {
453       target_regnum = reg_info->kinds[target_rk];
454       return (target_regnum != LLDB_INVALID_REGNUM);
455     }
456   }
457   return false;
458 }
459 
460 // bool
461 // RegisterContext::ReadRegisterValue (uint32_t reg, Scalar &value)
462 //{
463 //    DataExtractor data;
464 //    if (!ReadRegisterBytes (reg, data))
465 //        return false;
466 //
467 //    const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg);
468 //    uint32_t offset = 0;
469 //    switch (reg_info->encoding)
470 //    {
471 //    case eEncodingInvalid:
472 //    case eEncodingVector:
473 //        break;
474 //
475 //    case eEncodingUint:
476 //        switch (reg_info->byte_size)
477 //        {
478 //        case 1:
479 //            {
480 //                value = data.GetU8 (&offset);
481 //                return true;
482 //            }
483 //        case 2:
484 //            {
485 //                value = data.GetU16 (&offset);
486 //                return true;
487 //            }
488 //        case 4:
489 //            {
490 //                value = data.GetU32 (&offset);
491 //                return true;
492 //            }
493 //        case 8:
494 //            {
495 //                value = data.GetU64 (&offset);
496 //                return true;
497 //            }
498 //        }
499 //        break;
500 //    case eEncodingSint:
501 //        switch (reg_info->byte_size)
502 //        {
503 //        case 1:
504 //            {
505 //                int8_t v;
506 //                if (data.ExtractBytes (0, sizeof (int8_t),
507 //                endian::InlHostByteOrder(), &v) != sizeof (int8_t))
508 //                    return false;
509 //                value = v;
510 //                return true;
511 //            }
512 //        case 2:
513 //            {
514 //                int16_t v;
515 //                if (data.ExtractBytes (0, sizeof (int16_t),
516 //                endian::InlHostByteOrder(), &v) != sizeof (int16_t))
517 //                    return false;
518 //                value = v;
519 //                return true;
520 //            }
521 //        case 4:
522 //            {
523 //                int32_t v;
524 //                if (data.ExtractBytes (0, sizeof (int32_t),
525 //                endian::InlHostByteOrder(), &v) != sizeof (int32_t))
526 //                    return false;
527 //                value = v;
528 //                return true;
529 //            }
530 //        case 8:
531 //            {
532 //                int64_t v;
533 //                if (data.ExtractBytes (0, sizeof (int64_t),
534 //                endian::InlHostByteOrder(), &v) != sizeof (int64_t))
535 //                    return false;
536 //                value = v;
537 //                return true;
538 //            }
539 //        }
540 //        break;
541 //    case eEncodingIEEE754:
542 //        switch (reg_info->byte_size)
543 //        {
544 //        case sizeof (float):
545 //            {
546 //                float v;
547 //                if (data.ExtractBytes (0, sizeof (float),
548 //                endian::InlHostByteOrder(), &v) != sizeof (float))
549 //                    return false;
550 //                value = v;
551 //                return true;
552 //            }
553 //        case sizeof (double):
554 //            {
555 //                double v;
556 //                if (data.ExtractBytes (0, sizeof (double),
557 //                endian::InlHostByteOrder(), &v) != sizeof (double))
558 //                    return false;
559 //                value = v;
560 //                return true;
561 //            }
562 //        case sizeof (long double):
563 //            {
564 //                double v;
565 //                if (data.ExtractBytes (0, sizeof (long double),
566 //                endian::InlHostByteOrder(), &v) != sizeof (long double))
567 //                    return false;
568 //                value = v;
569 //                return true;
570 //            }
571 //        }
572 //        break;
573 //    }
574 //    return false;
575 //}
576 //
577 // bool
578 // RegisterContext::WriteRegisterValue (uint32_t reg, const Scalar &value)
579 //{
580 //    DataExtractor data;
581 //    if (!value.IsValid())
582 //        return false;
583 //    if (!value.GetData (data))
584 //        return false;
585 //
586 //    return WriteRegisterBytes (reg, data);
587 //}
588