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