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