1 //===-- RegisterContextMemory.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 "RegisterContextMemory.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "DynamicRegisterInfo.h"
17 #include "lldb/Core/DataBufferHeap.h"
18 #include "lldb/Core/Error.h"
19 #include "lldb/Core/RegisterValue.h"
20 #include "lldb/Target/Process.h"
21 #include "lldb/Target/Thread.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 //----------------------------------------------------------------------
27 // RegisterContextMemory constructor
28 //----------------------------------------------------------------------
29 RegisterContextMemory::RegisterContextMemory(Thread &thread,
30                                              uint32_t concrete_frame_idx,
31                                              DynamicRegisterInfo &reg_infos,
32                                              addr_t reg_data_addr)
33     : RegisterContext(thread, concrete_frame_idx), m_reg_infos(reg_infos),
34       m_reg_valid(), m_reg_data(), m_reg_data_addr(reg_data_addr) {
35   // Resize our vector of bools to contain one bool for every register.
36   // We will use these boolean values to know when a register value
37   // is valid in m_reg_data.
38   const size_t num_regs = reg_infos.GetNumRegisters();
39   assert(num_regs > 0);
40   m_reg_valid.resize(num_regs);
41 
42   // Make a heap based buffer that is big enough to store all registers
43   DataBufferSP reg_data_sp(
44       new DataBufferHeap(reg_infos.GetRegisterDataByteSize(), 0));
45   m_reg_data.SetData(reg_data_sp);
46 }
47 
48 //----------------------------------------------------------------------
49 // Destructor
50 //----------------------------------------------------------------------
51 RegisterContextMemory::~RegisterContextMemory() {}
52 
53 void RegisterContextMemory::InvalidateAllRegisters() {
54   if (m_reg_data_addr != LLDB_INVALID_ADDRESS)
55     SetAllRegisterValid(false);
56 }
57 
58 void RegisterContextMemory::SetAllRegisterValid(bool b) {
59   std::vector<bool>::iterator pos, end = m_reg_valid.end();
60   for (pos = m_reg_valid.begin(); pos != end; ++pos)
61     *pos = b;
62 }
63 
64 size_t RegisterContextMemory::GetRegisterCount() {
65   return m_reg_infos.GetNumRegisters();
66 }
67 
68 const RegisterInfo *RegisterContextMemory::GetRegisterInfoAtIndex(size_t reg) {
69   return m_reg_infos.GetRegisterInfoAtIndex(reg);
70 }
71 
72 size_t RegisterContextMemory::GetRegisterSetCount() {
73   return m_reg_infos.GetNumRegisterSets();
74 }
75 
76 const RegisterSet *RegisterContextMemory::GetRegisterSet(size_t reg_set) {
77   return m_reg_infos.GetRegisterSet(reg_set);
78 }
79 
80 uint32_t RegisterContextMemory::ConvertRegisterKindToRegisterNumber(
81     lldb::RegisterKind kind, uint32_t num) {
82   return m_reg_infos.ConvertRegisterKindToRegisterNumber(kind, num);
83 }
84 
85 bool RegisterContextMemory::ReadRegister(const RegisterInfo *reg_info,
86                                          RegisterValue &reg_value) {
87   const uint32_t reg_num = reg_info->kinds[eRegisterKindLLDB];
88   if (!m_reg_valid[reg_num]) {
89     if (!ReadAllRegisterValues(m_reg_data.GetSharedDataBuffer()))
90       return false;
91   }
92   const bool partial_data_ok = false;
93   return reg_value
94       .SetValueFromData(reg_info, m_reg_data, reg_info->byte_offset,
95                         partial_data_ok)
96       .Success();
97 }
98 
99 bool RegisterContextMemory::WriteRegister(const RegisterInfo *reg_info,
100                                           const RegisterValue &reg_value) {
101   if (m_reg_data_addr != LLDB_INVALID_ADDRESS) {
102     const uint32_t reg_num = reg_info->kinds[eRegisterKindLLDB];
103     addr_t reg_addr = m_reg_data_addr + reg_info->byte_offset;
104     Error error(WriteRegisterValueToMemory(reg_info, reg_addr,
105                                            reg_info->byte_size, reg_value));
106     m_reg_valid[reg_num] = false;
107     return error.Success();
108   }
109   return false;
110 }
111 
112 bool RegisterContextMemory::ReadAllRegisterValues(DataBufferSP &data_sp) {
113   if (m_reg_data_addr != LLDB_INVALID_ADDRESS) {
114     ProcessSP process_sp(CalculateProcess());
115     if (process_sp) {
116       Error error;
117       if (process_sp->ReadMemory(m_reg_data_addr, data_sp->GetBytes(),
118                                  data_sp->GetByteSize(),
119                                  error) == data_sp->GetByteSize()) {
120         SetAllRegisterValid(true);
121         return true;
122       }
123     }
124   }
125   return false;
126 }
127 
128 bool RegisterContextMemory::WriteAllRegisterValues(
129     const DataBufferSP &data_sp) {
130   if (m_reg_data_addr != LLDB_INVALID_ADDRESS) {
131     ProcessSP process_sp(CalculateProcess());
132     if (process_sp) {
133       Error error;
134       SetAllRegisterValid(false);
135       if (process_sp->WriteMemory(m_reg_data_addr, data_sp->GetBytes(),
136                                   data_sp->GetByteSize(),
137                                   error) == data_sp->GetByteSize())
138         return true;
139     }
140   }
141   return false;
142 }
143 
144 void RegisterContextMemory::SetAllRegisterData(
145     const lldb::DataBufferSP &data_sp) {
146   m_reg_data.SetData(data_sp);
147   SetAllRegisterValid(true);
148 }
149