1 //===-- ValueObject.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/ValueObject.h"
10
11 #include "lldb/Core/Address.h"
12 #include "lldb/Core/Declaration.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ValueObjectCast.h"
15 #include "lldb/Core/ValueObjectChild.h"
16 #include "lldb/Core/ValueObjectConstResult.h"
17 #include "lldb/Core/ValueObjectDynamicValue.h"
18 #include "lldb/Core/ValueObjectMemory.h"
19 #include "lldb/Core/ValueObjectSyntheticFilter.h"
20 #include "lldb/DataFormatters/DataVisualization.h"
21 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
22 #include "lldb/DataFormatters/FormatManager.h"
23 #include "lldb/DataFormatters/StringPrinter.h"
24 #include "lldb/DataFormatters/TypeFormat.h"
25 #include "lldb/DataFormatters/TypeSummary.h"
26 #include "lldb/DataFormatters/ValueObjectPrinter.h"
27 #include "lldb/Expression/ExpressionVariable.h"
28 #include "lldb/Host/Config.h"
29 #include "lldb/Symbol/CompileUnit.h"
30 #include "lldb/Symbol/CompilerType.h"
31 #include "lldb/Symbol/SymbolContext.h"
32 #include "lldb/Symbol/Type.h"
33 #include "lldb/Symbol/Variable.h"
34 #include "lldb/Target/ExecutionContext.h"
35 #include "lldb/Target/Language.h"
36 #include "lldb/Target/LanguageRuntime.h"
37 #include "lldb/Target/Process.h"
38 #include "lldb/Target/StackFrame.h"
39 #include "lldb/Target/Target.h"
40 #include "lldb/Target/Thread.h"
41 #include "lldb/Target/ThreadList.h"
42 #include "lldb/Utility/DataBuffer.h"
43 #include "lldb/Utility/DataBufferHeap.h"
44 #include "lldb/Utility/Flags.h"
45 #include "lldb/Utility/Log.h"
46 #include "lldb/Utility/Logging.h"
47 #include "lldb/Utility/Scalar.h"
48 #include "lldb/Utility/Stream.h"
49 #include "lldb/Utility/StreamString.h"
50 #include "lldb/lldb-private-types.h"
51
52 #include "llvm/Support/Compiler.h"
53
54 #include <algorithm>
55 #include <cstdint>
56 #include <cstdlib>
57 #include <memory>
58 #include <tuple>
59
60 #include <cassert>
61 #include <cinttypes>
62 #include <cstdio>
63 #include <cstring>
64
65 #include <lldb/Core/ValueObject.h>
66
67 namespace lldb_private {
68 class ExecutionContextScope;
69 }
70 namespace lldb_private {
71 class SymbolContextScope;
72 }
73
74 using namespace lldb;
75 using namespace lldb_private;
76
77 static user_id_t g_value_obj_uid = 0;
78
79 // ValueObject constructor
ValueObject(ValueObject & parent)80 ValueObject::ValueObject(ValueObject &parent)
81 : m_parent(&parent), m_update_point(parent.GetUpdatePoint()),
82 m_manager(parent.GetManager()), m_id(++g_value_obj_uid) {
83 m_flags.m_is_synthetic_children_generated =
84 parent.m_flags.m_is_synthetic_children_generated;
85 m_data.SetByteOrder(parent.GetDataExtractor().GetByteOrder());
86 m_data.SetAddressByteSize(parent.GetDataExtractor().GetAddressByteSize());
87 m_manager->ManageObject(this);
88 }
89
90 // ValueObject constructor
ValueObject(ExecutionContextScope * exe_scope,ValueObjectManager & manager,AddressType child_ptr_or_ref_addr_type)91 ValueObject::ValueObject(ExecutionContextScope *exe_scope,
92 ValueObjectManager &manager,
93 AddressType child_ptr_or_ref_addr_type)
94 : m_update_point(exe_scope), m_manager(&manager),
95 m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type),
96 m_id(++g_value_obj_uid) {
97 if (exe_scope) {
98 TargetSP target_sp(exe_scope->CalculateTarget());
99 if (target_sp) {
100 const ArchSpec &arch = target_sp->GetArchitecture();
101 m_data.SetByteOrder(arch.GetByteOrder());
102 m_data.SetAddressByteSize(arch.GetAddressByteSize());
103 }
104 }
105 m_manager->ManageObject(this);
106 }
107
108 // Destructor
109 ValueObject::~ValueObject() = default;
110
UpdateValueIfNeeded(bool update_format)111 bool ValueObject::UpdateValueIfNeeded(bool update_format) {
112
113 bool did_change_formats = false;
114
115 if (update_format)
116 did_change_formats = UpdateFormatsIfNeeded();
117
118 // If this is a constant value, then our success is predicated on whether we
119 // have an error or not
120 if (GetIsConstant()) {
121 // if you are constant, things might still have changed behind your back
122 // (e.g. you are a frozen object and things have changed deeper than you
123 // cared to freeze-dry yourself) in this case, your value has not changed,
124 // but "computed" entries might have, so you might now have a different
125 // summary, or a different object description. clear these so we will
126 // recompute them
127 if (update_format && !did_change_formats)
128 ClearUserVisibleData(eClearUserVisibleDataItemsSummary |
129 eClearUserVisibleDataItemsDescription);
130 return m_error.Success();
131 }
132
133 bool first_update = IsChecksumEmpty();
134
135 if (NeedsUpdating()) {
136 m_update_point.SetUpdated();
137
138 // Save the old value using swap to avoid a string copy which also will
139 // clear our m_value_str
140 if (m_value_str.empty()) {
141 m_flags.m_old_value_valid = false;
142 } else {
143 m_flags.m_old_value_valid = true;
144 m_old_value_str.swap(m_value_str);
145 ClearUserVisibleData(eClearUserVisibleDataItemsValue);
146 }
147
148 ClearUserVisibleData();
149
150 if (IsInScope()) {
151 const bool value_was_valid = GetValueIsValid();
152 SetValueDidChange(false);
153
154 m_error.Clear();
155
156 // Call the pure virtual function to update the value
157
158 bool need_compare_checksums = false;
159 llvm::SmallVector<uint8_t, 16> old_checksum;
160
161 if (!first_update && CanProvideValue()) {
162 need_compare_checksums = true;
163 old_checksum.resize(m_value_checksum.size());
164 std::copy(m_value_checksum.begin(), m_value_checksum.end(),
165 old_checksum.begin());
166 }
167
168 bool success = UpdateValue();
169
170 SetValueIsValid(success);
171
172 if (success) {
173 UpdateChildrenAddressType();
174 const uint64_t max_checksum_size = 128;
175 m_data.Checksum(m_value_checksum, max_checksum_size);
176 } else {
177 need_compare_checksums = false;
178 m_value_checksum.clear();
179 }
180
181 assert(!need_compare_checksums ||
182 (!old_checksum.empty() && !m_value_checksum.empty()));
183
184 if (first_update)
185 SetValueDidChange(false);
186 else if (!m_flags.m_value_did_change && !success) {
187 // The value wasn't gotten successfully, so we mark this as changed if
188 // the value used to be valid and now isn't
189 SetValueDidChange(value_was_valid);
190 } else if (need_compare_checksums) {
191 SetValueDidChange(memcmp(&old_checksum[0], &m_value_checksum[0],
192 m_value_checksum.size()));
193 }
194
195 } else {
196 m_error.SetErrorString("out of scope");
197 }
198 }
199 return m_error.Success();
200 }
201
UpdateFormatsIfNeeded()202 bool ValueObject::UpdateFormatsIfNeeded() {
203 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
204 LLDB_LOGF(log,
205 "[%s %p] checking for FormatManager revisions. ValueObject "
206 "rev: %d - Global rev: %d",
207 GetName().GetCString(), static_cast<void *>(this),
208 m_last_format_mgr_revision,
209 DataVisualization::GetCurrentRevision());
210
211 bool any_change = false;
212
213 if ((m_last_format_mgr_revision != DataVisualization::GetCurrentRevision())) {
214 m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
215 any_change = true;
216
217 SetValueFormat(DataVisualization::GetFormat(*this, eNoDynamicValues));
218 SetSummaryFormat(
219 DataVisualization::GetSummaryFormat(*this, GetDynamicValueType()));
220 #if LLDB_ENABLE_PYTHON
221 SetSyntheticChildren(
222 DataVisualization::GetSyntheticChildren(*this, GetDynamicValueType()));
223 #endif
224 }
225
226 return any_change;
227 }
228
SetNeedsUpdate()229 void ValueObject::SetNeedsUpdate() {
230 m_update_point.SetNeedsUpdate();
231 // We have to clear the value string here so ConstResult children will notice
232 // if their values are changed by hand (i.e. with SetValueAsCString).
233 ClearUserVisibleData(eClearUserVisibleDataItemsValue);
234 }
235
ClearDynamicTypeInformation()236 void ValueObject::ClearDynamicTypeInformation() {
237 m_flags.m_children_count_valid = false;
238 m_flags.m_did_calculate_complete_objc_class_type = false;
239 m_last_format_mgr_revision = 0;
240 m_override_type = CompilerType();
241 SetValueFormat(lldb::TypeFormatImplSP());
242 SetSummaryFormat(lldb::TypeSummaryImplSP());
243 SetSyntheticChildren(lldb::SyntheticChildrenSP());
244 }
245
MaybeCalculateCompleteType()246 CompilerType ValueObject::MaybeCalculateCompleteType() {
247 CompilerType compiler_type(GetCompilerTypeImpl());
248
249 if (m_flags.m_did_calculate_complete_objc_class_type) {
250 if (m_override_type.IsValid())
251 return m_override_type;
252 else
253 return compiler_type;
254 }
255
256 m_flags.m_did_calculate_complete_objc_class_type = true;
257
258 ProcessSP process_sp(
259 GetUpdatePoint().GetExecutionContextRef().GetProcessSP());
260
261 if (!process_sp)
262 return compiler_type;
263
264 if (auto *runtime =
265 process_sp->GetLanguageRuntime(GetObjectRuntimeLanguage())) {
266 if (llvm::Optional<CompilerType> complete_type =
267 runtime->GetRuntimeType(compiler_type)) {
268 m_override_type = complete_type.getValue();
269 if (m_override_type.IsValid())
270 return m_override_type;
271 }
272 }
273 return compiler_type;
274 }
275
276
277
GetDataExtractor()278 DataExtractor &ValueObject::GetDataExtractor() {
279 UpdateValueIfNeeded(false);
280 return m_data;
281 }
282
GetError()283 const Status &ValueObject::GetError() {
284 UpdateValueIfNeeded(false);
285 return m_error;
286 }
287
GetLocationAsCStringImpl(const Value & value,const DataExtractor & data)288 const char *ValueObject::GetLocationAsCStringImpl(const Value &value,
289 const DataExtractor &data) {
290 if (UpdateValueIfNeeded(false)) {
291 if (m_location_str.empty()) {
292 StreamString sstr;
293
294 Value::ValueType value_type = value.GetValueType();
295
296 switch (value_type) {
297 case Value::ValueType::Invalid:
298 m_location_str = "invalid";
299 break;
300 case Value::ValueType::Scalar:
301 if (value.GetContextType() == Value::ContextType::RegisterInfo) {
302 RegisterInfo *reg_info = value.GetRegisterInfo();
303 if (reg_info) {
304 if (reg_info->name)
305 m_location_str = reg_info->name;
306 else if (reg_info->alt_name)
307 m_location_str = reg_info->alt_name;
308 if (m_location_str.empty())
309 m_location_str = (reg_info->encoding == lldb::eEncodingVector)
310 ? "vector"
311 : "scalar";
312 }
313 }
314 if (m_location_str.empty())
315 m_location_str = "scalar";
316 break;
317
318 case Value::ValueType::LoadAddress:
319 case Value::ValueType::FileAddress:
320 case Value::ValueType::HostAddress: {
321 uint32_t addr_nibble_size = data.GetAddressByteSize() * 2;
322 sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size,
323 value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
324 m_location_str = std::string(sstr.GetString());
325 } break;
326 }
327 }
328 }
329 return m_location_str.c_str();
330 }
331
ResolveValue(Scalar & scalar)332 bool ValueObject::ResolveValue(Scalar &scalar) {
333 if (UpdateValueIfNeeded(
334 false)) // make sure that you are up to date before returning anything
335 {
336 ExecutionContext exe_ctx(GetExecutionContextRef());
337 Value tmp_value(m_value);
338 scalar = tmp_value.ResolveValue(&exe_ctx);
339 if (scalar.IsValid()) {
340 const uint32_t bitfield_bit_size = GetBitfieldBitSize();
341 if (bitfield_bit_size)
342 return scalar.ExtractBitfield(bitfield_bit_size,
343 GetBitfieldBitOffset());
344 return true;
345 }
346 }
347 return false;
348 }
349
IsLogicalTrue(Status & error)350 bool ValueObject::IsLogicalTrue(Status &error) {
351 if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {
352 LazyBool is_logical_true = language->IsLogicalTrue(*this, error);
353 switch (is_logical_true) {
354 case eLazyBoolYes:
355 case eLazyBoolNo:
356 return (is_logical_true == true);
357 case eLazyBoolCalculate:
358 break;
359 }
360 }
361
362 Scalar scalar_value;
363
364 if (!ResolveValue(scalar_value)) {
365 error.SetErrorString("failed to get a scalar result");
366 return false;
367 }
368
369 bool ret;
370 ret = scalar_value.ULongLong(1) != 0;
371 error.Clear();
372 return ret;
373 }
374
GetChildAtIndex(size_t idx,bool can_create)375 ValueObjectSP ValueObject::GetChildAtIndex(size_t idx, bool can_create) {
376 ValueObjectSP child_sp;
377 // We may need to update our value if we are dynamic
378 if (IsPossibleDynamicType())
379 UpdateValueIfNeeded(false);
380 if (idx < GetNumChildren()) {
381 // Check if we have already made the child value object?
382 if (can_create && !m_children.HasChildAtIndex(idx)) {
383 // No we haven't created the child at this index, so lets have our
384 // subclass do it and cache the result for quick future access.
385 m_children.SetChildAtIndex(idx, CreateChildAtIndex(idx, false, 0));
386 }
387
388 ValueObject *child = m_children.GetChildAtIndex(idx);
389 if (child != nullptr)
390 return child->GetSP();
391 }
392 return child_sp;
393 }
394
395 lldb::ValueObjectSP
GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,size_t * index_of_error)396 ValueObject::GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
397 size_t *index_of_error) {
398 if (idxs.size() == 0)
399 return GetSP();
400 ValueObjectSP root(GetSP());
401 for (size_t idx : idxs) {
402 root = root->GetChildAtIndex(idx, true);
403 if (!root) {
404 if (index_of_error)
405 *index_of_error = idx;
406 return root;
407 }
408 }
409 return root;
410 }
411
GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t,bool>> idxs,size_t * index_of_error)412 lldb::ValueObjectSP ValueObject::GetChildAtIndexPath(
413 llvm::ArrayRef<std::pair<size_t, bool>> idxs, size_t *index_of_error) {
414 if (idxs.size() == 0)
415 return GetSP();
416 ValueObjectSP root(GetSP());
417 for (std::pair<size_t, bool> idx : idxs) {
418 root = root->GetChildAtIndex(idx.first, idx.second);
419 if (!root) {
420 if (index_of_error)
421 *index_of_error = idx.first;
422 return root;
423 }
424 }
425 return root;
426 }
427
428 lldb::ValueObjectSP
GetChildAtNamePath(llvm::ArrayRef<ConstString> names,ConstString * name_of_error)429 ValueObject::GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
430 ConstString *name_of_error) {
431 if (names.size() == 0)
432 return GetSP();
433 ValueObjectSP root(GetSP());
434 for (ConstString name : names) {
435 root = root->GetChildMemberWithName(name, true);
436 if (!root) {
437 if (name_of_error)
438 *name_of_error = name;
439 return root;
440 }
441 }
442 return root;
443 }
444
GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString,bool>> names,ConstString * name_of_error)445 lldb::ValueObjectSP ValueObject::GetChildAtNamePath(
446 llvm::ArrayRef<std::pair<ConstString, bool>> names,
447 ConstString *name_of_error) {
448 if (names.size() == 0)
449 return GetSP();
450 ValueObjectSP root(GetSP());
451 for (std::pair<ConstString, bool> name : names) {
452 root = root->GetChildMemberWithName(name.first, name.second);
453 if (!root) {
454 if (name_of_error)
455 *name_of_error = name.first;
456 return root;
457 }
458 }
459 return root;
460 }
461
GetIndexOfChildWithName(ConstString name)462 size_t ValueObject::GetIndexOfChildWithName(ConstString name) {
463 bool omit_empty_base_classes = true;
464 return GetCompilerType().GetIndexOfChildWithName(name.GetCString(),
465 omit_empty_base_classes);
466 }
467
GetChildMemberWithName(ConstString name,bool can_create)468 ValueObjectSP ValueObject::GetChildMemberWithName(ConstString name,
469 bool can_create) {
470 // We may need to update our value if we are dynamic.
471 if (IsPossibleDynamicType())
472 UpdateValueIfNeeded(false);
473
474 // When getting a child by name, it could be buried inside some base classes
475 // (which really aren't part of the expression path), so we need a vector of
476 // indexes that can get us down to the correct child.
477 std::vector<uint32_t> child_indexes;
478 bool omit_empty_base_classes = true;
479
480 if (!GetCompilerType().IsValid())
481 return ValueObjectSP();
482
483 const size_t num_child_indexes =
484 GetCompilerType().GetIndexOfChildMemberWithName(
485 name.GetCString(), omit_empty_base_classes, child_indexes);
486 if (num_child_indexes == 0)
487 return nullptr;
488
489 ValueObjectSP child_sp = GetSP();
490 for (uint32_t idx : child_indexes)
491 if (child_sp)
492 child_sp = child_sp->GetChildAtIndex(idx, can_create);
493 return child_sp;
494 }
495
GetNumChildren(uint32_t max)496 size_t ValueObject::GetNumChildren(uint32_t max) {
497 UpdateValueIfNeeded();
498
499 if (max < UINT32_MAX) {
500 if (m_flags.m_children_count_valid) {
501 size_t children_count = m_children.GetChildrenCount();
502 return children_count <= max ? children_count : max;
503 } else
504 return CalculateNumChildren(max);
505 }
506
507 if (!m_flags.m_children_count_valid) {
508 SetNumChildren(CalculateNumChildren());
509 }
510 return m_children.GetChildrenCount();
511 }
512
MightHaveChildren()513 bool ValueObject::MightHaveChildren() {
514 bool has_children = false;
515 const uint32_t type_info = GetTypeInfo();
516 if (type_info) {
517 if (type_info & (eTypeHasChildren | eTypeIsPointer | eTypeIsReference))
518 has_children = true;
519 } else {
520 has_children = GetNumChildren() > 0;
521 }
522 return has_children;
523 }
524
525 // Should only be called by ValueObject::GetNumChildren()
SetNumChildren(size_t num_children)526 void ValueObject::SetNumChildren(size_t num_children) {
527 m_flags.m_children_count_valid = true;
528 m_children.SetChildrenCount(num_children);
529 }
530
CreateChildAtIndex(size_t idx,bool synthetic_array_member,int32_t synthetic_index)531 ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
532 bool synthetic_array_member,
533 int32_t synthetic_index) {
534 ValueObject *valobj = nullptr;
535
536 bool omit_empty_base_classes = true;
537 bool ignore_array_bounds = synthetic_array_member;
538 std::string child_name_str;
539 uint32_t child_byte_size = 0;
540 int32_t child_byte_offset = 0;
541 uint32_t child_bitfield_bit_size = 0;
542 uint32_t child_bitfield_bit_offset = 0;
543 bool child_is_base_class = false;
544 bool child_is_deref_of_parent = false;
545 uint64_t language_flags = 0;
546
547 const bool transparent_pointers = !synthetic_array_member;
548 CompilerType child_compiler_type;
549
550 ExecutionContext exe_ctx(GetExecutionContextRef());
551
552 child_compiler_type = GetCompilerType().GetChildCompilerTypeAtIndex(
553 &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
554 ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
555 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
556 child_is_deref_of_parent, this, language_flags);
557 if (child_compiler_type) {
558 if (synthetic_index)
559 child_byte_offset += child_byte_size * synthetic_index;
560
561 ConstString child_name;
562 if (!child_name_str.empty())
563 child_name.SetCString(child_name_str.c_str());
564
565 valobj = new ValueObjectChild(
566 *this, child_compiler_type, child_name, child_byte_size,
567 child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
568 child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
569 language_flags);
570 }
571
572 // In case of an incomplete type, try to use the ValueObject's
573 // synthetic value to create the child ValueObject.
574 if (!valobj && synthetic_array_member) {
575 if (ValueObjectSP synth_valobj_sp = GetSyntheticValue()) {
576 valobj = synth_valobj_sp
577 ->GetChildAtIndex(synthetic_index, synthetic_array_member)
578 .get();
579 }
580 }
581
582 return valobj;
583 }
584
GetSummaryAsCString(TypeSummaryImpl * summary_ptr,std::string & destination,lldb::LanguageType lang)585 bool ValueObject::GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
586 std::string &destination,
587 lldb::LanguageType lang) {
588 return GetSummaryAsCString(summary_ptr, destination,
589 TypeSummaryOptions().SetLanguage(lang));
590 }
591
GetSummaryAsCString(TypeSummaryImpl * summary_ptr,std::string & destination,const TypeSummaryOptions & options)592 bool ValueObject::GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
593 std::string &destination,
594 const TypeSummaryOptions &options) {
595 destination.clear();
596
597 // ideally we would like to bail out if passing NULL, but if we do so we end
598 // up not providing the summary for function pointers anymore
599 if (/*summary_ptr == NULL ||*/ m_flags.m_is_getting_summary)
600 return false;
601
602 m_flags.m_is_getting_summary = true;
603
604 TypeSummaryOptions actual_options(options);
605
606 if (actual_options.GetLanguage() == lldb::eLanguageTypeUnknown)
607 actual_options.SetLanguage(GetPreferredDisplayLanguage());
608
609 // this is a hot path in code and we prefer to avoid setting this string all
610 // too often also clearing out other information that we might care to see in
611 // a crash log. might be useful in very specific situations though.
612 /*Host::SetCrashDescriptionWithFormat("Trying to fetch a summary for %s %s.
613 Summary provider's description is %s",
614 GetTypeName().GetCString(),
615 GetName().GetCString(),
616 summary_ptr->GetDescription().c_str());*/
617
618 if (UpdateValueIfNeeded(false) && summary_ptr) {
619 if (HasSyntheticValue())
620 m_synthetic_value->UpdateValueIfNeeded(); // the summary might depend on
621 // the synthetic children being
622 // up-to-date (e.g. ${svar%#})
623 summary_ptr->FormatObject(this, destination, actual_options);
624 }
625 m_flags.m_is_getting_summary = false;
626 return !destination.empty();
627 }
628
GetSummaryAsCString(lldb::LanguageType lang)629 const char *ValueObject::GetSummaryAsCString(lldb::LanguageType lang) {
630 if (UpdateValueIfNeeded(true) && m_summary_str.empty()) {
631 TypeSummaryOptions summary_options;
632 summary_options.SetLanguage(lang);
633 GetSummaryAsCString(GetSummaryFormat().get(), m_summary_str,
634 summary_options);
635 }
636 if (m_summary_str.empty())
637 return nullptr;
638 return m_summary_str.c_str();
639 }
640
GetSummaryAsCString(std::string & destination,const TypeSummaryOptions & options)641 bool ValueObject::GetSummaryAsCString(std::string &destination,
642 const TypeSummaryOptions &options) {
643 return GetSummaryAsCString(GetSummaryFormat().get(), destination, options);
644 }
645
IsCStringContainer(bool check_pointer)646 bool ValueObject::IsCStringContainer(bool check_pointer) {
647 CompilerType pointee_or_element_compiler_type;
648 const Flags type_flags(GetTypeInfo(&pointee_or_element_compiler_type));
649 bool is_char_arr_ptr(type_flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
650 pointee_or_element_compiler_type.IsCharType());
651 if (!is_char_arr_ptr)
652 return false;
653 if (!check_pointer)
654 return true;
655 if (type_flags.Test(eTypeIsArray))
656 return true;
657 addr_t cstr_address = LLDB_INVALID_ADDRESS;
658 AddressType cstr_address_type = eAddressTypeInvalid;
659 cstr_address = GetPointerValue(&cstr_address_type);
660 return (cstr_address != LLDB_INVALID_ADDRESS);
661 }
662
GetPointeeData(DataExtractor & data,uint32_t item_idx,uint32_t item_count)663 size_t ValueObject::GetPointeeData(DataExtractor &data, uint32_t item_idx,
664 uint32_t item_count) {
665 CompilerType pointee_or_element_compiler_type;
666 const uint32_t type_info = GetTypeInfo(&pointee_or_element_compiler_type);
667 const bool is_pointer_type = type_info & eTypeIsPointer;
668 const bool is_array_type = type_info & eTypeIsArray;
669 if (!(is_pointer_type || is_array_type))
670 return 0;
671
672 if (item_count == 0)
673 return 0;
674
675 ExecutionContext exe_ctx(GetExecutionContextRef());
676
677 llvm::Optional<uint64_t> item_type_size =
678 pointee_or_element_compiler_type.GetByteSize(
679 exe_ctx.GetBestExecutionContextScope());
680 if (!item_type_size)
681 return 0;
682 const uint64_t bytes = item_count * *item_type_size;
683 const uint64_t offset = item_idx * *item_type_size;
684
685 if (item_idx == 0 && item_count == 1) // simply a deref
686 {
687 if (is_pointer_type) {
688 Status error;
689 ValueObjectSP pointee_sp = Dereference(error);
690 if (error.Fail() || pointee_sp.get() == nullptr)
691 return 0;
692 return pointee_sp->GetData(data, error);
693 } else {
694 ValueObjectSP child_sp = GetChildAtIndex(0, true);
695 if (child_sp.get() == nullptr)
696 return 0;
697 Status error;
698 return child_sp->GetData(data, error);
699 }
700 return true;
701 } else /* (items > 1) */
702 {
703 Status error;
704 lldb_private::DataBufferHeap *heap_buf_ptr = nullptr;
705 lldb::DataBufferSP data_sp(heap_buf_ptr =
706 new lldb_private::DataBufferHeap());
707
708 AddressType addr_type;
709 lldb::addr_t addr = is_pointer_type ? GetPointerValue(&addr_type)
710 : GetAddressOf(true, &addr_type);
711
712 switch (addr_type) {
713 case eAddressTypeFile: {
714 ModuleSP module_sp(GetModule());
715 if (module_sp) {
716 addr = addr + offset;
717 Address so_addr;
718 module_sp->ResolveFileAddress(addr, so_addr);
719 ExecutionContext exe_ctx(GetExecutionContextRef());
720 Target *target = exe_ctx.GetTargetPtr();
721 if (target) {
722 heap_buf_ptr->SetByteSize(bytes);
723 size_t bytes_read = target->ReadMemory(
724 so_addr, heap_buf_ptr->GetBytes(), bytes, error, true);
725 if (error.Success()) {
726 data.SetData(data_sp);
727 return bytes_read;
728 }
729 }
730 }
731 } break;
732 case eAddressTypeLoad: {
733 ExecutionContext exe_ctx(GetExecutionContextRef());
734 Process *process = exe_ctx.GetProcessPtr();
735 if (process) {
736 heap_buf_ptr->SetByteSize(bytes);
737 size_t bytes_read = process->ReadMemory(
738 addr + offset, heap_buf_ptr->GetBytes(), bytes, error);
739 if (error.Success() || bytes_read > 0) {
740 data.SetData(data_sp);
741 return bytes_read;
742 }
743 }
744 } break;
745 case eAddressTypeHost: {
746 auto max_bytes =
747 GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope());
748 if (max_bytes && *max_bytes > offset) {
749 size_t bytes_read = std::min<uint64_t>(*max_bytes - offset, bytes);
750 addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
751 if (addr == 0 || addr == LLDB_INVALID_ADDRESS)
752 break;
753 heap_buf_ptr->CopyData((uint8_t *)(addr + offset), bytes_read);
754 data.SetData(data_sp);
755 return bytes_read;
756 }
757 } break;
758 case eAddressTypeInvalid:
759 break;
760 }
761 }
762 return 0;
763 }
764
GetData(DataExtractor & data,Status & error)765 uint64_t ValueObject::GetData(DataExtractor &data, Status &error) {
766 UpdateValueIfNeeded(false);
767 ExecutionContext exe_ctx(GetExecutionContextRef());
768 error = m_value.GetValueAsData(&exe_ctx, data, GetModule().get());
769 if (error.Fail()) {
770 if (m_data.GetByteSize()) {
771 data = m_data;
772 error.Clear();
773 return data.GetByteSize();
774 } else {
775 return 0;
776 }
777 }
778 data.SetAddressByteSize(m_data.GetAddressByteSize());
779 data.SetByteOrder(m_data.GetByteOrder());
780 return data.GetByteSize();
781 }
782
SetData(DataExtractor & data,Status & error)783 bool ValueObject::SetData(DataExtractor &data, Status &error) {
784 error.Clear();
785 // Make sure our value is up to date first so that our location and location
786 // type is valid.
787 if (!UpdateValueIfNeeded(false)) {
788 error.SetErrorString("unable to read value");
789 return false;
790 }
791
792 uint64_t count = 0;
793 const Encoding encoding = GetCompilerType().GetEncoding(count);
794
795 const size_t byte_size = GetByteSize().getValueOr(0);
796
797 Value::ValueType value_type = m_value.GetValueType();
798
799 switch (value_type) {
800 case Value::ValueType::Invalid:
801 error.SetErrorString("invalid location");
802 return false;
803 case Value::ValueType::Scalar: {
804 Status set_error =
805 m_value.GetScalar().SetValueFromData(data, encoding, byte_size);
806
807 if (!set_error.Success()) {
808 error.SetErrorStringWithFormat("unable to set scalar value: %s",
809 set_error.AsCString());
810 return false;
811 }
812 } break;
813 case Value::ValueType::LoadAddress: {
814 // If it is a load address, then the scalar value is the storage location
815 // of the data, and we have to shove this value down to that load location.
816 ExecutionContext exe_ctx(GetExecutionContextRef());
817 Process *process = exe_ctx.GetProcessPtr();
818 if (process) {
819 addr_t target_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
820 size_t bytes_written = process->WriteMemory(
821 target_addr, data.GetDataStart(), byte_size, error);
822 if (!error.Success())
823 return false;
824 if (bytes_written != byte_size) {
825 error.SetErrorString("unable to write value to memory");
826 return false;
827 }
828 }
829 } break;
830 case Value::ValueType::HostAddress: {
831 // If it is a host address, then we stuff the scalar as a DataBuffer into
832 // the Value's data.
833 DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
834 m_data.SetData(buffer_sp, 0);
835 data.CopyByteOrderedData(0, byte_size,
836 const_cast<uint8_t *>(m_data.GetDataStart()),
837 byte_size, m_data.GetByteOrder());
838 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
839 } break;
840 case Value::ValueType::FileAddress:
841 break;
842 }
843
844 // If we have reached this point, then we have successfully changed the
845 // value.
846 SetNeedsUpdate();
847 return true;
848 }
849
CopyStringDataToBufferSP(const StreamString & source,lldb::DataBufferSP & destination)850 static bool CopyStringDataToBufferSP(const StreamString &source,
851 lldb::DataBufferSP &destination) {
852 destination = std::make_shared<DataBufferHeap>(source.GetSize() + 1, 0);
853 memcpy(destination->GetBytes(), source.GetString().data(), source.GetSize());
854 return true;
855 }
856
857 std::pair<size_t, bool>
ReadPointedString(lldb::DataBufferSP & buffer_sp,Status & error,uint32_t max_length,bool honor_array,Format item_format)858 ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
859 uint32_t max_length, bool honor_array,
860 Format item_format) {
861 bool was_capped = false;
862 StreamString s;
863 ExecutionContext exe_ctx(GetExecutionContextRef());
864 Target *target = exe_ctx.GetTargetPtr();
865
866 if (!target) {
867 s << "<no target to read from>";
868 error.SetErrorString("no target to read from");
869 CopyStringDataToBufferSP(s, buffer_sp);
870 return {0, was_capped};
871 }
872
873 if (max_length == 0)
874 max_length = target->GetMaximumSizeOfStringSummary();
875
876 size_t bytes_read = 0;
877 size_t total_bytes_read = 0;
878
879 CompilerType compiler_type = GetCompilerType();
880 CompilerType elem_or_pointee_compiler_type;
881 const Flags type_flags(GetTypeInfo(&elem_or_pointee_compiler_type));
882 if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
883 elem_or_pointee_compiler_type.IsCharType()) {
884 addr_t cstr_address = LLDB_INVALID_ADDRESS;
885 AddressType cstr_address_type = eAddressTypeInvalid;
886
887 size_t cstr_len = 0;
888 bool capped_data = false;
889 const bool is_array = type_flags.Test(eTypeIsArray);
890 if (is_array) {
891 // We have an array
892 uint64_t array_size = 0;
893 if (compiler_type.IsArrayType(nullptr, &array_size)) {
894 cstr_len = array_size;
895 if (cstr_len > max_length) {
896 capped_data = true;
897 cstr_len = max_length;
898 }
899 }
900 cstr_address = GetAddressOf(true, &cstr_address_type);
901 } else {
902 // We have a pointer
903 cstr_address = GetPointerValue(&cstr_address_type);
904 }
905
906 if (cstr_address == 0 || cstr_address == LLDB_INVALID_ADDRESS) {
907 if (cstr_address_type == eAddressTypeHost && is_array) {
908 const char *cstr = GetDataExtractor().PeekCStr(0);
909 if (cstr == nullptr) {
910 s << "<invalid address>";
911 error.SetErrorString("invalid address");
912 CopyStringDataToBufferSP(s, buffer_sp);
913 return {0, was_capped};
914 }
915 buffer_sp = std::make_shared<DataBufferHeap>(cstr_len, 0);
916 memcpy(buffer_sp->GetBytes(), cstr, cstr_len);
917 return {cstr_len, was_capped};
918 } else {
919 s << "<invalid address>";
920 error.SetErrorString("invalid address");
921 CopyStringDataToBufferSP(s, buffer_sp);
922 return {0, was_capped};
923 }
924 }
925
926 Address cstr_so_addr(cstr_address);
927 DataExtractor data;
928 if (cstr_len > 0 && honor_array) {
929 // I am using GetPointeeData() here to abstract the fact that some
930 // ValueObjects are actually frozen pointers in the host but the pointed-
931 // to data lives in the debuggee, and GetPointeeData() automatically
932 // takes care of this
933 GetPointeeData(data, 0, cstr_len);
934
935 if ((bytes_read = data.GetByteSize()) > 0) {
936 total_bytes_read = bytes_read;
937 for (size_t offset = 0; offset < bytes_read; offset++)
938 s.Printf("%c", *data.PeekData(offset, 1));
939 if (capped_data)
940 was_capped = true;
941 }
942 } else {
943 cstr_len = max_length;
944 const size_t k_max_buf_size = 64;
945
946 size_t offset = 0;
947
948 int cstr_len_displayed = -1;
949 bool capped_cstr = false;
950 // I am using GetPointeeData() here to abstract the fact that some
951 // ValueObjects are actually frozen pointers in the host but the pointed-
952 // to data lives in the debuggee, and GetPointeeData() automatically
953 // takes care of this
954 while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) {
955 total_bytes_read += bytes_read;
956 const char *cstr = data.PeekCStr(0);
957 size_t len = strnlen(cstr, k_max_buf_size);
958 if (cstr_len_displayed < 0)
959 cstr_len_displayed = len;
960
961 if (len == 0)
962 break;
963 cstr_len_displayed += len;
964 if (len > bytes_read)
965 len = bytes_read;
966 if (len > cstr_len)
967 len = cstr_len;
968
969 for (size_t offset = 0; offset < bytes_read; offset++)
970 s.Printf("%c", *data.PeekData(offset, 1));
971
972 if (len < k_max_buf_size)
973 break;
974
975 if (len >= cstr_len) {
976 capped_cstr = true;
977 break;
978 }
979
980 cstr_len -= len;
981 offset += len;
982 }
983
984 if (cstr_len_displayed >= 0) {
985 if (capped_cstr)
986 was_capped = true;
987 }
988 }
989 } else {
990 error.SetErrorString("not a string object");
991 s << "<not a string object>";
992 }
993 CopyStringDataToBufferSP(s, buffer_sp);
994 return {total_bytes_read, was_capped};
995 }
996
GetObjectDescription()997 const char *ValueObject::GetObjectDescription() {
998 if (!UpdateValueIfNeeded(true))
999 return nullptr;
1000
1001 // Return cached value.
1002 if (!m_object_desc_str.empty())
1003 return m_object_desc_str.c_str();
1004
1005 ExecutionContext exe_ctx(GetExecutionContextRef());
1006 Process *process = exe_ctx.GetProcessPtr();
1007 if (!process)
1008 return nullptr;
1009
1010 // Returns the object description produced by one language runtime.
1011 auto get_object_description = [&](LanguageType language) -> const char * {
1012 if (LanguageRuntime *runtime = process->GetLanguageRuntime(language)) {
1013 StreamString s;
1014 if (runtime->GetObjectDescription(s, *this)) {
1015 m_object_desc_str.append(std::string(s.GetString()));
1016 return m_object_desc_str.c_str();
1017 }
1018 }
1019 return nullptr;
1020 };
1021
1022 // Try the native language runtime first.
1023 LanguageType native_language = GetObjectRuntimeLanguage();
1024 if (const char *desc = get_object_description(native_language))
1025 return desc;
1026
1027 // Try the Objective-C language runtime. This fallback is necessary
1028 // for Objective-C++ and mixed Objective-C / C++ programs.
1029 if (Language::LanguageIsCFamily(native_language))
1030 return get_object_description(eLanguageTypeObjC);
1031 return nullptr;
1032 }
1033
GetValueAsCString(const lldb_private::TypeFormatImpl & format,std::string & destination)1034 bool ValueObject::GetValueAsCString(const lldb_private::TypeFormatImpl &format,
1035 std::string &destination) {
1036 if (UpdateValueIfNeeded(false))
1037 return format.FormatObject(this, destination);
1038 else
1039 return false;
1040 }
1041
GetValueAsCString(lldb::Format format,std::string & destination)1042 bool ValueObject::GetValueAsCString(lldb::Format format,
1043 std::string &destination) {
1044 return GetValueAsCString(TypeFormatImpl_Format(format), destination);
1045 }
1046
GetValueAsCString()1047 const char *ValueObject::GetValueAsCString() {
1048 if (UpdateValueIfNeeded(true)) {
1049 lldb::TypeFormatImplSP format_sp;
1050 lldb::Format my_format = GetFormat();
1051 if (my_format == lldb::eFormatDefault) {
1052 if (m_type_format_sp)
1053 format_sp = m_type_format_sp;
1054 else {
1055 if (m_flags.m_is_bitfield_for_scalar)
1056 my_format = eFormatUnsigned;
1057 else {
1058 if (m_value.GetContextType() == Value::ContextType::RegisterInfo) {
1059 const RegisterInfo *reg_info = m_value.GetRegisterInfo();
1060 if (reg_info)
1061 my_format = reg_info->format;
1062 } else {
1063 my_format = GetValue().GetCompilerType().GetFormat();
1064 }
1065 }
1066 }
1067 }
1068 if (my_format != m_last_format || m_value_str.empty()) {
1069 m_last_format = my_format;
1070 if (!format_sp)
1071 format_sp = std::make_shared<TypeFormatImpl_Format>(my_format);
1072 if (GetValueAsCString(*format_sp.get(), m_value_str)) {
1073 if (!m_flags.m_value_did_change && m_flags.m_old_value_valid) {
1074 // The value was gotten successfully, so we consider the value as
1075 // changed if the value string differs
1076 SetValueDidChange(m_old_value_str != m_value_str);
1077 }
1078 }
1079 }
1080 }
1081 if (m_value_str.empty())
1082 return nullptr;
1083 return m_value_str.c_str();
1084 }
1085
1086 // if > 8bytes, 0 is returned. this method should mostly be used to read
1087 // address values out of pointers
GetValueAsUnsigned(uint64_t fail_value,bool * success)1088 uint64_t ValueObject::GetValueAsUnsigned(uint64_t fail_value, bool *success) {
1089 // If our byte size is zero this is an aggregate type that has children
1090 if (CanProvideValue()) {
1091 Scalar scalar;
1092 if (ResolveValue(scalar)) {
1093 if (success)
1094 *success = true;
1095 scalar.MakeUnsigned();
1096 return scalar.ULongLong(fail_value);
1097 }
1098 // fallthrough, otherwise...
1099 }
1100
1101 if (success)
1102 *success = false;
1103 return fail_value;
1104 }
1105
GetValueAsSigned(int64_t fail_value,bool * success)1106 int64_t ValueObject::GetValueAsSigned(int64_t fail_value, bool *success) {
1107 // If our byte size is zero this is an aggregate type that has children
1108 if (CanProvideValue()) {
1109 Scalar scalar;
1110 if (ResolveValue(scalar)) {
1111 if (success)
1112 *success = true;
1113 scalar.MakeSigned();
1114 return scalar.SLongLong(fail_value);
1115 }
1116 // fallthrough, otherwise...
1117 }
1118
1119 if (success)
1120 *success = false;
1121 return fail_value;
1122 }
1123
1124 // if any more "special cases" are added to
1125 // ValueObject::DumpPrintableRepresentation() please keep this call up to date
1126 // by returning true for your new special cases. We will eventually move to
1127 // checking this call result before trying to display special cases
HasSpecialPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display,Format custom_format)1128 bool ValueObject::HasSpecialPrintableRepresentation(
1129 ValueObjectRepresentationStyle val_obj_display, Format custom_format) {
1130 Flags flags(GetTypeInfo());
1131 if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
1132 val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) {
1133 if (IsCStringContainer(true) &&
1134 (custom_format == eFormatCString || custom_format == eFormatCharArray ||
1135 custom_format == eFormatChar || custom_format == eFormatVectorOfChar))
1136 return true;
1137
1138 if (flags.Test(eTypeIsArray)) {
1139 if ((custom_format == eFormatBytes) ||
1140 (custom_format == eFormatBytesWithASCII))
1141 return true;
1142
1143 if ((custom_format == eFormatVectorOfChar) ||
1144 (custom_format == eFormatVectorOfFloat32) ||
1145 (custom_format == eFormatVectorOfFloat64) ||
1146 (custom_format == eFormatVectorOfSInt16) ||
1147 (custom_format == eFormatVectorOfSInt32) ||
1148 (custom_format == eFormatVectorOfSInt64) ||
1149 (custom_format == eFormatVectorOfSInt8) ||
1150 (custom_format == eFormatVectorOfUInt128) ||
1151 (custom_format == eFormatVectorOfUInt16) ||
1152 (custom_format == eFormatVectorOfUInt32) ||
1153 (custom_format == eFormatVectorOfUInt64) ||
1154 (custom_format == eFormatVectorOfUInt8))
1155 return true;
1156 }
1157 }
1158 return false;
1159 }
1160
DumpPrintableRepresentation(Stream & s,ValueObjectRepresentationStyle val_obj_display,Format custom_format,PrintableRepresentationSpecialCases special,bool do_dump_error)1161 bool ValueObject::DumpPrintableRepresentation(
1162 Stream &s, ValueObjectRepresentationStyle val_obj_display,
1163 Format custom_format, PrintableRepresentationSpecialCases special,
1164 bool do_dump_error) {
1165
1166 Flags flags(GetTypeInfo());
1167
1168 bool allow_special =
1169 (special == ValueObject::PrintableRepresentationSpecialCases::eAllow);
1170 const bool only_special = false;
1171
1172 if (allow_special) {
1173 if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
1174 val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) {
1175 // when being asked to get a printable display an array or pointer type
1176 // directly, try to "do the right thing"
1177
1178 if (IsCStringContainer(true) &&
1179 (custom_format == eFormatCString ||
1180 custom_format == eFormatCharArray || custom_format == eFormatChar ||
1181 custom_format ==
1182 eFormatVectorOfChar)) // print char[] & char* directly
1183 {
1184 Status error;
1185 lldb::DataBufferSP buffer_sp;
1186 std::pair<size_t, bool> read_string = ReadPointedString(
1187 buffer_sp, error, 0, (custom_format == eFormatVectorOfChar) ||
1188 (custom_format == eFormatCharArray));
1189 lldb_private::formatters::StringPrinter::
1190 ReadBufferAndDumpToStreamOptions options(*this);
1191 options.SetData(DataExtractor(
1192 buffer_sp, lldb::eByteOrderInvalid,
1193 8)); // none of this matters for a string - pass some defaults
1194 options.SetStream(&s);
1195 options.SetPrefixToken(nullptr);
1196 options.SetQuote('"');
1197 options.SetSourceSize(buffer_sp->GetByteSize());
1198 options.SetIsTruncated(read_string.second);
1199 formatters::StringPrinter::ReadBufferAndDumpToStream<
1200 lldb_private::formatters::StringPrinter::StringElementType::ASCII>(
1201 options);
1202 return !error.Fail();
1203 }
1204
1205 if (custom_format == eFormatEnum)
1206 return false;
1207
1208 // this only works for arrays, because I have no way to know when the
1209 // pointed memory ends, and no special \0 end of data marker
1210 if (flags.Test(eTypeIsArray)) {
1211 if ((custom_format == eFormatBytes) ||
1212 (custom_format == eFormatBytesWithASCII)) {
1213 const size_t count = GetNumChildren();
1214
1215 s << '[';
1216 for (size_t low = 0; low < count; low++) {
1217
1218 if (low)
1219 s << ',';
1220
1221 ValueObjectSP child = GetChildAtIndex(low, true);
1222 if (!child.get()) {
1223 s << "<invalid child>";
1224 continue;
1225 }
1226 child->DumpPrintableRepresentation(
1227 s, ValueObject::eValueObjectRepresentationStyleValue,
1228 custom_format);
1229 }
1230
1231 s << ']';
1232
1233 return true;
1234 }
1235
1236 if ((custom_format == eFormatVectorOfChar) ||
1237 (custom_format == eFormatVectorOfFloat32) ||
1238 (custom_format == eFormatVectorOfFloat64) ||
1239 (custom_format == eFormatVectorOfSInt16) ||
1240 (custom_format == eFormatVectorOfSInt32) ||
1241 (custom_format == eFormatVectorOfSInt64) ||
1242 (custom_format == eFormatVectorOfSInt8) ||
1243 (custom_format == eFormatVectorOfUInt128) ||
1244 (custom_format == eFormatVectorOfUInt16) ||
1245 (custom_format == eFormatVectorOfUInt32) ||
1246 (custom_format == eFormatVectorOfUInt64) ||
1247 (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes
1248 // with ASCII or any vector
1249 // format should be printed
1250 // directly
1251 {
1252 const size_t count = GetNumChildren();
1253
1254 Format format = FormatManager::GetSingleItemFormat(custom_format);
1255
1256 s << '[';
1257 for (size_t low = 0; low < count; low++) {
1258
1259 if (low)
1260 s << ',';
1261
1262 ValueObjectSP child = GetChildAtIndex(low, true);
1263 if (!child.get()) {
1264 s << "<invalid child>";
1265 continue;
1266 }
1267 child->DumpPrintableRepresentation(
1268 s, ValueObject::eValueObjectRepresentationStyleValue, format);
1269 }
1270
1271 s << ']';
1272
1273 return true;
1274 }
1275 }
1276
1277 if ((custom_format == eFormatBoolean) ||
1278 (custom_format == eFormatBinary) || (custom_format == eFormatChar) ||
1279 (custom_format == eFormatCharPrintable) ||
1280 (custom_format == eFormatComplexFloat) ||
1281 (custom_format == eFormatDecimal) || (custom_format == eFormatHex) ||
1282 (custom_format == eFormatHexUppercase) ||
1283 (custom_format == eFormatFloat) || (custom_format == eFormatOctal) ||
1284 (custom_format == eFormatOSType) ||
1285 (custom_format == eFormatUnicode16) ||
1286 (custom_format == eFormatUnicode32) ||
1287 (custom_format == eFormatUnsigned) ||
1288 (custom_format == eFormatPointer) ||
1289 (custom_format == eFormatComplexInteger) ||
1290 (custom_format == eFormatComplex) ||
1291 (custom_format == eFormatDefault)) // use the [] operator
1292 return false;
1293 }
1294 }
1295
1296 if (only_special)
1297 return false;
1298
1299 bool var_success = false;
1300
1301 {
1302 llvm::StringRef str;
1303
1304 // this is a local stream that we are using to ensure that the data pointed
1305 // to by cstr survives long enough for us to copy it to its destination -
1306 // it is necessary to have this temporary storage area for cases where our
1307 // desired output is not backed by some other longer-term storage
1308 StreamString strm;
1309
1310 if (custom_format != eFormatInvalid)
1311 SetFormat(custom_format);
1312
1313 switch (val_obj_display) {
1314 case eValueObjectRepresentationStyleValue:
1315 str = GetValueAsCString();
1316 break;
1317
1318 case eValueObjectRepresentationStyleSummary:
1319 str = GetSummaryAsCString();
1320 break;
1321
1322 case eValueObjectRepresentationStyleLanguageSpecific:
1323 str = GetObjectDescription();
1324 break;
1325
1326 case eValueObjectRepresentationStyleLocation:
1327 str = GetLocationAsCString();
1328 break;
1329
1330 case eValueObjectRepresentationStyleChildrenCount:
1331 strm.Printf("%" PRIu64 "", (uint64_t)GetNumChildren());
1332 str = strm.GetString();
1333 break;
1334
1335 case eValueObjectRepresentationStyleType:
1336 str = GetTypeName().GetStringRef();
1337 break;
1338
1339 case eValueObjectRepresentationStyleName:
1340 str = GetName().GetStringRef();
1341 break;
1342
1343 case eValueObjectRepresentationStyleExpressionPath:
1344 GetExpressionPath(strm);
1345 str = strm.GetString();
1346 break;
1347 }
1348
1349 if (str.empty()) {
1350 if (val_obj_display == eValueObjectRepresentationStyleValue)
1351 str = GetSummaryAsCString();
1352 else if (val_obj_display == eValueObjectRepresentationStyleSummary) {
1353 if (!CanProvideValue()) {
1354 strm.Printf("%s @ %s", GetTypeName().AsCString(),
1355 GetLocationAsCString());
1356 str = strm.GetString();
1357 } else
1358 str = GetValueAsCString();
1359 }
1360 }
1361
1362 if (!str.empty())
1363 s << str;
1364 else {
1365 if (m_error.Fail()) {
1366 if (do_dump_error)
1367 s.Printf("<%s>", m_error.AsCString());
1368 else
1369 return false;
1370 } else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1371 s.PutCString("<no summary available>");
1372 else if (val_obj_display == eValueObjectRepresentationStyleValue)
1373 s.PutCString("<no value available>");
1374 else if (val_obj_display ==
1375 eValueObjectRepresentationStyleLanguageSpecific)
1376 s.PutCString("<not a valid Objective-C object>"); // edit this if we
1377 // have other runtimes
1378 // that support a
1379 // description
1380 else
1381 s.PutCString("<no printable representation>");
1382 }
1383
1384 // we should only return false here if we could not do *anything* even if
1385 // we have an error message as output, that's a success from our callers'
1386 // perspective, so return true
1387 var_success = true;
1388
1389 if (custom_format != eFormatInvalid)
1390 SetFormat(eFormatDefault);
1391 }
1392
1393 return var_success;
1394 }
1395
GetAddressOf(bool scalar_is_load_address,AddressType * address_type)1396 addr_t ValueObject::GetAddressOf(bool scalar_is_load_address,
1397 AddressType *address_type) {
1398 // Can't take address of a bitfield
1399 if (IsBitfield())
1400 return LLDB_INVALID_ADDRESS;
1401
1402 if (!UpdateValueIfNeeded(false))
1403 return LLDB_INVALID_ADDRESS;
1404
1405 switch (m_value.GetValueType()) {
1406 case Value::ValueType::Invalid:
1407 return LLDB_INVALID_ADDRESS;
1408 case Value::ValueType::Scalar:
1409 if (scalar_is_load_address) {
1410 if (address_type)
1411 *address_type = eAddressTypeLoad;
1412 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1413 }
1414 break;
1415
1416 case Value::ValueType::LoadAddress:
1417 case Value::ValueType::FileAddress: {
1418 if (address_type)
1419 *address_type = m_value.GetValueAddressType();
1420 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1421 } break;
1422 case Value::ValueType::HostAddress: {
1423 if (address_type)
1424 *address_type = m_value.GetValueAddressType();
1425 return LLDB_INVALID_ADDRESS;
1426 } break;
1427 }
1428 if (address_type)
1429 *address_type = eAddressTypeInvalid;
1430 return LLDB_INVALID_ADDRESS;
1431 }
1432
GetPointerValue(AddressType * address_type)1433 addr_t ValueObject::GetPointerValue(AddressType *address_type) {
1434 addr_t address = LLDB_INVALID_ADDRESS;
1435 if (address_type)
1436 *address_type = eAddressTypeInvalid;
1437
1438 if (!UpdateValueIfNeeded(false))
1439 return address;
1440
1441 switch (m_value.GetValueType()) {
1442 case Value::ValueType::Invalid:
1443 return LLDB_INVALID_ADDRESS;
1444 case Value::ValueType::Scalar:
1445 address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1446 break;
1447
1448 case Value::ValueType::HostAddress:
1449 case Value::ValueType::LoadAddress:
1450 case Value::ValueType::FileAddress: {
1451 lldb::offset_t data_offset = 0;
1452 address = m_data.GetAddress(&data_offset);
1453 } break;
1454 }
1455
1456 if (address_type)
1457 *address_type = GetAddressTypeOfChildren();
1458
1459 return address;
1460 }
1461
SetValueFromCString(const char * value_str,Status & error)1462 bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
1463 error.Clear();
1464 // Make sure our value is up to date first so that our location and location
1465 // type is valid.
1466 if (!UpdateValueIfNeeded(false)) {
1467 error.SetErrorString("unable to read value");
1468 return false;
1469 }
1470
1471 uint64_t count = 0;
1472 const Encoding encoding = GetCompilerType().GetEncoding(count);
1473
1474 const size_t byte_size = GetByteSize().getValueOr(0);
1475
1476 Value::ValueType value_type = m_value.GetValueType();
1477
1478 if (value_type == Value::ValueType::Scalar) {
1479 // If the value is already a scalar, then let the scalar change itself:
1480 m_value.GetScalar().SetValueFromCString(value_str, encoding, byte_size);
1481 } else if (byte_size <= 16) {
1482 // If the value fits in a scalar, then make a new scalar and again let the
1483 // scalar code do the conversion, then figure out where to put the new
1484 // value.
1485 Scalar new_scalar;
1486 error = new_scalar.SetValueFromCString(value_str, encoding, byte_size);
1487 if (error.Success()) {
1488 switch (value_type) {
1489 case Value::ValueType::LoadAddress: {
1490 // If it is a load address, then the scalar value is the storage
1491 // location of the data, and we have to shove this value down to that
1492 // load location.
1493 ExecutionContext exe_ctx(GetExecutionContextRef());
1494 Process *process = exe_ctx.GetProcessPtr();
1495 if (process) {
1496 addr_t target_addr =
1497 m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1498 size_t bytes_written = process->WriteScalarToMemory(
1499 target_addr, new_scalar, byte_size, error);
1500 if (!error.Success())
1501 return false;
1502 if (bytes_written != byte_size) {
1503 error.SetErrorString("unable to write value to memory");
1504 return false;
1505 }
1506 }
1507 } break;
1508 case Value::ValueType::HostAddress: {
1509 // If it is a host address, then we stuff the scalar as a DataBuffer
1510 // into the Value's data.
1511 DataExtractor new_data;
1512 new_data.SetByteOrder(m_data.GetByteOrder());
1513
1514 DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
1515 m_data.SetData(buffer_sp, 0);
1516 bool success = new_scalar.GetData(new_data);
1517 if (success) {
1518 new_data.CopyByteOrderedData(
1519 0, byte_size, const_cast<uint8_t *>(m_data.GetDataStart()),
1520 byte_size, m_data.GetByteOrder());
1521 }
1522 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1523
1524 } break;
1525 case Value::ValueType::Invalid:
1526 error.SetErrorString("invalid location");
1527 return false;
1528 case Value::ValueType::FileAddress:
1529 case Value::ValueType::Scalar:
1530 break;
1531 }
1532 } else {
1533 return false;
1534 }
1535 } else {
1536 // We don't support setting things bigger than a scalar at present.
1537 error.SetErrorString("unable to write aggregate data type");
1538 return false;
1539 }
1540
1541 // If we have reached this point, then we have successfully changed the
1542 // value.
1543 SetNeedsUpdate();
1544 return true;
1545 }
1546
GetDeclaration(Declaration & decl)1547 bool ValueObject::GetDeclaration(Declaration &decl) {
1548 decl.Clear();
1549 return false;
1550 }
1551
AddSyntheticChild(ConstString key,ValueObject * valobj)1552 void ValueObject::AddSyntheticChild(ConstString key,
1553 ValueObject *valobj) {
1554 m_synthetic_children[key] = valobj;
1555 }
1556
GetSyntheticChild(ConstString key) const1557 ValueObjectSP ValueObject::GetSyntheticChild(ConstString key) const {
1558 ValueObjectSP synthetic_child_sp;
1559 std::map<ConstString, ValueObject *>::const_iterator pos =
1560 m_synthetic_children.find(key);
1561 if (pos != m_synthetic_children.end())
1562 synthetic_child_sp = pos->second->GetSP();
1563 return synthetic_child_sp;
1564 }
1565
IsPossibleDynamicType()1566 bool ValueObject::IsPossibleDynamicType() {
1567 ExecutionContext exe_ctx(GetExecutionContextRef());
1568 Process *process = exe_ctx.GetProcessPtr();
1569 if (process)
1570 return process->IsPossibleDynamicValue(*this);
1571 else
1572 return GetCompilerType().IsPossibleDynamicType(nullptr, true, true);
1573 }
1574
IsRuntimeSupportValue()1575 bool ValueObject::IsRuntimeSupportValue() {
1576 Process *process(GetProcessSP().get());
1577 if (!process)
1578 return false;
1579
1580 // We trust that the compiler did the right thing and marked runtime support
1581 // values as artificial.
1582 if (!GetVariable() || !GetVariable()->IsArtificial())
1583 return false;
1584
1585 if (auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage()))
1586 if (runtime->IsAllowedRuntimeValue(GetName()))
1587 return false;
1588
1589 return true;
1590 }
1591
IsNilReference()1592 bool ValueObject::IsNilReference() {
1593 if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {
1594 return language->IsNilReference(*this);
1595 }
1596 return false;
1597 }
1598
IsUninitializedReference()1599 bool ValueObject::IsUninitializedReference() {
1600 if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {
1601 return language->IsUninitializedReference(*this);
1602 }
1603 return false;
1604 }
1605
1606 // This allows you to create an array member using and index that doesn't not
1607 // fall in the normal bounds of the array. Many times structure can be defined
1608 // as: struct Collection {
1609 // uint32_t item_count;
1610 // Item item_array[0];
1611 // };
1612 // The size of the "item_array" is 1, but many times in practice there are more
1613 // items in "item_array".
1614
GetSyntheticArrayMember(size_t index,bool can_create)1615 ValueObjectSP ValueObject::GetSyntheticArrayMember(size_t index,
1616 bool can_create) {
1617 ValueObjectSP synthetic_child_sp;
1618 if (IsPointerType() || IsArrayType()) {
1619 std::string index_str = llvm::formatv("[{0}]", index);
1620 ConstString index_const_str(index_str);
1621 // Check if we have already created a synthetic array member in this valid
1622 // object. If we have we will re-use it.
1623 synthetic_child_sp = GetSyntheticChild(index_const_str);
1624 if (!synthetic_child_sp) {
1625 ValueObject *synthetic_child;
1626 // We haven't made a synthetic array member for INDEX yet, so lets make
1627 // one and cache it for any future reference.
1628 synthetic_child = CreateChildAtIndex(0, true, index);
1629
1630 // Cache the value if we got one back...
1631 if (synthetic_child) {
1632 AddSyntheticChild(index_const_str, synthetic_child);
1633 synthetic_child_sp = synthetic_child->GetSP();
1634 synthetic_child_sp->SetName(ConstString(index_str));
1635 synthetic_child_sp->m_flags.m_is_array_item_for_pointer = true;
1636 }
1637 }
1638 }
1639 return synthetic_child_sp;
1640 }
1641
GetSyntheticBitFieldChild(uint32_t from,uint32_t to,bool can_create)1642 ValueObjectSP ValueObject::GetSyntheticBitFieldChild(uint32_t from, uint32_t to,
1643 bool can_create) {
1644 ValueObjectSP synthetic_child_sp;
1645 if (IsScalarType()) {
1646 std::string index_str = llvm::formatv("[{0}-{1}]", from, to);
1647 ConstString index_const_str(index_str);
1648 // Check if we have already created a synthetic array member in this valid
1649 // object. If we have we will re-use it.
1650 synthetic_child_sp = GetSyntheticChild(index_const_str);
1651 if (!synthetic_child_sp) {
1652 uint32_t bit_field_size = to - from + 1;
1653 uint32_t bit_field_offset = from;
1654 if (GetDataExtractor().GetByteOrder() == eByteOrderBig)
1655 bit_field_offset =
1656 GetByteSize().getValueOr(0) * 8 - bit_field_size - bit_field_offset;
1657 // We haven't made a synthetic array member for INDEX yet, so lets make
1658 // one and cache it for any future reference.
1659 ValueObjectChild *synthetic_child = new ValueObjectChild(
1660 *this, GetCompilerType(), index_const_str,
1661 GetByteSize().getValueOr(0), 0, bit_field_size, bit_field_offset,
1662 false, false, eAddressTypeInvalid, 0);
1663
1664 // Cache the value if we got one back...
1665 if (synthetic_child) {
1666 AddSyntheticChild(index_const_str, synthetic_child);
1667 synthetic_child_sp = synthetic_child->GetSP();
1668 synthetic_child_sp->SetName(ConstString(index_str));
1669 synthetic_child_sp->m_flags.m_is_bitfield_for_scalar = true;
1670 }
1671 }
1672 }
1673 return synthetic_child_sp;
1674 }
1675
GetSyntheticChildAtOffset(uint32_t offset,const CompilerType & type,bool can_create,ConstString name_const_str)1676 ValueObjectSP ValueObject::GetSyntheticChildAtOffset(
1677 uint32_t offset, const CompilerType &type, bool can_create,
1678 ConstString name_const_str) {
1679
1680 ValueObjectSP synthetic_child_sp;
1681
1682 if (name_const_str.IsEmpty()) {
1683 name_const_str.SetString("@" + std::to_string(offset));
1684 }
1685
1686 // Check if we have already created a synthetic array member in this valid
1687 // object. If we have we will re-use it.
1688 synthetic_child_sp = GetSyntheticChild(name_const_str);
1689
1690 if (synthetic_child_sp.get())
1691 return synthetic_child_sp;
1692
1693 if (!can_create)
1694 return {};
1695
1696 ExecutionContext exe_ctx(GetExecutionContextRef());
1697 llvm::Optional<uint64_t> size =
1698 type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
1699 if (!size)
1700 return {};
1701 ValueObjectChild *synthetic_child =
1702 new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
1703 false, false, eAddressTypeInvalid, 0);
1704 if (synthetic_child) {
1705 AddSyntheticChild(name_const_str, synthetic_child);
1706 synthetic_child_sp = synthetic_child->GetSP();
1707 synthetic_child_sp->SetName(name_const_str);
1708 synthetic_child_sp->m_flags.m_is_child_at_offset = true;
1709 }
1710 return synthetic_child_sp;
1711 }
1712
GetSyntheticBase(uint32_t offset,const CompilerType & type,bool can_create,ConstString name_const_str)1713 ValueObjectSP ValueObject::GetSyntheticBase(uint32_t offset,
1714 const CompilerType &type,
1715 bool can_create,
1716 ConstString name_const_str) {
1717 ValueObjectSP synthetic_child_sp;
1718
1719 if (name_const_str.IsEmpty()) {
1720 char name_str[128];
1721 snprintf(name_str, sizeof(name_str), "base%s@%i",
1722 type.GetTypeName().AsCString("<unknown>"), offset);
1723 name_const_str.SetCString(name_str);
1724 }
1725
1726 // Check if we have already created a synthetic array member in this valid
1727 // object. If we have we will re-use it.
1728 synthetic_child_sp = GetSyntheticChild(name_const_str);
1729
1730 if (synthetic_child_sp.get())
1731 return synthetic_child_sp;
1732
1733 if (!can_create)
1734 return {};
1735
1736 const bool is_base_class = true;
1737
1738 ExecutionContext exe_ctx(GetExecutionContextRef());
1739 llvm::Optional<uint64_t> size =
1740 type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
1741 if (!size)
1742 return {};
1743 ValueObjectChild *synthetic_child =
1744 new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
1745 is_base_class, false, eAddressTypeInvalid, 0);
1746 if (synthetic_child) {
1747 AddSyntheticChild(name_const_str, synthetic_child);
1748 synthetic_child_sp = synthetic_child->GetSP();
1749 synthetic_child_sp->SetName(name_const_str);
1750 }
1751 return synthetic_child_sp;
1752 }
1753
1754 // your expression path needs to have a leading . or -> (unless it somehow
1755 // "looks like" an array, in which case it has a leading [ symbol). while the [
1756 // is meaningful and should be shown to the user, . and -> are just parser
1757 // design, but by no means added information for the user.. strip them off
SkipLeadingExpressionPathSeparators(const char * expression)1758 static const char *SkipLeadingExpressionPathSeparators(const char *expression) {
1759 if (!expression || !expression[0])
1760 return expression;
1761 if (expression[0] == '.')
1762 return expression + 1;
1763 if (expression[0] == '-' && expression[1] == '>')
1764 return expression + 2;
1765 return expression;
1766 }
1767
1768 ValueObjectSP
GetSyntheticExpressionPathChild(const char * expression,bool can_create)1769 ValueObject::GetSyntheticExpressionPathChild(const char *expression,
1770 bool can_create) {
1771 ValueObjectSP synthetic_child_sp;
1772 ConstString name_const_string(expression);
1773 // Check if we have already created a synthetic array member in this valid
1774 // object. If we have we will re-use it.
1775 synthetic_child_sp = GetSyntheticChild(name_const_string);
1776 if (!synthetic_child_sp) {
1777 // We haven't made a synthetic array member for expression yet, so lets
1778 // make one and cache it for any future reference.
1779 synthetic_child_sp = GetValueForExpressionPath(
1780 expression, nullptr, nullptr,
1781 GetValueForExpressionPathOptions().SetSyntheticChildrenTraversal(
1782 GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
1783 None));
1784
1785 // Cache the value if we got one back...
1786 if (synthetic_child_sp.get()) {
1787 // FIXME: this causes a "real" child to end up with its name changed to
1788 // the contents of expression
1789 AddSyntheticChild(name_const_string, synthetic_child_sp.get());
1790 synthetic_child_sp->SetName(
1791 ConstString(SkipLeadingExpressionPathSeparators(expression)));
1792 }
1793 }
1794 return synthetic_child_sp;
1795 }
1796
CalculateSyntheticValue()1797 void ValueObject::CalculateSyntheticValue() {
1798 TargetSP target_sp(GetTargetSP());
1799 if (target_sp && !target_sp->GetEnableSyntheticValue()) {
1800 m_synthetic_value = nullptr;
1801 return;
1802 }
1803
1804 lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
1805
1806 if (!UpdateFormatsIfNeeded() && m_synthetic_value)
1807 return;
1808
1809 if (m_synthetic_children_sp.get() == nullptr)
1810 return;
1811
1812 if (current_synth_sp == m_synthetic_children_sp && m_synthetic_value)
1813 return;
1814
1815 m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp);
1816 }
1817
CalculateDynamicValue(DynamicValueType use_dynamic)1818 void ValueObject::CalculateDynamicValue(DynamicValueType use_dynamic) {
1819 if (use_dynamic == eNoDynamicValues)
1820 return;
1821
1822 if (!m_dynamic_value && !IsDynamic()) {
1823 ExecutionContext exe_ctx(GetExecutionContextRef());
1824 Process *process = exe_ctx.GetProcessPtr();
1825 if (process && process->IsPossibleDynamicValue(*this)) {
1826 ClearDynamicTypeInformation();
1827 m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
1828 }
1829 }
1830 }
1831
GetDynamicValue(DynamicValueType use_dynamic)1832 ValueObjectSP ValueObject::GetDynamicValue(DynamicValueType use_dynamic) {
1833 if (use_dynamic == eNoDynamicValues)
1834 return ValueObjectSP();
1835
1836 if (!IsDynamic() && m_dynamic_value == nullptr) {
1837 CalculateDynamicValue(use_dynamic);
1838 }
1839 if (m_dynamic_value)
1840 return m_dynamic_value->GetSP();
1841 else
1842 return ValueObjectSP();
1843 }
1844
GetSyntheticValue()1845 ValueObjectSP ValueObject::GetSyntheticValue() {
1846 CalculateSyntheticValue();
1847
1848 if (m_synthetic_value)
1849 return m_synthetic_value->GetSP();
1850 else
1851 return ValueObjectSP();
1852 }
1853
HasSyntheticValue()1854 bool ValueObject::HasSyntheticValue() {
1855 UpdateFormatsIfNeeded();
1856
1857 if (m_synthetic_children_sp.get() == nullptr)
1858 return false;
1859
1860 CalculateSyntheticValue();
1861
1862 return m_synthetic_value != nullptr;
1863 }
1864
GetNonBaseClassParent()1865 ValueObject *ValueObject::GetNonBaseClassParent() {
1866 if (GetParent()) {
1867 if (GetParent()->IsBaseClass())
1868 return GetParent()->GetNonBaseClassParent();
1869 else
1870 return GetParent();
1871 }
1872 return nullptr;
1873 }
1874
IsBaseClass(uint32_t & depth)1875 bool ValueObject::IsBaseClass(uint32_t &depth) {
1876 if (!IsBaseClass()) {
1877 depth = 0;
1878 return false;
1879 }
1880 if (GetParent()) {
1881 GetParent()->IsBaseClass(depth);
1882 depth = depth + 1;
1883 return true;
1884 }
1885 // TODO: a base of no parent? weird..
1886 depth = 1;
1887 return true;
1888 }
1889
GetExpressionPath(Stream & s,GetExpressionPathFormat epformat)1890 void ValueObject::GetExpressionPath(Stream &s,
1891 GetExpressionPathFormat epformat) {
1892 // synthetic children do not actually "exist" as part of the hierarchy, and
1893 // sometimes they are consed up in ways that don't make sense from an
1894 // underlying language/API standpoint. So, use a special code path here to
1895 // return something that can hopefully be used in expression
1896 if (m_flags.m_is_synthetic_children_generated) {
1897 UpdateValueIfNeeded();
1898
1899 if (m_value.GetValueType() == Value::ValueType::LoadAddress) {
1900 if (IsPointerOrReferenceType()) {
1901 s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"),
1902 GetValueAsUnsigned(0));
1903 return;
1904 } else {
1905 uint64_t load_addr =
1906 m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1907 if (load_addr != LLDB_INVALID_ADDRESS) {
1908 s.Printf("(*( (%s *)0x%" PRIx64 "))", GetTypeName().AsCString("void"),
1909 load_addr);
1910 return;
1911 }
1912 }
1913 }
1914
1915 if (CanProvideValue()) {
1916 s.Printf("((%s)%s)", GetTypeName().AsCString("void"),
1917 GetValueAsCString());
1918 return;
1919 }
1920
1921 return;
1922 }
1923
1924 const bool is_deref_of_parent = IsDereferenceOfParent();
1925
1926 if (is_deref_of_parent &&
1927 epformat == eGetExpressionPathFormatDereferencePointers) {
1928 // this is the original format of GetExpressionPath() producing code like
1929 // *(a_ptr).memberName, which is entirely fine, until you put this into
1930 // StackFrame::GetValueForVariableExpressionPath() which prefers to see
1931 // a_ptr->memberName. the eHonorPointers mode is meant to produce strings
1932 // in this latter format
1933 s.PutCString("*(");
1934 }
1935
1936 ValueObject *parent = GetParent();
1937
1938 if (parent)
1939 parent->GetExpressionPath(s, epformat);
1940
1941 // if we are a deref_of_parent just because we are synthetic array members
1942 // made up to allow ptr[%d] syntax to work in variable printing, then add our
1943 // name ([%d]) to the expression path
1944 if (m_flags.m_is_array_item_for_pointer &&
1945 epformat == eGetExpressionPathFormatHonorPointers)
1946 s.PutCString(m_name.GetStringRef());
1947
1948 if (!IsBaseClass()) {
1949 if (!is_deref_of_parent) {
1950 ValueObject *non_base_class_parent = GetNonBaseClassParent();
1951 if (non_base_class_parent &&
1952 !non_base_class_parent->GetName().IsEmpty()) {
1953 CompilerType non_base_class_parent_compiler_type =
1954 non_base_class_parent->GetCompilerType();
1955 if (non_base_class_parent_compiler_type) {
1956 if (parent && parent->IsDereferenceOfParent() &&
1957 epformat == eGetExpressionPathFormatHonorPointers) {
1958 s.PutCString("->");
1959 } else {
1960 const uint32_t non_base_class_parent_type_info =
1961 non_base_class_parent_compiler_type.GetTypeInfo();
1962
1963 if (non_base_class_parent_type_info & eTypeIsPointer) {
1964 s.PutCString("->");
1965 } else if ((non_base_class_parent_type_info & eTypeHasChildren) &&
1966 !(non_base_class_parent_type_info & eTypeIsArray)) {
1967 s.PutChar('.');
1968 }
1969 }
1970 }
1971 }
1972
1973 const char *name = GetName().GetCString();
1974 if (name)
1975 s.PutCString(name);
1976 }
1977 }
1978
1979 if (is_deref_of_parent &&
1980 epformat == eGetExpressionPathFormatDereferencePointers) {
1981 s.PutChar(')');
1982 }
1983 }
1984
GetValueForExpressionPath(llvm::StringRef expression,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_value_type,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * final_task_on_target)1985 ValueObjectSP ValueObject::GetValueForExpressionPath(
1986 llvm::StringRef expression, ExpressionPathScanEndReason *reason_to_stop,
1987 ExpressionPathEndResultType *final_value_type,
1988 const GetValueForExpressionPathOptions &options,
1989 ExpressionPathAftermath *final_task_on_target) {
1990
1991 ExpressionPathScanEndReason dummy_reason_to_stop =
1992 ValueObject::eExpressionPathScanEndReasonUnknown;
1993 ExpressionPathEndResultType dummy_final_value_type =
1994 ValueObject::eExpressionPathEndResultTypeInvalid;
1995 ExpressionPathAftermath dummy_final_task_on_target =
1996 ValueObject::eExpressionPathAftermathNothing;
1997
1998 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(
1999 expression, reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2000 final_value_type ? final_value_type : &dummy_final_value_type, options,
2001 final_task_on_target ? final_task_on_target
2002 : &dummy_final_task_on_target);
2003
2004 if (!final_task_on_target ||
2005 *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2006 return ret_val;
2007
2008 if (ret_val.get() &&
2009 ((final_value_type ? *final_value_type : dummy_final_value_type) ==
2010 eExpressionPathEndResultTypePlain)) // I can only deref and takeaddress
2011 // of plain objects
2012 {
2013 if ((final_task_on_target ? *final_task_on_target
2014 : dummy_final_task_on_target) ==
2015 ValueObject::eExpressionPathAftermathDereference) {
2016 Status error;
2017 ValueObjectSP final_value = ret_val->Dereference(error);
2018 if (error.Fail() || !final_value.get()) {
2019 if (reason_to_stop)
2020 *reason_to_stop =
2021 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2022 if (final_value_type)
2023 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2024 return ValueObjectSP();
2025 } else {
2026 if (final_task_on_target)
2027 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2028 return final_value;
2029 }
2030 }
2031 if (*final_task_on_target ==
2032 ValueObject::eExpressionPathAftermathTakeAddress) {
2033 Status error;
2034 ValueObjectSP final_value = ret_val->AddressOf(error);
2035 if (error.Fail() || !final_value.get()) {
2036 if (reason_to_stop)
2037 *reason_to_stop =
2038 ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2039 if (final_value_type)
2040 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2041 return ValueObjectSP();
2042 } else {
2043 if (final_task_on_target)
2044 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2045 return final_value;
2046 }
2047 }
2048 }
2049 return ret_val; // final_task_on_target will still have its original value, so
2050 // you know I did not do it
2051 }
2052
GetValueForExpressionPath_Impl(llvm::StringRef expression,ExpressionPathScanEndReason * reason_to_stop,ExpressionPathEndResultType * final_result,const GetValueForExpressionPathOptions & options,ExpressionPathAftermath * what_next)2053 ValueObjectSP ValueObject::GetValueForExpressionPath_Impl(
2054 llvm::StringRef expression, ExpressionPathScanEndReason *reason_to_stop,
2055 ExpressionPathEndResultType *final_result,
2056 const GetValueForExpressionPathOptions &options,
2057 ExpressionPathAftermath *what_next) {
2058 ValueObjectSP root = GetSP();
2059
2060 if (!root)
2061 return nullptr;
2062
2063 llvm::StringRef remainder = expression;
2064
2065 while (true) {
2066 llvm::StringRef temp_expression = remainder;
2067
2068 CompilerType root_compiler_type = root->GetCompilerType();
2069 CompilerType pointee_compiler_type;
2070 Flags pointee_compiler_type_info;
2071
2072 Flags root_compiler_type_info(
2073 root_compiler_type.GetTypeInfo(&pointee_compiler_type));
2074 if (pointee_compiler_type)
2075 pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo());
2076
2077 if (temp_expression.empty()) {
2078 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2079 return root;
2080 }
2081
2082 switch (temp_expression.front()) {
2083 case '-': {
2084 temp_expression = temp_expression.drop_front();
2085 if (options.m_check_dot_vs_arrow_syntax &&
2086 root_compiler_type_info.Test(eTypeIsPointer)) // if you are trying to
2087 // use -> on a
2088 // non-pointer and I
2089 // must catch the error
2090 {
2091 *reason_to_stop =
2092 ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot;
2093 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2094 return ValueObjectSP();
2095 }
2096 if (root_compiler_type_info.Test(eTypeIsObjC) && // if yo are trying to
2097 // extract an ObjC IVar
2098 // when this is forbidden
2099 root_compiler_type_info.Test(eTypeIsPointer) &&
2100 options.m_no_fragile_ivar) {
2101 *reason_to_stop =
2102 ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed;
2103 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2104 return ValueObjectSP();
2105 }
2106 if (!temp_expression.startswith(">")) {
2107 *reason_to_stop =
2108 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2109 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2110 return ValueObjectSP();
2111 }
2112 }
2113 LLVM_FALLTHROUGH;
2114 case '.': // or fallthrough from ->
2115 {
2116 if (options.m_check_dot_vs_arrow_syntax &&
2117 temp_expression.front() == '.' &&
2118 root_compiler_type_info.Test(eTypeIsPointer)) // if you are trying to
2119 // use . on a pointer
2120 // and I must catch the
2121 // error
2122 {
2123 *reason_to_stop =
2124 ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow;
2125 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2126 return nullptr;
2127 }
2128 temp_expression = temp_expression.drop_front(); // skip . or >
2129
2130 size_t next_sep_pos = temp_expression.find_first_of("-.[", 1);
2131 ConstString child_name;
2132 if (next_sep_pos == llvm::StringRef::npos) // if no other separator just
2133 // expand this last layer
2134 {
2135 child_name.SetString(temp_expression);
2136 ValueObjectSP child_valobj_sp =
2137 root->GetChildMemberWithName(child_name, true);
2138
2139 if (child_valobj_sp.get()) // we know we are done, so just return
2140 {
2141 *reason_to_stop =
2142 ValueObject::eExpressionPathScanEndReasonEndOfString;
2143 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2144 return child_valobj_sp;
2145 } else {
2146 switch (options.m_synthetic_children_traversal) {
2147 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2148 None:
2149 break;
2150 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2151 FromSynthetic:
2152 if (root->IsSynthetic()) {
2153 child_valobj_sp = root->GetNonSyntheticValue();
2154 if (child_valobj_sp.get())
2155 child_valobj_sp =
2156 child_valobj_sp->GetChildMemberWithName(child_name, true);
2157 }
2158 break;
2159 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2160 ToSynthetic:
2161 if (!root->IsSynthetic()) {
2162 child_valobj_sp = root->GetSyntheticValue();
2163 if (child_valobj_sp.get())
2164 child_valobj_sp =
2165 child_valobj_sp->GetChildMemberWithName(child_name, true);
2166 }
2167 break;
2168 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2169 Both:
2170 if (root->IsSynthetic()) {
2171 child_valobj_sp = root->GetNonSyntheticValue();
2172 if (child_valobj_sp.get())
2173 child_valobj_sp =
2174 child_valobj_sp->GetChildMemberWithName(child_name, true);
2175 } else {
2176 child_valobj_sp = root->GetSyntheticValue();
2177 if (child_valobj_sp.get())
2178 child_valobj_sp =
2179 child_valobj_sp->GetChildMemberWithName(child_name, true);
2180 }
2181 break;
2182 }
2183 }
2184
2185 // if we are here and options.m_no_synthetic_children is true,
2186 // child_valobj_sp is going to be a NULL SP, so we hit the "else"
2187 // branch, and return an error
2188 if (child_valobj_sp.get()) // if it worked, just return
2189 {
2190 *reason_to_stop =
2191 ValueObject::eExpressionPathScanEndReasonEndOfString;
2192 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2193 return child_valobj_sp;
2194 } else {
2195 *reason_to_stop =
2196 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2197 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2198 return nullptr;
2199 }
2200 } else // other layers do expand
2201 {
2202 llvm::StringRef next_separator = temp_expression.substr(next_sep_pos);
2203
2204 child_name.SetString(temp_expression.slice(0, next_sep_pos));
2205
2206 ValueObjectSP child_valobj_sp =
2207 root->GetChildMemberWithName(child_name, true);
2208 if (child_valobj_sp.get()) // store the new root and move on
2209 {
2210 root = child_valobj_sp;
2211 remainder = next_separator;
2212 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2213 continue;
2214 } else {
2215 switch (options.m_synthetic_children_traversal) {
2216 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2217 None:
2218 break;
2219 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2220 FromSynthetic:
2221 if (root->IsSynthetic()) {
2222 child_valobj_sp = root->GetNonSyntheticValue();
2223 if (child_valobj_sp.get())
2224 child_valobj_sp =
2225 child_valobj_sp->GetChildMemberWithName(child_name, true);
2226 }
2227 break;
2228 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2229 ToSynthetic:
2230 if (!root->IsSynthetic()) {
2231 child_valobj_sp = root->GetSyntheticValue();
2232 if (child_valobj_sp.get())
2233 child_valobj_sp =
2234 child_valobj_sp->GetChildMemberWithName(child_name, true);
2235 }
2236 break;
2237 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2238 Both:
2239 if (root->IsSynthetic()) {
2240 child_valobj_sp = root->GetNonSyntheticValue();
2241 if (child_valobj_sp.get())
2242 child_valobj_sp =
2243 child_valobj_sp->GetChildMemberWithName(child_name, true);
2244 } else {
2245 child_valobj_sp = root->GetSyntheticValue();
2246 if (child_valobj_sp.get())
2247 child_valobj_sp =
2248 child_valobj_sp->GetChildMemberWithName(child_name, true);
2249 }
2250 break;
2251 }
2252 }
2253
2254 // if we are here and options.m_no_synthetic_children is true,
2255 // child_valobj_sp is going to be a NULL SP, so we hit the "else"
2256 // branch, and return an error
2257 if (child_valobj_sp.get()) // if it worked, move on
2258 {
2259 root = child_valobj_sp;
2260 remainder = next_separator;
2261 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2262 continue;
2263 } else {
2264 *reason_to_stop =
2265 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2266 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2267 return nullptr;
2268 }
2269 }
2270 break;
2271 }
2272 case '[': {
2273 if (!root_compiler_type_info.Test(eTypeIsArray) &&
2274 !root_compiler_type_info.Test(eTypeIsPointer) &&
2275 !root_compiler_type_info.Test(
2276 eTypeIsVector)) // if this is not a T[] nor a T*
2277 {
2278 if (!root_compiler_type_info.Test(
2279 eTypeIsScalar)) // if this is not even a scalar...
2280 {
2281 if (options.m_synthetic_children_traversal ==
2282 GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2283 None) // ...only chance left is synthetic
2284 {
2285 *reason_to_stop =
2286 ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
2287 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2288 return ValueObjectSP();
2289 }
2290 } else if (!options.m_allow_bitfields_syntax) // if this is a scalar,
2291 // check that we can
2292 // expand bitfields
2293 {
2294 *reason_to_stop =
2295 ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
2296 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2297 return ValueObjectSP();
2298 }
2299 }
2300 if (temp_expression[1] ==
2301 ']') // if this is an unbounded range it only works for arrays
2302 {
2303 if (!root_compiler_type_info.Test(eTypeIsArray)) {
2304 *reason_to_stop =
2305 ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
2306 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2307 return nullptr;
2308 } else // even if something follows, we cannot expand unbounded ranges,
2309 // just let the caller do it
2310 {
2311 *reason_to_stop =
2312 ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2313 *final_result =
2314 ValueObject::eExpressionPathEndResultTypeUnboundedRange;
2315 return root;
2316 }
2317 }
2318
2319 size_t close_bracket_position = temp_expression.find(']', 1);
2320 if (close_bracket_position ==
2321 llvm::StringRef::npos) // if there is no ], this is a syntax error
2322 {
2323 *reason_to_stop =
2324 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2325 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2326 return nullptr;
2327 }
2328
2329 llvm::StringRef bracket_expr =
2330 temp_expression.slice(1, close_bracket_position);
2331
2332 // If this was an empty expression it would have been caught by the if
2333 // above.
2334 assert(!bracket_expr.empty());
2335
2336 if (!bracket_expr.contains('-')) {
2337 // if no separator, this is of the form [N]. Note that this cannot be
2338 // an unbounded range of the form [], because that case was handled
2339 // above with an unconditional return.
2340 unsigned long index = 0;
2341 if (bracket_expr.getAsInteger(0, index)) {
2342 *reason_to_stop =
2343 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2344 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2345 return nullptr;
2346 }
2347
2348 // from here on we do have a valid index
2349 if (root_compiler_type_info.Test(eTypeIsArray)) {
2350 ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
2351 if (!child_valobj_sp)
2352 child_valobj_sp = root->GetSyntheticArrayMember(index, true);
2353 if (!child_valobj_sp)
2354 if (root->HasSyntheticValue() &&
2355 root->GetSyntheticValue()->GetNumChildren() > index)
2356 child_valobj_sp =
2357 root->GetSyntheticValue()->GetChildAtIndex(index, true);
2358 if (child_valobj_sp) {
2359 root = child_valobj_sp;
2360 remainder =
2361 temp_expression.substr(close_bracket_position + 1); // skip ]
2362 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2363 continue;
2364 } else {
2365 *reason_to_stop =
2366 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2367 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2368 return nullptr;
2369 }
2370 } else if (root_compiler_type_info.Test(eTypeIsPointer)) {
2371 if (*what_next ==
2372 ValueObject::
2373 eExpressionPathAftermathDereference && // if this is a
2374 // ptr-to-scalar, I
2375 // am accessing it
2376 // by index and I
2377 // would have
2378 // deref'ed anyway,
2379 // then do it now
2380 // and use this as
2381 // a bitfield
2382 pointee_compiler_type_info.Test(eTypeIsScalar)) {
2383 Status error;
2384 root = root->Dereference(error);
2385 if (error.Fail() || !root) {
2386 *reason_to_stop =
2387 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2388 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2389 return nullptr;
2390 } else {
2391 *what_next = eExpressionPathAftermathNothing;
2392 continue;
2393 }
2394 } else {
2395 if (root->GetCompilerType().GetMinimumLanguage() ==
2396 eLanguageTypeObjC &&
2397 pointee_compiler_type_info.AllClear(eTypeIsPointer) &&
2398 root->HasSyntheticValue() &&
2399 (options.m_synthetic_children_traversal ==
2400 GetValueForExpressionPathOptions::
2401 SyntheticChildrenTraversal::ToSynthetic ||
2402 options.m_synthetic_children_traversal ==
2403 GetValueForExpressionPathOptions::
2404 SyntheticChildrenTraversal::Both)) {
2405 root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
2406 } else
2407 root = root->GetSyntheticArrayMember(index, true);
2408 if (!root) {
2409 *reason_to_stop =
2410 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2411 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2412 return nullptr;
2413 } else {
2414 remainder =
2415 temp_expression.substr(close_bracket_position + 1); // skip ]
2416 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2417 continue;
2418 }
2419 }
2420 } else if (root_compiler_type_info.Test(eTypeIsScalar)) {
2421 root = root->GetSyntheticBitFieldChild(index, index, true);
2422 if (!root) {
2423 *reason_to_stop =
2424 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2425 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2426 return nullptr;
2427 } else // we do not know how to expand members of bitfields, so we
2428 // just return and let the caller do any further processing
2429 {
2430 *reason_to_stop = ValueObject::
2431 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
2432 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
2433 return root;
2434 }
2435 } else if (root_compiler_type_info.Test(eTypeIsVector)) {
2436 root = root->GetChildAtIndex(index, true);
2437 if (!root) {
2438 *reason_to_stop =
2439 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2440 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2441 return ValueObjectSP();
2442 } else {
2443 remainder =
2444 temp_expression.substr(close_bracket_position + 1); // skip ]
2445 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2446 continue;
2447 }
2448 } else if (options.m_synthetic_children_traversal ==
2449 GetValueForExpressionPathOptions::
2450 SyntheticChildrenTraversal::ToSynthetic ||
2451 options.m_synthetic_children_traversal ==
2452 GetValueForExpressionPathOptions::
2453 SyntheticChildrenTraversal::Both) {
2454 if (root->HasSyntheticValue())
2455 root = root->GetSyntheticValue();
2456 else if (!root->IsSynthetic()) {
2457 *reason_to_stop =
2458 ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2459 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2460 return nullptr;
2461 }
2462 // if we are here, then root itself is a synthetic VO.. should be
2463 // good to go
2464
2465 if (!root) {
2466 *reason_to_stop =
2467 ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2468 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2469 return nullptr;
2470 }
2471 root = root->GetChildAtIndex(index, true);
2472 if (!root) {
2473 *reason_to_stop =
2474 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2475 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2476 return nullptr;
2477 } else {
2478 remainder =
2479 temp_expression.substr(close_bracket_position + 1); // skip ]
2480 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2481 continue;
2482 }
2483 } else {
2484 *reason_to_stop =
2485 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2486 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2487 return nullptr;
2488 }
2489 } else {
2490 // we have a low and a high index
2491 llvm::StringRef sleft, sright;
2492 unsigned long low_index, high_index;
2493 std::tie(sleft, sright) = bracket_expr.split('-');
2494 if (sleft.getAsInteger(0, low_index) ||
2495 sright.getAsInteger(0, high_index)) {
2496 *reason_to_stop =
2497 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2498 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2499 return nullptr;
2500 }
2501
2502 if (low_index > high_index) // swap indices if required
2503 std::swap(low_index, high_index);
2504
2505 if (root_compiler_type_info.Test(
2506 eTypeIsScalar)) // expansion only works for scalars
2507 {
2508 root = root->GetSyntheticBitFieldChild(low_index, high_index, true);
2509 if (!root) {
2510 *reason_to_stop =
2511 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2512 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2513 return nullptr;
2514 } else {
2515 *reason_to_stop = ValueObject::
2516 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
2517 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
2518 return root;
2519 }
2520 } else if (root_compiler_type_info.Test(
2521 eTypeIsPointer) && // if this is a ptr-to-scalar, I am
2522 // accessing it by index and I would
2523 // have deref'ed anyway, then do it
2524 // now and use this as a bitfield
2525 *what_next ==
2526 ValueObject::eExpressionPathAftermathDereference &&
2527 pointee_compiler_type_info.Test(eTypeIsScalar)) {
2528 Status error;
2529 root = root->Dereference(error);
2530 if (error.Fail() || !root) {
2531 *reason_to_stop =
2532 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2533 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2534 return nullptr;
2535 } else {
2536 *what_next = ValueObject::eExpressionPathAftermathNothing;
2537 continue;
2538 }
2539 } else {
2540 *reason_to_stop =
2541 ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2542 *final_result = ValueObject::eExpressionPathEndResultTypeBoundedRange;
2543 return root;
2544 }
2545 }
2546 break;
2547 }
2548 default: // some non-separator is in the way
2549 {
2550 *reason_to_stop =
2551 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2552 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2553 return nullptr;
2554 }
2555 }
2556 }
2557 }
2558
Dump(Stream & s)2559 void ValueObject::Dump(Stream &s) { Dump(s, DumpValueObjectOptions(*this)); }
2560
Dump(Stream & s,const DumpValueObjectOptions & options)2561 void ValueObject::Dump(Stream &s, const DumpValueObjectOptions &options) {
2562 ValueObjectPrinter printer(this, &s, options);
2563 printer.PrintValueObject();
2564 }
2565
CreateConstantValue(ConstString name)2566 ValueObjectSP ValueObject::CreateConstantValue(ConstString name) {
2567 ValueObjectSP valobj_sp;
2568
2569 if (UpdateValueIfNeeded(false) && m_error.Success()) {
2570 ExecutionContext exe_ctx(GetExecutionContextRef());
2571
2572 DataExtractor data;
2573 data.SetByteOrder(m_data.GetByteOrder());
2574 data.SetAddressByteSize(m_data.GetAddressByteSize());
2575
2576 if (IsBitfield()) {
2577 Value v(Scalar(GetValueAsUnsigned(UINT64_MAX)));
2578 m_error = v.GetValueAsData(&exe_ctx, data, GetModule().get());
2579 } else
2580 m_error = m_value.GetValueAsData(&exe_ctx, data, GetModule().get());
2581
2582 valobj_sp = ValueObjectConstResult::Create(
2583 exe_ctx.GetBestExecutionContextScope(), GetCompilerType(), name, data,
2584 GetAddressOf());
2585 }
2586
2587 if (!valobj_sp) {
2588 ExecutionContext exe_ctx(GetExecutionContextRef());
2589 valobj_sp = ValueObjectConstResult::Create(
2590 exe_ctx.GetBestExecutionContextScope(), m_error);
2591 }
2592 return valobj_sp;
2593 }
2594
GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue,bool synthValue)2595 ValueObjectSP ValueObject::GetQualifiedRepresentationIfAvailable(
2596 lldb::DynamicValueType dynValue, bool synthValue) {
2597 ValueObjectSP result_sp(GetSP());
2598
2599 switch (dynValue) {
2600 case lldb::eDynamicCanRunTarget:
2601 case lldb::eDynamicDontRunTarget: {
2602 if (!result_sp->IsDynamic()) {
2603 if (result_sp->GetDynamicValue(dynValue))
2604 result_sp = result_sp->GetDynamicValue(dynValue);
2605 }
2606 } break;
2607 case lldb::eNoDynamicValues: {
2608 if (result_sp->IsDynamic()) {
2609 if (result_sp->GetStaticValue())
2610 result_sp = result_sp->GetStaticValue();
2611 }
2612 } break;
2613 }
2614
2615 if (synthValue) {
2616 if (!result_sp->IsSynthetic()) {
2617 if (result_sp->GetSyntheticValue())
2618 result_sp = result_sp->GetSyntheticValue();
2619 }
2620 } else {
2621 if (result_sp->IsSynthetic()) {
2622 if (result_sp->GetNonSyntheticValue())
2623 result_sp = result_sp->GetNonSyntheticValue();
2624 }
2625 }
2626
2627 return result_sp;
2628 }
2629
Dereference(Status & error)2630 ValueObjectSP ValueObject::Dereference(Status &error) {
2631 if (m_deref_valobj)
2632 return m_deref_valobj->GetSP();
2633
2634 const bool is_pointer_or_reference_type = IsPointerOrReferenceType();
2635 if (is_pointer_or_reference_type) {
2636 bool omit_empty_base_classes = true;
2637 bool ignore_array_bounds = false;
2638
2639 std::string child_name_str;
2640 uint32_t child_byte_size = 0;
2641 int32_t child_byte_offset = 0;
2642 uint32_t child_bitfield_bit_size = 0;
2643 uint32_t child_bitfield_bit_offset = 0;
2644 bool child_is_base_class = false;
2645 bool child_is_deref_of_parent = false;
2646 const bool transparent_pointers = false;
2647 CompilerType compiler_type = GetCompilerType();
2648 CompilerType child_compiler_type;
2649 uint64_t language_flags = 0;
2650
2651 ExecutionContext exe_ctx(GetExecutionContextRef());
2652
2653 child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex(
2654 &exe_ctx, 0, transparent_pointers, omit_empty_base_classes,
2655 ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
2656 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
2657 child_is_deref_of_parent, this, language_flags);
2658 if (child_compiler_type && child_byte_size) {
2659 ConstString child_name;
2660 if (!child_name_str.empty())
2661 child_name.SetCString(child_name_str.c_str());
2662
2663 m_deref_valobj = new ValueObjectChild(
2664 *this, child_compiler_type, child_name, child_byte_size,
2665 child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
2666 child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
2667 language_flags);
2668 }
2669
2670 // In case of incomplete child compiler type, use the pointee type and try
2671 // to recreate a new ValueObjectChild using it.
2672 if (!m_deref_valobj) {
2673 if (HasSyntheticValue()) {
2674 child_compiler_type = compiler_type.GetPointeeType();
2675
2676 if (child_compiler_type) {
2677 ConstString child_name;
2678 if (!child_name_str.empty())
2679 child_name.SetCString(child_name_str.c_str());
2680
2681 m_deref_valobj = new ValueObjectChild(
2682 *this, child_compiler_type, child_name, child_byte_size,
2683 child_byte_offset, child_bitfield_bit_size,
2684 child_bitfield_bit_offset, child_is_base_class,
2685 child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
2686 }
2687 }
2688 }
2689
2690 } else if (HasSyntheticValue()) {
2691 m_deref_valobj =
2692 GetSyntheticValue()
2693 ->GetChildMemberWithName(ConstString("$$dereference$$"), true)
2694 .get();
2695 } else if (IsSynthetic()) {
2696 m_deref_valobj =
2697 GetChildMemberWithName(ConstString("$$dereference$$"), true).get();
2698 }
2699
2700 if (m_deref_valobj) {
2701 error.Clear();
2702 return m_deref_valobj->GetSP();
2703 } else {
2704 StreamString strm;
2705 GetExpressionPath(strm);
2706
2707 if (is_pointer_or_reference_type)
2708 error.SetErrorStringWithFormat("dereference failed: (%s) %s",
2709 GetTypeName().AsCString("<invalid type>"),
2710 strm.GetData());
2711 else
2712 error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s",
2713 GetTypeName().AsCString("<invalid type>"),
2714 strm.GetData());
2715 return ValueObjectSP();
2716 }
2717 }
2718
AddressOf(Status & error)2719 ValueObjectSP ValueObject::AddressOf(Status &error) {
2720 if (m_addr_of_valobj_sp)
2721 return m_addr_of_valobj_sp;
2722
2723 AddressType address_type = eAddressTypeInvalid;
2724 const bool scalar_is_load_address = false;
2725 addr_t addr = GetAddressOf(scalar_is_load_address, &address_type);
2726 error.Clear();
2727 if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost) {
2728 switch (address_type) {
2729 case eAddressTypeInvalid: {
2730 StreamString expr_path_strm;
2731 GetExpressionPath(expr_path_strm);
2732 error.SetErrorStringWithFormat("'%s' is not in memory",
2733 expr_path_strm.GetData());
2734 } break;
2735
2736 case eAddressTypeFile:
2737 case eAddressTypeLoad: {
2738 CompilerType compiler_type = GetCompilerType();
2739 if (compiler_type) {
2740 std::string name(1, '&');
2741 name.append(m_name.AsCString(""));
2742 ExecutionContext exe_ctx(GetExecutionContextRef());
2743 m_addr_of_valobj_sp = ValueObjectConstResult::Create(
2744 exe_ctx.GetBestExecutionContextScope(),
2745 compiler_type.GetPointerType(), ConstString(name.c_str()), addr,
2746 eAddressTypeInvalid, m_data.GetAddressByteSize());
2747 }
2748 } break;
2749 default:
2750 break;
2751 }
2752 } else {
2753 StreamString expr_path_strm;
2754 GetExpressionPath(expr_path_strm);
2755 error.SetErrorStringWithFormat("'%s' doesn't have a valid address",
2756 expr_path_strm.GetData());
2757 }
2758
2759 return m_addr_of_valobj_sp;
2760 }
2761
Cast(const CompilerType & compiler_type)2762 ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) {
2763 return ValueObjectCast::Create(*this, GetName(), compiler_type);
2764 }
2765
Clone(ConstString new_name)2766 lldb::ValueObjectSP ValueObject::Clone(ConstString new_name) {
2767 return ValueObjectCast::Create(*this, new_name, GetCompilerType());
2768 }
2769
CastPointerType(const char * name,CompilerType & compiler_type)2770 ValueObjectSP ValueObject::CastPointerType(const char *name,
2771 CompilerType &compiler_type) {
2772 ValueObjectSP valobj_sp;
2773 AddressType address_type;
2774 addr_t ptr_value = GetPointerValue(&address_type);
2775
2776 if (ptr_value != LLDB_INVALID_ADDRESS) {
2777 Address ptr_addr(ptr_value);
2778 ExecutionContext exe_ctx(GetExecutionContextRef());
2779 valobj_sp = ValueObjectMemory::Create(
2780 exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, compiler_type);
2781 }
2782 return valobj_sp;
2783 }
2784
CastPointerType(const char * name,TypeSP & type_sp)2785 ValueObjectSP ValueObject::CastPointerType(const char *name, TypeSP &type_sp) {
2786 ValueObjectSP valobj_sp;
2787 AddressType address_type;
2788 addr_t ptr_value = GetPointerValue(&address_type);
2789
2790 if (ptr_value != LLDB_INVALID_ADDRESS) {
2791 Address ptr_addr(ptr_value);
2792 ExecutionContext exe_ctx(GetExecutionContextRef());
2793 valobj_sp = ValueObjectMemory::Create(
2794 exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, type_sp);
2795 }
2796 return valobj_sp;
2797 }
2798
EvaluationPoint()2799 ValueObject::EvaluationPoint::EvaluationPoint() : m_mod_id(), m_exe_ctx_ref() {}
2800
EvaluationPoint(ExecutionContextScope * exe_scope,bool use_selected)2801 ValueObject::EvaluationPoint::EvaluationPoint(ExecutionContextScope *exe_scope,
2802 bool use_selected)
2803 : m_mod_id(), m_exe_ctx_ref(), m_needs_update(true) {
2804 ExecutionContext exe_ctx(exe_scope);
2805 TargetSP target_sp(exe_ctx.GetTargetSP());
2806 if (target_sp) {
2807 m_exe_ctx_ref.SetTargetSP(target_sp);
2808 ProcessSP process_sp(exe_ctx.GetProcessSP());
2809 if (!process_sp)
2810 process_sp = target_sp->GetProcessSP();
2811
2812 if (process_sp) {
2813 m_mod_id = process_sp->GetModID();
2814 m_exe_ctx_ref.SetProcessSP(process_sp);
2815
2816 ThreadSP thread_sp(exe_ctx.GetThreadSP());
2817
2818 if (!thread_sp) {
2819 if (use_selected)
2820 thread_sp = process_sp->GetThreadList().GetSelectedThread();
2821 }
2822
2823 if (thread_sp) {
2824 m_exe_ctx_ref.SetThreadSP(thread_sp);
2825
2826 StackFrameSP frame_sp(exe_ctx.GetFrameSP());
2827 if (!frame_sp) {
2828 if (use_selected)
2829 frame_sp = thread_sp->GetSelectedFrame();
2830 }
2831 if (frame_sp)
2832 m_exe_ctx_ref.SetFrameSP(frame_sp);
2833 }
2834 }
2835 }
2836 }
2837
EvaluationPoint(const ValueObject::EvaluationPoint & rhs)2838 ValueObject::EvaluationPoint::EvaluationPoint(
2839 const ValueObject::EvaluationPoint &rhs)
2840 : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref), m_needs_update(true) {}
2841
2842 ValueObject::EvaluationPoint::~EvaluationPoint() = default;
2843
2844 // This function checks the EvaluationPoint against the current process state.
2845 // If the current state matches the evaluation point, or the evaluation point
2846 // is already invalid, then we return false, meaning "no change". If the
2847 // current state is different, we update our state, and return true meaning
2848 // "yes, change". If we did see a change, we also set m_needs_update to true,
2849 // so future calls to NeedsUpdate will return true. exe_scope will be set to
2850 // the current execution context scope.
2851
SyncWithProcessState(bool accept_invalid_exe_ctx)2852 bool ValueObject::EvaluationPoint::SyncWithProcessState(
2853 bool accept_invalid_exe_ctx) {
2854 // Start with the target, if it is NULL, then we're obviously not going to
2855 // get any further:
2856 const bool thread_and_frame_only_if_stopped = true;
2857 ExecutionContext exe_ctx(
2858 m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped));
2859
2860 if (exe_ctx.GetTargetPtr() == nullptr)
2861 return false;
2862
2863 // If we don't have a process nothing can change.
2864 Process *process = exe_ctx.GetProcessPtr();
2865 if (process == nullptr)
2866 return false;
2867
2868 // If our stop id is the current stop ID, nothing has changed:
2869 ProcessModID current_mod_id = process->GetModID();
2870
2871 // If the current stop id is 0, either we haven't run yet, or the process
2872 // state has been cleared. In either case, we aren't going to be able to sync
2873 // with the process state.
2874 if (current_mod_id.GetStopID() == 0)
2875 return false;
2876
2877 bool changed = false;
2878 const bool was_valid = m_mod_id.IsValid();
2879 if (was_valid) {
2880 if (m_mod_id == current_mod_id) {
2881 // Everything is already up to date in this object, no need to update the
2882 // execution context scope.
2883 changed = false;
2884 } else {
2885 m_mod_id = current_mod_id;
2886 m_needs_update = true;
2887 changed = true;
2888 }
2889 }
2890
2891 // Now re-look up the thread and frame in case the underlying objects have
2892 // gone away & been recreated. That way we'll be sure to return a valid
2893 // exe_scope. If we used to have a thread or a frame but can't find it
2894 // anymore, then mark ourselves as invalid.
2895
2896 if (!accept_invalid_exe_ctx) {
2897 if (m_exe_ctx_ref.HasThreadRef()) {
2898 ThreadSP thread_sp(m_exe_ctx_ref.GetThreadSP());
2899 if (thread_sp) {
2900 if (m_exe_ctx_ref.HasFrameRef()) {
2901 StackFrameSP frame_sp(m_exe_ctx_ref.GetFrameSP());
2902 if (!frame_sp) {
2903 // We used to have a frame, but now it is gone
2904 SetInvalid();
2905 changed = was_valid;
2906 }
2907 }
2908 } else {
2909 // We used to have a thread, but now it is gone
2910 SetInvalid();
2911 changed = was_valid;
2912 }
2913 }
2914 }
2915
2916 return changed;
2917 }
2918
SetUpdated()2919 void ValueObject::EvaluationPoint::SetUpdated() {
2920 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
2921 if (process_sp)
2922 m_mod_id = process_sp->GetModID();
2923 m_needs_update = false;
2924 }
2925
ClearUserVisibleData(uint32_t clear_mask)2926 void ValueObject::ClearUserVisibleData(uint32_t clear_mask) {
2927 if ((clear_mask & eClearUserVisibleDataItemsValue) ==
2928 eClearUserVisibleDataItemsValue)
2929 m_value_str.clear();
2930
2931 if ((clear_mask & eClearUserVisibleDataItemsLocation) ==
2932 eClearUserVisibleDataItemsLocation)
2933 m_location_str.clear();
2934
2935 if ((clear_mask & eClearUserVisibleDataItemsSummary) ==
2936 eClearUserVisibleDataItemsSummary)
2937 m_summary_str.clear();
2938
2939 if ((clear_mask & eClearUserVisibleDataItemsDescription) ==
2940 eClearUserVisibleDataItemsDescription)
2941 m_object_desc_str.clear();
2942
2943 if ((clear_mask & eClearUserVisibleDataItemsSyntheticChildren) ==
2944 eClearUserVisibleDataItemsSyntheticChildren) {
2945 if (m_synthetic_value)
2946 m_synthetic_value = nullptr;
2947 }
2948 }
2949
GetSymbolContextScope()2950 SymbolContextScope *ValueObject::GetSymbolContextScope() {
2951 if (m_parent) {
2952 if (!m_parent->IsPointerOrReferenceType())
2953 return m_parent->GetSymbolContextScope();
2954 }
2955 return nullptr;
2956 }
2957
2958 lldb::ValueObjectSP
CreateValueObjectFromExpression(llvm::StringRef name,llvm::StringRef expression,const ExecutionContext & exe_ctx)2959 ValueObject::CreateValueObjectFromExpression(llvm::StringRef name,
2960 llvm::StringRef expression,
2961 const ExecutionContext &exe_ctx) {
2962 return CreateValueObjectFromExpression(name, expression, exe_ctx,
2963 EvaluateExpressionOptions());
2964 }
2965
CreateValueObjectFromExpression(llvm::StringRef name,llvm::StringRef expression,const ExecutionContext & exe_ctx,const EvaluateExpressionOptions & options)2966 lldb::ValueObjectSP ValueObject::CreateValueObjectFromExpression(
2967 llvm::StringRef name, llvm::StringRef expression,
2968 const ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options) {
2969 lldb::ValueObjectSP retval_sp;
2970 lldb::TargetSP target_sp(exe_ctx.GetTargetSP());
2971 if (!target_sp)
2972 return retval_sp;
2973 if (expression.empty())
2974 return retval_sp;
2975 target_sp->EvaluateExpression(expression, exe_ctx.GetFrameSP().get(),
2976 retval_sp, options);
2977 if (retval_sp && !name.empty())
2978 retval_sp->SetName(ConstString(name));
2979 return retval_sp;
2980 }
2981
CreateValueObjectFromAddress(llvm::StringRef name,uint64_t address,const ExecutionContext & exe_ctx,CompilerType type)2982 lldb::ValueObjectSP ValueObject::CreateValueObjectFromAddress(
2983 llvm::StringRef name, uint64_t address, const ExecutionContext &exe_ctx,
2984 CompilerType type) {
2985 if (type) {
2986 CompilerType pointer_type(type.GetPointerType());
2987 if (pointer_type) {
2988 lldb::DataBufferSP buffer(
2989 new lldb_private::DataBufferHeap(&address, sizeof(lldb::addr_t)));
2990 lldb::ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create(
2991 exe_ctx.GetBestExecutionContextScope(), pointer_type,
2992 ConstString(name), buffer, exe_ctx.GetByteOrder(),
2993 exe_ctx.GetAddressByteSize()));
2994 if (ptr_result_valobj_sp) {
2995 ptr_result_valobj_sp->GetValue().SetValueType(
2996 Value::ValueType::LoadAddress);
2997 Status err;
2998 ptr_result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
2999 if (ptr_result_valobj_sp && !name.empty())
3000 ptr_result_valobj_sp->SetName(ConstString(name));
3001 }
3002 return ptr_result_valobj_sp;
3003 }
3004 }
3005 return lldb::ValueObjectSP();
3006 }
3007
CreateValueObjectFromData(llvm::StringRef name,const DataExtractor & data,const ExecutionContext & exe_ctx,CompilerType type)3008 lldb::ValueObjectSP ValueObject::CreateValueObjectFromData(
3009 llvm::StringRef name, const DataExtractor &data,
3010 const ExecutionContext &exe_ctx, CompilerType type) {
3011 lldb::ValueObjectSP new_value_sp;
3012 new_value_sp = ValueObjectConstResult::Create(
3013 exe_ctx.GetBestExecutionContextScope(), type, ConstString(name), data,
3014 LLDB_INVALID_ADDRESS);
3015 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
3016 if (new_value_sp && !name.empty())
3017 new_value_sp->SetName(ConstString(name));
3018 return new_value_sp;
3019 }
3020
GetModule()3021 ModuleSP ValueObject::GetModule() {
3022 ValueObject *root(GetRoot());
3023 if (root != this)
3024 return root->GetModule();
3025 return lldb::ModuleSP();
3026 }
3027
GetRoot()3028 ValueObject *ValueObject::GetRoot() {
3029 if (m_root)
3030 return m_root;
3031 return (m_root = FollowParentChain([](ValueObject *vo) -> bool {
3032 return (vo->m_parent != nullptr);
3033 }));
3034 }
3035
3036 ValueObject *
FollowParentChain(std::function<bool (ValueObject *)> f)3037 ValueObject::FollowParentChain(std::function<bool(ValueObject *)> f) {
3038 ValueObject *vo = this;
3039 while (vo) {
3040 if (!f(vo))
3041 break;
3042 vo = vo->m_parent;
3043 }
3044 return vo;
3045 }
3046
GetAddressTypeOfChildren()3047 AddressType ValueObject::GetAddressTypeOfChildren() {
3048 if (m_address_type_of_ptr_or_ref_children == eAddressTypeInvalid) {
3049 ValueObject *root(GetRoot());
3050 if (root != this)
3051 return root->GetAddressTypeOfChildren();
3052 }
3053 return m_address_type_of_ptr_or_ref_children;
3054 }
3055
GetDynamicValueType()3056 lldb::DynamicValueType ValueObject::GetDynamicValueType() {
3057 ValueObject *with_dv_info = this;
3058 while (with_dv_info) {
3059 if (with_dv_info->HasDynamicValueTypeInfo())
3060 return with_dv_info->GetDynamicValueTypeImpl();
3061 with_dv_info = with_dv_info->m_parent;
3062 }
3063 return lldb::eNoDynamicValues;
3064 }
3065
GetFormat() const3066 lldb::Format ValueObject::GetFormat() const {
3067 const ValueObject *with_fmt_info = this;
3068 while (with_fmt_info) {
3069 if (with_fmt_info->m_format != lldb::eFormatDefault)
3070 return with_fmt_info->m_format;
3071 with_fmt_info = with_fmt_info->m_parent;
3072 }
3073 return m_format;
3074 }
3075
GetPreferredDisplayLanguage()3076 lldb::LanguageType ValueObject::GetPreferredDisplayLanguage() {
3077 lldb::LanguageType type = m_preferred_display_language;
3078 if (m_preferred_display_language == lldb::eLanguageTypeUnknown) {
3079 if (GetRoot()) {
3080 if (GetRoot() == this) {
3081 if (StackFrameSP frame_sp = GetFrameSP()) {
3082 const SymbolContext &sc(
3083 frame_sp->GetSymbolContext(eSymbolContextCompUnit));
3084 if (CompileUnit *cu = sc.comp_unit)
3085 type = cu->GetLanguage();
3086 }
3087 } else {
3088 type = GetRoot()->GetPreferredDisplayLanguage();
3089 }
3090 }
3091 }
3092 return (m_preferred_display_language = type); // only compute it once
3093 }
3094
SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType lt)3095 void ValueObject::SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType lt) {
3096 if (m_preferred_display_language == lldb::eLanguageTypeUnknown)
3097 SetPreferredDisplayLanguage(lt);
3098 }
3099
CanProvideValue()3100 bool ValueObject::CanProvideValue() {
3101 // we need to support invalid types as providers of values because some bare-
3102 // board debugging scenarios have no notion of types, but still manage to
3103 // have raw numeric values for things like registers. sigh.
3104 CompilerType type = GetCompilerType();
3105 return (!type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
3106 }
3107
3108
3109
Persist()3110 ValueObjectSP ValueObject::Persist() {
3111 if (!UpdateValueIfNeeded())
3112 return nullptr;
3113
3114 TargetSP target_sp(GetTargetSP());
3115 if (!target_sp)
3116 return nullptr;
3117
3118 PersistentExpressionState *persistent_state =
3119 target_sp->GetPersistentExpressionStateForLanguage(
3120 GetPreferredDisplayLanguage());
3121
3122 if (!persistent_state)
3123 return nullptr;
3124
3125 ConstString name = persistent_state->GetNextPersistentVariableName();
3126
3127 ValueObjectSP const_result_sp =
3128 ValueObjectConstResult::Create(target_sp.get(), GetValue(), name);
3129
3130 ExpressionVariableSP persistent_var_sp =
3131 persistent_state->CreatePersistentVariable(const_result_sp);
3132 persistent_var_sp->m_live_sp = persistent_var_sp->m_frozen_sp;
3133 persistent_var_sp->m_flags |= ExpressionVariable::EVIsProgramReference;
3134
3135 return persistent_var_sp->GetValueObject();
3136 }
3137