1 //===-- ValueObjectRegister.cpp -------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Core/ValueObjectRegister.h"
10 
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/Value.h"
13 #include "lldb/Symbol/CompilerType.h"
14 #include "lldb/Symbol/TypeSystem.h"
15 #include "lldb/Target/ExecutionContext.h"
16 #include "lldb/Target/Process.h"
17 #include "lldb/Target/RegisterContext.h"
18 #include "lldb/Target/StackFrame.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Utility/DataExtractor.h"
21 #include "lldb/Utility/LLDBLog.h"
22 #include "lldb/Utility/Log.h"
23 #include "lldb/Utility/Scalar.h"
24 #include "lldb/Utility/Status.h"
25 #include "lldb/Utility/Stream.h"
26 
27 #include "llvm/ADT/StringRef.h"
28 
29 #include <cassert>
30 #include <memory>
31 #include <optional>
32 
33 namespace lldb_private {
34 class ExecutionContextScope;
35 }
36 
37 using namespace lldb;
38 using namespace lldb_private;
39 
40 #pragma mark ValueObjectRegisterSet
41 
42 ValueObjectSP
43 ValueObjectRegisterSet::Create(ExecutionContextScope *exe_scope,
44                                lldb::RegisterContextSP &reg_ctx_sp,
45                                uint32_t set_idx) {
46   auto manager_sp = ValueObjectManager::Create();
47   return (new ValueObjectRegisterSet(exe_scope, *manager_sp, reg_ctx_sp,
48                                      set_idx))
49       ->GetSP();
50 }
51 
52 ValueObjectRegisterSet::ValueObjectRegisterSet(ExecutionContextScope *exe_scope,
53                                                ValueObjectManager &manager,
54                                                lldb::RegisterContextSP &reg_ctx,
55                                                uint32_t reg_set_idx)
56     : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx),
57       m_reg_set(nullptr), m_reg_set_idx(reg_set_idx) {
58   assert(reg_ctx);
59   m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
60   if (m_reg_set) {
61     m_name.SetCString(m_reg_set->name);
62   }
63 }
64 
65 ValueObjectRegisterSet::~ValueObjectRegisterSet() = default;
66 
67 CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
68   return CompilerType();
69 }
70 
71 ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); }
72 
73 ConstString ValueObjectRegisterSet::GetQualifiedTypeName() {
74   return ConstString();
75 }
76 
77 size_t ValueObjectRegisterSet::CalculateNumChildren(uint32_t max) {
78   const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
79   if (reg_set) {
80     auto reg_count = reg_set->num_registers;
81     return reg_count <= max ? reg_count : max;
82   }
83   return 0;
84 }
85 
86 std::optional<uint64_t> ValueObjectRegisterSet::GetByteSize() { return 0; }
87 
88 bool ValueObjectRegisterSet::UpdateValue() {
89   m_error.Clear();
90   SetValueDidChange(false);
91   ExecutionContext exe_ctx(GetExecutionContextRef());
92   StackFrame *frame = exe_ctx.GetFramePtr();
93   if (frame == nullptr)
94     m_reg_ctx_sp.reset();
95   else {
96     m_reg_ctx_sp = frame->GetRegisterContext();
97     if (m_reg_ctx_sp) {
98       const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
99       if (reg_set == nullptr)
100         m_reg_ctx_sp.reset();
101       else if (m_reg_set != reg_set) {
102         SetValueDidChange(true);
103         m_name.SetCString(reg_set->name);
104       }
105     }
106   }
107   if (m_reg_ctx_sp) {
108     SetValueIsValid(true);
109   } else {
110     SetValueIsValid(false);
111     m_error.SetErrorToGenericError();
112     m_children.Clear();
113   }
114   return m_error.Success();
115 }
116 
117 ValueObject *ValueObjectRegisterSet::CreateChildAtIndex(
118     size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
119   ValueObject *valobj = nullptr;
120   if (m_reg_ctx_sp && m_reg_set) {
121     const size_t num_children = GetNumChildren();
122     if (idx < num_children)
123       valobj = new ValueObjectRegister(
124           *this, m_reg_ctx_sp,
125           m_reg_ctx_sp->GetRegisterInfoAtIndex(m_reg_set->registers[idx]));
126   }
127   return valobj;
128 }
129 
130 lldb::ValueObjectSP
131 ValueObjectRegisterSet::GetChildMemberWithName(llvm::StringRef name,
132                                                bool can_create) {
133   ValueObject *valobj = nullptr;
134   if (m_reg_ctx_sp && m_reg_set) {
135     const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(name);
136     if (reg_info != nullptr)
137       valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, reg_info);
138   }
139   if (valobj)
140     return valobj->GetSP();
141   else
142     return ValueObjectSP();
143 }
144 
145 size_t ValueObjectRegisterSet::GetIndexOfChildWithName(llvm::StringRef name) {
146   if (m_reg_ctx_sp && m_reg_set) {
147     const RegisterInfo *reg_info = m_reg_ctx_sp->GetRegisterInfoByName(name);
148     if (reg_info != nullptr)
149       return reg_info->kinds[eRegisterKindLLDB];
150   }
151   return UINT32_MAX;
152 }
153 
154 #pragma mark -
155 #pragma mark ValueObjectRegister
156 
157 void ValueObjectRegister::ConstructObject(const RegisterInfo *reg_info) {
158   if (reg_info) {
159     m_reg_info = *reg_info;
160     if (reg_info->name)
161       m_name.SetCString(reg_info->name);
162     else if (reg_info->alt_name)
163       m_name.SetCString(reg_info->alt_name);
164   }
165 }
166 
167 ValueObjectRegister::ValueObjectRegister(ValueObject &parent,
168                                          lldb::RegisterContextSP &reg_ctx_sp,
169                                          const RegisterInfo *reg_info)
170     : ValueObject(parent), m_reg_ctx_sp(reg_ctx_sp), m_reg_info(),
171       m_reg_value(), m_type_name(), m_compiler_type() {
172   assert(reg_ctx_sp.get());
173   ConstructObject(reg_info);
174 }
175 
176 ValueObjectSP ValueObjectRegister::Create(ExecutionContextScope *exe_scope,
177                                           lldb::RegisterContextSP &reg_ctx_sp,
178                                           const RegisterInfo *reg_info) {
179   auto manager_sp = ValueObjectManager::Create();
180   return (new ValueObjectRegister(exe_scope, *manager_sp, reg_ctx_sp, reg_info))
181       ->GetSP();
182 }
183 
184 ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
185                                          ValueObjectManager &manager,
186                                          lldb::RegisterContextSP &reg_ctx,
187                                          const RegisterInfo *reg_info)
188     : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), m_reg_info(),
189       m_reg_value(), m_type_name(), m_compiler_type() {
190   assert(reg_ctx);
191   ConstructObject(reg_info);
192 }
193 
194 ValueObjectRegister::~ValueObjectRegister() = default;
195 
196 CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
197   if (!m_compiler_type.IsValid()) {
198     ExecutionContext exe_ctx(GetExecutionContextRef());
199     if (auto *target = exe_ctx.GetTargetPtr()) {
200       if (auto *exe_module = target->GetExecutableModulePointer()) {
201         auto type_system_or_err =
202             exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
203         if (auto err = type_system_or_err.takeError()) {
204           LLDB_LOG_ERROR(GetLog(LLDBLog::Types), std::move(err),
205                          "Unable to get CompilerType from TypeSystem: {0}");
206         } else {
207           if (auto ts = *type_system_or_err)
208             m_compiler_type = ts->GetBuiltinTypeForEncodingAndBitSize(
209                 m_reg_info.encoding, m_reg_info.byte_size * 8);
210         }
211       }
212     }
213   }
214   return m_compiler_type;
215 }
216 
217 ConstString ValueObjectRegister::GetTypeName() {
218   if (m_type_name.IsEmpty())
219     m_type_name = GetCompilerType().GetTypeName();
220   return m_type_name;
221 }
222 
223 size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
224   ExecutionContext exe_ctx(GetExecutionContextRef());
225   auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
226   return children_count <= max ? children_count : max;
227 }
228 
229 std::optional<uint64_t> ValueObjectRegister::GetByteSize() {
230   return m_reg_info.byte_size;
231 }
232 
233 bool ValueObjectRegister::UpdateValue() {
234   m_error.Clear();
235   ExecutionContext exe_ctx(GetExecutionContextRef());
236   StackFrame *frame = exe_ctx.GetFramePtr();
237   if (frame == nullptr) {
238     m_reg_ctx_sp.reset();
239     m_reg_value.Clear();
240   }
241 
242   if (m_reg_ctx_sp) {
243     RegisterValue m_old_reg_value(m_reg_value);
244     if (m_reg_ctx_sp->ReadRegister(&m_reg_info, m_reg_value)) {
245       if (m_reg_value.GetData(m_data)) {
246         Process *process = exe_ctx.GetProcessPtr();
247         if (process)
248           m_data.SetAddressByteSize(process->GetAddressByteSize());
249         m_value.SetContext(Value::ContextType::RegisterInfo,
250                            (void *)&m_reg_info);
251         m_value.SetValueType(Value::ValueType::HostAddress);
252         m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
253         SetValueIsValid(true);
254         SetValueDidChange(!(m_old_reg_value == m_reg_value));
255         return true;
256       }
257     }
258   }
259 
260   SetValueIsValid(false);
261   m_error.SetErrorToGenericError();
262   return false;
263 }
264 
265 bool ValueObjectRegister::SetValueFromCString(const char *value_str,
266                                               Status &error) {
267   // The new value will be in the m_data.  Copy that into our register value.
268   error =
269       m_reg_value.SetValueFromString(&m_reg_info, llvm::StringRef(value_str));
270   if (!error.Success())
271     return false;
272 
273   if (!m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
274     error.SetErrorString("unable to write back to register");
275     return false;
276   }
277 
278   SetNeedsUpdate();
279   return true;
280 }
281 
282 bool ValueObjectRegister::SetData(DataExtractor &data, Status &error) {
283   error = m_reg_value.SetValueFromData(m_reg_info, data, 0, false);
284   if (!error.Success())
285     return false;
286 
287   if (!m_reg_ctx_sp->WriteRegister(&m_reg_info, m_reg_value)) {
288     error.SetErrorString("unable to write back to register");
289     return false;
290   }
291 
292   SetNeedsUpdate();
293   return true;
294 }
295 
296 bool ValueObjectRegister::ResolveValue(Scalar &scalar) {
297   if (UpdateValueIfNeeded(
298           false)) // make sure that you are up to date before returning anything
299     return m_reg_value.GetScalarValue(scalar);
300   return false;
301 }
302 
303 void ValueObjectRegister::GetExpressionPath(Stream &s,
304                                             GetExpressionPathFormat epformat) {
305   s.Printf("$%s", m_reg_info.name);
306 }
307