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