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/LLDBLog.h"
46#include "lldb/Utility/Log.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
67namespace lldb_private {
68class ExecutionContextScope;
69}
70namespace lldb_private {
71class SymbolContextScope;
72}
73
74using namespace lldb;
75using namespace lldb_private;
76
77static user_id_t g_value_obj_uid = 0;
78
79// ValueObject constructor
80ValueObject::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
91ValueObject::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
109ValueObject::~ValueObject() = default;
110
111bool 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
202bool ValueObject::UpdateFormatsIfNeeded() {
203 Log *log = GetLog(LLDBLog::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
229void 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
236void 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
246CompilerType 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;
269 if (m_override_type.IsValid())
270 return m_override_type;
271 }
272 }
273 return compiler_type;
274}
275
276
277
278DataExtractor &ValueObject::GetDataExtractor() {
279 UpdateValueIfNeeded(false);
280 return m_data;
281}
282
283const Status &ValueObject::GetError() {
284 UpdateValueIfNeeded(false);
285 return m_error;
286}
287
288const 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
332bool 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
350bool 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
375ValueObjectSP 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
395lldb::ValueObjectSP
396ValueObject::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
412lldb::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
428lldb::ValueObjectSP
429ValueObject::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
445lldb::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
462size_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
468ValueObjectSP 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
496size_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
513bool 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()
526void ValueObject::SetNumChildren(size_t num_children) {
527 m_flags.m_children_count_valid = true;
528 m_children.SetChildrenCount(num_children);
529}
530
531ValueObject *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
585bool 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
592bool 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
629const 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
641bool ValueObject::GetSummaryAsCString(std::string &destination,
642 const TypeSummaryOptions &options) {
643 return GetSummaryAsCString(GetSummaryFormat().get(), destination, options);
644}
645
646bool 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
663size_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
765uint64_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
783bool 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().value_or(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
850static bool CopyStringDataToBufferSP(const StreamString &source,
851 lldb::WritableDataBufferSP &destination) {
852 llvm::StringRef src = source.GetString();
853 src = src.rtrim('\0');
854 destination = std::make_shared<DataBufferHeap>(src.size(), 0);
855 memcpy(destination->GetBytes(), src.data(), src.size());
856 return true;
857}
858
859std::pair<size_t, bool>
860ValueObject::ReadPointedString(lldb::WritableDataBufferSP &buffer_sp,
861 Status &error, uint32_t max_length,
862 bool honor_array, Format item_format) {
863 bool was_capped = false;
864 StreamString s;
865 ExecutionContext exe_ctx(GetExecutionContextRef());
866 Target *target = exe_ctx.GetTargetPtr();
867
868 if (!target) {
869 s << "<no target to read from>";
870 error.SetErrorString("no target to read from");
871 CopyStringDataToBufferSP(s, buffer_sp);
872 return {0, was_capped};
873 }
874
875 if (max_length == 0)
876 max_length = target->GetMaximumSizeOfStringSummary();
877
878 size_t bytes_read = 0;
879 size_t total_bytes_read = 0;
880
881 CompilerType compiler_type = GetCompilerType();
882 CompilerType elem_or_pointee_compiler_type;
883 const Flags type_flags(GetTypeInfo(&elem_or_pointee_compiler_type));
884 if (type_flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
885 elem_or_pointee_compiler_type.IsCharType()) {
886 addr_t cstr_address = LLDB_INVALID_ADDRESS;
887 AddressType cstr_address_type = eAddressTypeInvalid;
888
889 size_t cstr_len = 0;
890 bool capped_data = false;
891 const bool is_array = type_flags.Test(eTypeIsArray);
892 if (is_array) {
893 // We have an array
894 uint64_t array_size = 0;
895 if (compiler_type.IsArrayType(nullptr, &array_size)) {
896 cstr_len = array_size;
897 if (cstr_len > max_length) {
898 capped_data = true;
899 cstr_len = max_length;
900 }
901 }
902 cstr_address = GetAddressOf(true, &cstr_address_type);
903 } else {
904 // We have a pointer
905 cstr_address = GetPointerValue(&cstr_address_type);
906 }
907
908 if (cstr_address == 0 || cstr_address == LLDB_INVALID_ADDRESS) {
909 if (cstr_address_type == eAddressTypeHost && is_array) {
910 const char *cstr = GetDataExtractor().PeekCStr(0);
911 if (cstr == nullptr) {
912 s << "<invalid address>";
913 error.SetErrorString("invalid address");
914 CopyStringDataToBufferSP(s, buffer_sp);
915 return {0, was_capped};
916 }
917 s << llvm::StringRef(cstr, cstr_len);
918 CopyStringDataToBufferSP(s, buffer_sp);
919 return {cstr_len, was_capped};
920 } else {
921 s << "<invalid address>";
922 error.SetErrorString("invalid address");
923 CopyStringDataToBufferSP(s, buffer_sp);
924 return {0, was_capped};
925 }
926 }
927
928 Address cstr_so_addr(cstr_address);
929 DataExtractor data;
930 if (cstr_len > 0 && honor_array) {
931 // I am using GetPointeeData() here to abstract the fact that some
932 // ValueObjects are actually frozen pointers in the host but the pointed-
933 // to data lives in the debuggee, and GetPointeeData() automatically
934 // takes care of this
935 GetPointeeData(data, 0, cstr_len);
936
937 if ((bytes_read = data.GetByteSize()) > 0) {
938 total_bytes_read = bytes_read;
939 for (size_t offset = 0; offset < bytes_read; offset++)
940 s.Printf("%c", *data.PeekData(offset, 1));
941 if (capped_data)
942 was_capped = true;
943 }
944 } else {
945 cstr_len = max_length;
946 const size_t k_max_buf_size = 64;
947
948 size_t offset = 0;
949
950 int cstr_len_displayed = -1;
951 bool capped_cstr = false;
952 // I am using GetPointeeData() here to abstract the fact that some
953 // ValueObjects are actually frozen pointers in the host but the pointed-
954 // to data lives in the debuggee, and GetPointeeData() automatically
955 // takes care of this
956 while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) {
957 total_bytes_read += bytes_read;
958 const char *cstr = data.PeekCStr(0);
959 size_t len = strnlen(cstr, k_max_buf_size);
960 if (cstr_len_displayed < 0)
961 cstr_len_displayed = len;
962
963 if (len == 0)
964 break;
965 cstr_len_displayed += len;
966 if (len > bytes_read)
967 len = bytes_read;
968 if (len > cstr_len)
969 len = cstr_len;
970
971 for (size_t offset = 0; offset < bytes_read; offset++)
972 s.Printf("%c", *data.PeekData(offset, 1));
973
974 if (len < k_max_buf_size)
975 break;
976
977 if (len >= cstr_len) {
978 capped_cstr = true;
979 break;
980 }
981
982 cstr_len -= len;
983 offset += len;
984 }
985
986 if (cstr_len_displayed >= 0) {
987 if (capped_cstr)
988 was_capped = true;
989 }
990 }
991 } else {
992 error.SetErrorString("not a string object");
993 s << "<not a string object>";
994 }
995 CopyStringDataToBufferSP(s, buffer_sp);
996 return {total_bytes_read, was_capped};
997}
998
999const char *ValueObject::GetObjectDescription() {
1000 if (!UpdateValueIfNeeded(true))
1001 return nullptr;
1002
1003 // Return cached value.
1004 if (!m_object_desc_str.empty())
1005 return m_object_desc_str.c_str();
1006
1007 ExecutionContext exe_ctx(GetExecutionContextRef());
1008 Process *process = exe_ctx.GetProcessPtr();
1009 if (!process)
1010 return nullptr;
1011
1012 // Returns the object description produced by one language runtime.
1013 auto get_object_description = [&](LanguageType language) -> const char * {
1014 if (LanguageRuntime *runtime = process->GetLanguageRuntime(language)) {
1015 StreamString s;
1016 if (runtime->GetObjectDescription(s, *this)) {
1017 m_object_desc_str.append(std::string(s.GetString()));
1018 return m_object_desc_str.c_str();
1019 }
1020 }
1021 return nullptr;
1022 };
1023
1024 // Try the native language runtime first.
1025 LanguageType native_language = GetObjectRuntimeLanguage();
1026 if (const char *desc = get_object_description(native_language))
1027 return desc;
1028
1029 // Try the Objective-C language runtime. This fallback is necessary
1030 // for Objective-C++ and mixed Objective-C / C++ programs.
1031 if (Language::LanguageIsCFamily(native_language))
1032 return get_object_description(eLanguageTypeObjC);
1033 return nullptr;
1034}
1035
1036bool ValueObject::GetValueAsCString(const lldb_private::TypeFormatImpl &format,
1037 std::string &destination) {
1038 if (UpdateValueIfNeeded(false))
1039 return format.FormatObject(this, destination);
1040 else
1041 return false;
1042}
1043
1044bool ValueObject::GetValueAsCString(lldb::Format format,
1045 std::string &destination) {
1046 return GetValueAsCString(TypeFormatImpl_Format(format), destination);
1047}
1048
1049const char *ValueObject::GetValueAsCString() {
1050 if (UpdateValueIfNeeded(true)) {
1051 lldb::TypeFormatImplSP format_sp;
1052 lldb::Format my_format = GetFormat();
1053 if (my_format == lldb::eFormatDefault) {
1054 if (m_type_format_sp)
1055 format_sp = m_type_format_sp;
1056 else {
1057 if (m_flags.m_is_bitfield_for_scalar)
1058 my_format = eFormatUnsigned;
1059 else {
1060 if (m_value.GetContextType() == Value::ContextType::RegisterInfo) {
1061 const RegisterInfo *reg_info = m_value.GetRegisterInfo();
1062 if (reg_info)
1063 my_format = reg_info->format;
1064 } else {
1065 my_format = GetValue().GetCompilerType().GetFormat();
1066 }
1067 }
1068 }
1069 }
1070 if (my_format != m_last_format || m_value_str.empty()) {
1071 m_last_format = my_format;
1072 if (!format_sp)
1073 format_sp = std::make_shared<TypeFormatImpl_Format>(my_format);
1074 if (GetValueAsCString(*format_sp.get(), m_value_str)) {
1075 if (!m_flags.m_value_did_change && m_flags.m_old_value_valid) {
1076 // The value was gotten successfully, so we consider the value as
1077 // changed if the value string differs
1078 SetValueDidChange(m_old_value_str != m_value_str);
1079 }
1080 }
1081 }
1082 }
1083 if (m_value_str.empty())
1084 return nullptr;
1085 return m_value_str.c_str();
1086}
1087
1088// if > 8bytes, 0 is returned. this method should mostly be used to read
1089// address values out of pointers
1090uint64_t ValueObject::GetValueAsUnsigned(uint64_t fail_value, bool *success) {
1091 // If our byte size is zero this is an aggregate type that has children
1092 if (CanProvideValue()) {
1093 Scalar scalar;
1094 if (ResolveValue(scalar)) {
1095 if (success)
1096 *success = true;
1097 scalar.MakeUnsigned();
1098 return scalar.ULongLong(fail_value);
1099 }
1100 // fallthrough, otherwise...
1101 }
1102
1103 if (success)
1104 *success = false;
1105 return fail_value;
1106}
1107
1108int64_t ValueObject::GetValueAsSigned(int64_t fail_value, bool *success) {
1109 // If our byte size is zero this is an aggregate type that has children
1110 if (CanProvideValue()) {
1111 Scalar scalar;
1112 if (ResolveValue(scalar)) {
1113 if (success)
1114 *success = true;
1115 scalar.MakeSigned();
1116 return scalar.SLongLong(fail_value);
1117 }
1118 // fallthrough, otherwise...
1119 }
1120
1121 if (success)
1122 *success = false;
1123 return fail_value;
1124}
1125
1126// if any more "special cases" are added to
1127// ValueObject::DumpPrintableRepresentation() please keep this call up to date
1128// by returning true for your new special cases. We will eventually move to
1129// checking this call result before trying to display special cases
1130bool ValueObject::HasSpecialPrintableRepresentation(
1131 ValueObjectRepresentationStyle val_obj_display, Format custom_format) {
1132 Flags flags(GetTypeInfo());
1133 if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
1134 val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) {
1135 if (IsCStringContainer(true) &&
1136 (custom_format == eFormatCString || custom_format == eFormatCharArray ||
1137 custom_format == eFormatChar || custom_format == eFormatVectorOfChar))
1138 return true;
1139
1140 if (flags.Test(eTypeIsArray)) {
1141 if ((custom_format == eFormatBytes) ||
1142 (custom_format == eFormatBytesWithASCII))
1143 return true;
1144
1145 if ((custom_format == eFormatVectorOfChar) ||
1146 (custom_format == eFormatVectorOfFloat32) ||
1147 (custom_format == eFormatVectorOfFloat64) ||
1148 (custom_format == eFormatVectorOfSInt16) ||
1149 (custom_format == eFormatVectorOfSInt32) ||
1150 (custom_format == eFormatVectorOfSInt64) ||
1151 (custom_format == eFormatVectorOfSInt8) ||
1152 (custom_format == eFormatVectorOfUInt128) ||
1153 (custom_format == eFormatVectorOfUInt16) ||
1154 (custom_format == eFormatVectorOfUInt32) ||
1155 (custom_format == eFormatVectorOfUInt64) ||
1156 (custom_format == eFormatVectorOfUInt8))
1157 return true;
1158 }
1159 }
1160 return false;
1161}
1162
1163bool ValueObject::DumpPrintableRepresentation(
1164 Stream &s, ValueObjectRepresentationStyle val_obj_display,
1165 Format custom_format, PrintableRepresentationSpecialCases special,
1166 bool do_dump_error) {
1167
1168 Flags flags(GetTypeInfo());
1169
1170 bool allow_special =
1171 (special == ValueObject::PrintableRepresentationSpecialCases::eAllow);
1172 const bool only_special = false;
1173
1174 if (allow_special) {
1175 if (flags.AnySet(eTypeIsArray | eTypeIsPointer) &&
1176 val_obj_display == ValueObject::eValueObjectRepresentationStyleValue) {
1177 // when being asked to get a printable display an array or pointer type
1178 // directly, try to "do the right thing"
1179
1180 if (IsCStringContainer(true) &&
1181 (custom_format == eFormatCString ||
1182 custom_format == eFormatCharArray || custom_format == eFormatChar ||
1183 custom_format ==
1184 eFormatVectorOfChar)) // print char[] & char* directly
1185 {
1186 Status error;
1187 lldb::WritableDataBufferSP buffer_sp;
1188 std::pair<size_t, bool> read_string = ReadPointedString(
1189 buffer_sp, error, 0, (custom_format == eFormatVectorOfChar) ||
1190 (custom_format == eFormatCharArray));
1191 lldb_private::formatters::StringPrinter::
1192 ReadBufferAndDumpToStreamOptions options(*this);
1193 options.SetData(DataExtractor(
1194 buffer_sp, lldb::eByteOrderInvalid,
1195 8)); // none of this matters for a string - pass some defaults
1196 options.SetStream(&s);
1197 options.SetPrefixToken(nullptr);
1198 options.SetQuote('"');
1199 options.SetSourceSize(buffer_sp->GetByteSize());
1200 options.SetIsTruncated(read_string.second);
1201 options.SetBinaryZeroIsTerminator(custom_format != eFormatVectorOfChar);
1202 formatters::StringPrinter::ReadBufferAndDumpToStream<
1203 lldb_private::formatters::StringPrinter::StringElementType::ASCII>(
1204 options);
1205 return !error.Fail();
1206 }
1207
1208 if (custom_format == eFormatEnum)
1209 return false;
1210
1211 // this only works for arrays, because I have no way to know when the
1212 // pointed memory ends, and no special \0 end of data marker
1213 if (flags.Test(eTypeIsArray)) {
1214 if ((custom_format == eFormatBytes) ||
1215 (custom_format == eFormatBytesWithASCII)) {
1216 const size_t count = GetNumChildren();
1217
1218 s << '[';
1219 for (size_t low = 0; low < count; low++) {
1220
1221 if (low)
1222 s << ',';
1223
1224 ValueObjectSP child = GetChildAtIndex(low, true);
1225 if (!child.get()) {
1226 s << "<invalid child>";
1227 continue;
1228 }
1229 child->DumpPrintableRepresentation(
1230 s, ValueObject::eValueObjectRepresentationStyleValue,
1231 custom_format);
1232 }
1233
1234 s << ']';
1235
1236 return true;
1237 }
1238
1239 if ((custom_format == eFormatVectorOfChar) ||
1240 (custom_format == eFormatVectorOfFloat32) ||
1241 (custom_format == eFormatVectorOfFloat64) ||
1242 (custom_format == eFormatVectorOfSInt16) ||
1243 (custom_format == eFormatVectorOfSInt32) ||
1244 (custom_format == eFormatVectorOfSInt64) ||
1245 (custom_format == eFormatVectorOfSInt8) ||
1246 (custom_format == eFormatVectorOfUInt128) ||
1247 (custom_format == eFormatVectorOfUInt16) ||
1248 (custom_format == eFormatVectorOfUInt32) ||
1249 (custom_format == eFormatVectorOfUInt64) ||
1250 (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes
1251 // with ASCII or any vector
1252 // format should be printed
1253 // directly
1254 {
1255 const size_t count = GetNumChildren();
1256
1257 Format format = FormatManager::GetSingleItemFormat(custom_format);
1258
1259 s << '[';
1260 for (size_t low = 0; low < count; low++) {
1261
1262 if (low)
1263 s << ',';
1264
1265 ValueObjectSP child = GetChildAtIndex(low, true);
1266 if (!child.get()) {
1267 s << "<invalid child>";
1268 continue;
1269 }
1270 child->DumpPrintableRepresentation(
1271 s, ValueObject::eValueObjectRepresentationStyleValue, format);
1272 }
1273
1274 s << ']';
1275
1276 return true;
1277 }
1278 }
1279
1280 if ((custom_format == eFormatBoolean) ||
1281 (custom_format == eFormatBinary) || (custom_format == eFormatChar) ||
1282 (custom_format == eFormatCharPrintable) ||
1283 (custom_format == eFormatComplexFloat) ||
1284 (custom_format == eFormatDecimal) || (custom_format == eFormatHex) ||
1285 (custom_format == eFormatHexUppercase) ||
1286 (custom_format == eFormatFloat) || (custom_format == eFormatOctal) ||
1287 (custom_format == eFormatOSType) ||
1288 (custom_format == eFormatUnicode16) ||
1289 (custom_format == eFormatUnicode32) ||
1290 (custom_format == eFormatUnsigned) ||
1291 (custom_format == eFormatPointer) ||
1292 (custom_format == eFormatComplexInteger) ||
1293 (custom_format == eFormatComplex) ||
1294 (custom_format == eFormatDefault)) // use the [] operator
1295 return false;
1296 }
1297 }
1298
1299 if (only_special)
1300 return false;
1301
1302 bool var_success = false;
1303
1304 {
1305 llvm::StringRef str;
1306
1307 // this is a local stream that we are using to ensure that the data pointed
1308 // to by cstr survives long enough for us to copy it to its destination -
1309 // it is necessary to have this temporary storage area for cases where our
1310 // desired output is not backed by some other longer-term storage
1311 StreamString strm;
1312
1313 if (custom_format != eFormatInvalid)
1314 SetFormat(custom_format);
1315
1316 switch (val_obj_display) {
1317 case eValueObjectRepresentationStyleValue:
1318 str = GetValueAsCString();
1319 break;
1320
1321 case eValueObjectRepresentationStyleSummary:
1322 str = GetSummaryAsCString();
1323 break;
1324
1325 case eValueObjectRepresentationStyleLanguageSpecific:
1326 str = GetObjectDescription();
1327 break;
1328
1329 case eValueObjectRepresentationStyleLocation:
1330 str = GetLocationAsCString();
1331 break;
1332
1333 case eValueObjectRepresentationStyleChildrenCount:
1334 strm.Printf("%" PRIu64 "", (uint64_t)GetNumChildren());
1335 str = strm.GetString();
1336 break;
1337
1338 case eValueObjectRepresentationStyleType:
1339 str = GetTypeName().GetStringRef();
1340 break;
1341
1342 case eValueObjectRepresentationStyleName:
1343 str = GetName().GetStringRef();
1344 break;
1345
1346 case eValueObjectRepresentationStyleExpressionPath:
1347 GetExpressionPath(strm);
1348 str = strm.GetString();
1349 break;
1350 }
1351
1352 if (str.empty()) {
1353 if (val_obj_display == eValueObjectRepresentationStyleValue)
1354 str = GetSummaryAsCString();
1355 else if (val_obj_display == eValueObjectRepresentationStyleSummary) {
1356 if (!CanProvideValue()) {
1357 strm.Printf("%s @ %s", GetTypeName().AsCString(),
1358 GetLocationAsCString());
1359 str = strm.GetString();
1360 } else
1361 str = GetValueAsCString();
1362 }
1363 }
1364
1365 if (!str.empty())
1366 s << str;
1367 else {
1368 if (m_error.Fail()) {
1369 if (do_dump_error)
1370 s.Printf("<%s>", m_error.AsCString());
1371 else
1372 return false;
1373 } else if (val_obj_display == eValueObjectRepresentationStyleSummary)
1374 s.PutCString("<no summary available>");
1375 else if (val_obj_display == eValueObjectRepresentationStyleValue)
1376 s.PutCString("<no value available>");
1377 else if (val_obj_display ==
1378 eValueObjectRepresentationStyleLanguageSpecific)
1379 s.PutCString("<not a valid Objective-C object>"); // edit this if we
1380 // have other runtimes
1381 // that support a
1382 // description
1383 else
1384 s.PutCString("<no printable representation>");
1385 }
1386
1387 // we should only return false here if we could not do *anything* even if
1388 // we have an error message as output, that's a success from our callers'
1389 // perspective, so return true
1390 var_success = true;
1391
1392 if (custom_format != eFormatInvalid)
1393 SetFormat(eFormatDefault);
1394 }
1395
1396 return var_success;
1397}
1398
1399addr_t ValueObject::GetAddressOf(bool scalar_is_load_address,
1400 AddressType *address_type) {
1401 // Can't take address of a bitfield
1402 if (IsBitfield())
1403 return LLDB_INVALID_ADDRESS;
1404
1405 if (!UpdateValueIfNeeded(false))
1406 return LLDB_INVALID_ADDRESS;
1407
1408 switch (m_value.GetValueType()) {
1409 case Value::ValueType::Invalid:
1410 return LLDB_INVALID_ADDRESS;
1411 case Value::ValueType::Scalar:
1412 if (scalar_is_load_address) {
1413 if (address_type)
1414 *address_type = eAddressTypeLoad;
1415 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1416 }
1417 break;
1418
1419 case Value::ValueType::LoadAddress:
1420 case Value::ValueType::FileAddress: {
1421 if (address_type)
1422 *address_type = m_value.GetValueAddressType();
1423 return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1424 } break;
1425 case Value::ValueType::HostAddress: {
1426 if (address_type)
1427 *address_type = m_value.GetValueAddressType();
1428 return LLDB_INVALID_ADDRESS;
1429 } break;
1430 }
1431 if (address_type)
1432 *address_type = eAddressTypeInvalid;
1433 return LLDB_INVALID_ADDRESS;
1434}
1435
1436addr_t ValueObject::GetPointerValue(AddressType *address_type) {
1437 addr_t address = LLDB_INVALID_ADDRESS;
1438 if (address_type)
1439 *address_type = eAddressTypeInvalid;
1440
1441 if (!UpdateValueIfNeeded(false))
1442 return address;
1443
1444 switch (m_value.GetValueType()) {
1445 case Value::ValueType::Invalid:
1446 return LLDB_INVALID_ADDRESS;
1447 case Value::ValueType::Scalar:
1448 address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1449 break;
1450
1451 case Value::ValueType::HostAddress:
1452 case Value::ValueType::LoadAddress:
1453 case Value::ValueType::FileAddress: {
1454 lldb::offset_t data_offset = 0;
1455 address = m_data.GetAddress(&data_offset);
1456 } break;
1457 }
1458
1459 if (address_type)
1460 *address_type = GetAddressTypeOfChildren();
1461
1462 return address;
1463}
1464
1465bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
1466 error.Clear();
1467 // Make sure our value is up to date first so that our location and location
1468 // type is valid.
1469 if (!UpdateValueIfNeeded(false)) {
1470 error.SetErrorString("unable to read value");
1471 return false;
1472 }
1473
1474 uint64_t count = 0;
1475 const Encoding encoding = GetCompilerType().GetEncoding(count);
1476
1477 const size_t byte_size = GetByteSize().value_or(0);
1478
1479 Value::ValueType value_type = m_value.GetValueType();
1480
1481 if (value_type == Value::ValueType::Scalar) {
1482 // If the value is already a scalar, then let the scalar change itself:
1483 m_value.GetScalar().SetValueFromCString(value_str, encoding, byte_size);
1484 } else if (byte_size <= 16) {
1485 // If the value fits in a scalar, then make a new scalar and again let the
1486 // scalar code do the conversion, then figure out where to put the new
1487 // value.
1488 Scalar new_scalar;
1489 error = new_scalar.SetValueFromCString(value_str, encoding, byte_size);
1490 if (error.Success()) {
1491 switch (value_type) {
1492 case Value::ValueType::LoadAddress: {
1493 // If it is a load address, then the scalar value is the storage
1494 // location of the data, and we have to shove this value down to that
1495 // load location.
1496 ExecutionContext exe_ctx(GetExecutionContextRef());
1497 Process *process = exe_ctx.GetProcessPtr();
1498 if (process) {
1499 addr_t target_addr =
1500 m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1501 size_t bytes_written = process->WriteScalarToMemory(
1502 target_addr, new_scalar, byte_size, error);
1503 if (!error.Success())
1504 return false;
1505 if (bytes_written != byte_size) {
1506 error.SetErrorString("unable to write value to memory");
1507 return false;
1508 }
1509 }
1510 } break;
1511 case Value::ValueType::HostAddress: {
1512 // If it is a host address, then we stuff the scalar as a DataBuffer
1513 // into the Value's data.
1514 DataExtractor new_data;
1515 new_data.SetByteOrder(m_data.GetByteOrder());
1516
1517 DataBufferSP buffer_sp(new DataBufferHeap(byte_size, 0));
1518 m_data.SetData(buffer_sp, 0);
1519 bool success = new_scalar.GetData(new_data);
1520 if (success) {
1521 new_data.CopyByteOrderedData(
1522 0, byte_size, const_cast<uint8_t *>(m_data.GetDataStart()),
1523 byte_size, m_data.GetByteOrder());
1524 }
1525 m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1526
1527 } break;
1528 case Value::ValueType::Invalid:
1529 error.SetErrorString("invalid location");
1530 return false;
1531 case Value::ValueType::FileAddress:
1532 case Value::ValueType::Scalar:
1533 break;
1534 }
1535 } else {
1536 return false;
1537 }
1538 } else {
1539 // We don't support setting things bigger than a scalar at present.
1540 error.SetErrorString("unable to write aggregate data type");
1541 return false;
1542 }
1543
1544 // If we have reached this point, then we have successfully changed the
1545 // value.
1546 SetNeedsUpdate();
1547 return true;
1548}
1549
1550bool ValueObject::GetDeclaration(Declaration &decl) {
1551 decl.Clear();
1552 return false;
1553}
1554
1555void ValueObject::AddSyntheticChild(ConstString key,
1556 ValueObject *valobj) {
1557 m_synthetic_children[key] = valobj;
1558}
1559
1560ValueObjectSP ValueObject::GetSyntheticChild(ConstString key) const {
1561 ValueObjectSP synthetic_child_sp;
1562 std::map<ConstString, ValueObject *>::const_iterator pos =
1563 m_synthetic_children.find(key);
1564 if (pos != m_synthetic_children.end())
1565 synthetic_child_sp = pos->second->GetSP();
1566 return synthetic_child_sp;
1567}
1568
1569bool ValueObject::IsPossibleDynamicType() {
1570 ExecutionContext exe_ctx(GetExecutionContextRef());
1571 Process *process = exe_ctx.GetProcessPtr();
1572 if (process)
1573 return process->IsPossibleDynamicValue(*this);
1574 else
1575 return GetCompilerType().IsPossibleDynamicType(nullptr, true, true);
1576}
1577
1578bool ValueObject::IsRuntimeSupportValue() {
1579 Process *process(GetProcessSP().get());
1580 if (!process)
1581 return false;
1582
1583 // We trust that the compiler did the right thing and marked runtime support
1584 // values as artificial.
1585 if (!GetVariable() || !GetVariable()->IsArtificial())
1586 return false;
1587
1588 if (auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage()))
1589 if (runtime->IsAllowedRuntimeValue(GetName()))
1590 return false;
1591
1592 return true;
1593}
1594
1595bool ValueObject::IsNilReference() {
1596 if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {
1597 return language->IsNilReference(*this);
1598 }
1599 return false;
1600}
1601
1602bool ValueObject::IsUninitializedReference() {
1603 if (Language *language = Language::FindPlugin(GetObjectRuntimeLanguage())) {
1604 return language->IsUninitializedReference(*this);
1605 }
1606 return false;
1607}
1608
1609// This allows you to create an array member using and index that doesn't not
1610// fall in the normal bounds of the array. Many times structure can be defined
1611// as: struct Collection {
1612// uint32_t item_count;
1613// Item item_array[0];
1614// };
1615// The size of the "item_array" is 1, but many times in practice there are more
1616// items in "item_array".
1617
1618ValueObjectSP ValueObject::GetSyntheticArrayMember(size_t index,
1619 bool can_create) {
1620 ValueObjectSP synthetic_child_sp;
1621 if (IsPointerType() || IsArrayType()) {
1622 std::string index_str = llvm::formatv("[{0}]", index);
1623 ConstString index_const_str(index_str);
1624 // Check if we have already created a synthetic array member in this valid
1625 // object. If we have we will re-use it.
1626 synthetic_child_sp = GetSyntheticChild(index_const_str);
1627 if (!synthetic_child_sp) {
1628 ValueObject *synthetic_child;
1629 // We haven't made a synthetic array member for INDEX yet, so lets make
1630 // one and cache it for any future reference.
1631 synthetic_child = CreateChildAtIndex(0, true, index);
1632
1633 // Cache the value if we got one back...
1634 if (synthetic_child) {
1635 AddSyntheticChild(index_const_str, synthetic_child);
1636 synthetic_child_sp = synthetic_child->GetSP();
1637 synthetic_child_sp->SetName(ConstString(index_str));
1638 synthetic_child_sp->m_flags.m_is_array_item_for_pointer = true;
1639 }
1640 }
1641 }
1642 return synthetic_child_sp;
1643}
1644
1645ValueObjectSP ValueObject::GetSyntheticBitFieldChild(uint32_t from, uint32_t to,
1646 bool can_create) {
1647 ValueObjectSP synthetic_child_sp;
1648 if (IsScalarType()) {
1649 std::string index_str = llvm::formatv("[{0}-{1}]", from, to);
1650 ConstString index_const_str(index_str);
1651 // Check if we have already created a synthetic array member in this valid
1652 // object. If we have we will re-use it.
1653 synthetic_child_sp = GetSyntheticChild(index_const_str);
1654 if (!synthetic_child_sp) {
1655 uint32_t bit_field_size = to - from + 1;
1656 uint32_t bit_field_offset = from;
1657 if (GetDataExtractor().GetByteOrder() == eByteOrderBig)
1658 bit_field_offset =
1659 GetByteSize().value_or(0) * 8 - bit_field_size - bit_field_offset;
1660 // We haven't made a synthetic array member for INDEX yet, so lets make
1661 // one and cache it for any future reference.
1662 ValueObjectChild *synthetic_child = new ValueObjectChild(
1663 *this, GetCompilerType(), index_const_str, GetByteSize().value_or(0),
1664 0, bit_field_size, bit_field_offset, false, false,
1665 eAddressTypeInvalid, 0);
1666
1667 // Cache the value if we got one back...
1668 if (synthetic_child) {
1669 AddSyntheticChild(index_const_str, synthetic_child);
1670 synthetic_child_sp = synthetic_child->GetSP();
1671 synthetic_child_sp->SetName(ConstString(index_str));
1672 synthetic_child_sp->m_flags.m_is_bitfield_for_scalar = true;
1673 }
1674 }
1675 }
1676 return synthetic_child_sp;
1677}
1678
1679ValueObjectSP ValueObject::GetSyntheticChildAtOffset(
1680 uint32_t offset, const CompilerType &type, bool can_create,
1681 ConstString name_const_str) {
1682
1683 ValueObjectSP synthetic_child_sp;
1684
1685 if (name_const_str.IsEmpty()) {
1686 name_const_str.SetString("@" + std::to_string(offset));
1687 }
1688
1689 // Check if we have already created a synthetic array member in this valid
1690 // object. If we have we will re-use it.
1691 synthetic_child_sp = GetSyntheticChild(name_const_str);
1692
1693 if (synthetic_child_sp.get())
1694 return synthetic_child_sp;
1695
1696 if (!can_create)
1697 return {};
1698
1699 ExecutionContext exe_ctx(GetExecutionContextRef());
1700 llvm::Optional<uint64_t> size =
1701 type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
1702 if (!size)
1703 return {};
1704 ValueObjectChild *synthetic_child =
1705 new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
1706 false, false, eAddressTypeInvalid, 0);
1707 if (synthetic_child) {
1708 AddSyntheticChild(name_const_str, synthetic_child);
1709 synthetic_child_sp = synthetic_child->GetSP();
1710 synthetic_child_sp->SetName(name_const_str);
1711 synthetic_child_sp->m_flags.m_is_child_at_offset = true;
1712 }
1713 return synthetic_child_sp;
1714}
1715
1716ValueObjectSP ValueObject::GetSyntheticBase(uint32_t offset,
1717 const CompilerType &type,
1718 bool can_create,
1719 ConstString name_const_str) {
1720 ValueObjectSP synthetic_child_sp;
1721
1722 if (name_const_str.IsEmpty()) {
1723 char name_str[128];
1724 snprintf(name_str, sizeof(name_str), "base%s@%i",
1725 type.GetTypeName().AsCString("<unknown>"), offset);
1726 name_const_str.SetCString(name_str);
1727 }
1728
1729 // Check if we have already created a synthetic array member in this valid
1730 // object. If we have we will re-use it.
1731 synthetic_child_sp = GetSyntheticChild(name_const_str);
1732
1733 if (synthetic_child_sp.get())
1734 return synthetic_child_sp;
1735
1736 if (!can_create)
1737 return {};
1738
1739 const bool is_base_class = true;
1740
1741 ExecutionContext exe_ctx(GetExecutionContextRef());
1742 llvm::Optional<uint64_t> size =
1743 type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
1744 if (!size)
1745 return {};
1746 ValueObjectChild *synthetic_child =
1747 new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
1748 is_base_class, false, eAddressTypeInvalid, 0);
1749 if (synthetic_child) {
1750 AddSyntheticChild(name_const_str, synthetic_child);
1751 synthetic_child_sp = synthetic_child->GetSP();
1752 synthetic_child_sp->SetName(name_const_str);
1753 }
1754 return synthetic_child_sp;
1755}
1756
1757// your expression path needs to have a leading . or -> (unless it somehow
1758// "looks like" an array, in which case it has a leading [ symbol). while the [
1759// is meaningful and should be shown to the user, . and -> are just parser
1760// design, but by no means added information for the user.. strip them off
1761static const char *SkipLeadingExpressionPathSeparators(const char *expression) {
1762 if (!expression || !expression[0])
1763 return expression;
1764 if (expression[0] == '.')
1765 return expression + 1;
1766 if (expression[0] == '-' && expression[1] == '>')
1767 return expression + 2;
1768 return expression;
1769}
1770
1771ValueObjectSP
1772ValueObject::GetSyntheticExpressionPathChild(const char *expression,
1773 bool can_create) {
1774 ValueObjectSP synthetic_child_sp;
1775 ConstString name_const_string(expression);
1776 // Check if we have already created a synthetic array member in this valid
1777 // object. If we have we will re-use it.
1778 synthetic_child_sp = GetSyntheticChild(name_const_string);
1779 if (!synthetic_child_sp) {
1780 // We haven't made a synthetic array member for expression yet, so lets
1781 // make one and cache it for any future reference.
1782 synthetic_child_sp = GetValueForExpressionPath(
1783 expression, nullptr, nullptr,
1784 GetValueForExpressionPathOptions().SetSyntheticChildrenTraversal(
1785 GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
1786 None));
1787
1788 // Cache the value if we got one back...
1789 if (synthetic_child_sp.get()) {
1790 // FIXME: this causes a "real" child to end up with its name changed to
1791 // the contents of expression
1792 AddSyntheticChild(name_const_string, synthetic_child_sp.get());
1793 synthetic_child_sp->SetName(
1794 ConstString(SkipLeadingExpressionPathSeparators(expression)));
1795 }
1796 }
1797 return synthetic_child_sp;
1798}
1799
1800void ValueObject::CalculateSyntheticValue() {
1801 TargetSP target_sp(GetTargetSP());
1802 if (target_sp && !target_sp->GetEnableSyntheticValue()) {
1803 m_synthetic_value = nullptr;
1804 return;
1805 }
1806
1807 lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
1808
1809 if (!UpdateFormatsIfNeeded() && m_synthetic_value)
1810 return;
1811
1812 if (m_synthetic_children_sp.get() == nullptr)
1813 return;
1814
1815 if (current_synth_sp == m_synthetic_children_sp && m_synthetic_value)
1816 return;
1817
1818 m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp);
1819}
1820
1821void ValueObject::CalculateDynamicValue(DynamicValueType use_dynamic) {
1822 if (use_dynamic == eNoDynamicValues)
1823 return;
1824
1825 if (!m_dynamic_value && !IsDynamic()) {
1826 ExecutionContext exe_ctx(GetExecutionContextRef());
1827 Process *process = exe_ctx.GetProcessPtr();
1828 if (process && process->IsPossibleDynamicValue(*this)) {
1829 ClearDynamicTypeInformation();
1830 m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
1831 }
1832 }
1833}
1834
1835ValueObjectSP ValueObject::GetDynamicValue(DynamicValueType use_dynamic) {
1836 if (use_dynamic == eNoDynamicValues)
1837 return ValueObjectSP();
1838
1839 if (!IsDynamic() && m_dynamic_value == nullptr) {
1840 CalculateDynamicValue(use_dynamic);
1841 }
1842 if (m_dynamic_value)
1843 return m_dynamic_value->GetSP();
1844 else
1845 return ValueObjectSP();
1846}
1847
1848ValueObjectSP ValueObject::GetSyntheticValue() {
1849 CalculateSyntheticValue();
1850
1851 if (m_synthetic_value)
1852 return m_synthetic_value->GetSP();
1853 else
1854 return ValueObjectSP();
1855}
1856
1857bool ValueObject::HasSyntheticValue() {
1858 UpdateFormatsIfNeeded();
1859
1860 if (m_synthetic_children_sp.get() == nullptr)
1861 return false;
1862
1863 CalculateSyntheticValue();
1864
1865 return m_synthetic_value != nullptr;
1866}
1867
1868ValueObject *ValueObject::GetNonBaseClassParent() {
1869 if (GetParent()) {
1870 if (GetParent()->IsBaseClass())
1871 return GetParent()->GetNonBaseClassParent();
1872 else
1873 return GetParent();
1874 }
1875 return nullptr;
1876}
1877
1878bool ValueObject::IsBaseClass(uint32_t &depth) {
1879 if (!IsBaseClass()) {
1880 depth = 0;
1881 return false;
1882 }
1883 if (GetParent()) {
1884 GetParent()->IsBaseClass(depth);
1885 depth = depth + 1;
1886 return true;
1887 }
1888 // TODO: a base of no parent? weird..
1889 depth = 1;
1890 return true;
1891}
1892
1893void ValueObject::GetExpressionPath(Stream &s,
1894 GetExpressionPathFormat epformat) {
1895 // synthetic children do not actually "exist" as part of the hierarchy, and
1896 // sometimes they are consed up in ways that don't make sense from an
1897 // underlying language/API standpoint. So, use a special code path here to
1898 // return something that can hopefully be used in expression
1899 if (m_flags.m_is_synthetic_children_generated) {
1900 UpdateValueIfNeeded();
1901
1902 if (m_value.GetValueType() == Value::ValueType::LoadAddress) {
1903 if (IsPointerOrReferenceType()) {
1904 s.Printf("((%s)0x%" PRIx64 ")", GetTypeName().AsCString("void"),
1905 GetValueAsUnsigned(0));
1906 return;
1907 } else {
1908 uint64_t load_addr =
1909 m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1910 if (load_addr != LLDB_INVALID_ADDRESS) {
1911 s.Printf("(*( (%s *)0x%" PRIx64 "))", GetTypeName().AsCString("void"),
1912 load_addr);
1913 return;
1914 }
1915 }
1916 }
1917
1918 if (CanProvideValue()) {
1919 s.Printf("((%s)%s)", GetTypeName().AsCString("void"),
1920 GetValueAsCString());
1921 return;
1922 }
1923
1924 return;
1925 }
1926
1927 const bool is_deref_of_parent = IsDereferenceOfParent();
1928
1929 if (is_deref_of_parent &&
1930 epformat == eGetExpressionPathFormatDereferencePointers) {
1931 // this is the original format of GetExpressionPath() producing code like
1932 // *(a_ptr).memberName, which is entirely fine, until you put this into
1933 // StackFrame::GetValueForVariableExpressionPath() which prefers to see
1934 // a_ptr->memberName. the eHonorPointers mode is meant to produce strings
1935 // in this latter format
1936 s.PutCString("*(");
1937 }
1938
1939 ValueObject *parent = GetParent();
1940
1941 if (parent)
1942 parent->GetExpressionPath(s, epformat);
1943
1944 // if we are a deref_of_parent just because we are synthetic array members
1945 // made up to allow ptr[%d] syntax to work in variable printing, then add our
1946 // name ([%d]) to the expression path
1947 if (m_flags.m_is_array_item_for_pointer &&
1948 epformat == eGetExpressionPathFormatHonorPointers)
1949 s.PutCString(m_name.GetStringRef());
1950
1951 if (!IsBaseClass()) {
1952 if (!is_deref_of_parent) {
1953 ValueObject *non_base_class_parent = GetNonBaseClassParent();
1954 if (non_base_class_parent &&
1955 !non_base_class_parent->GetName().IsEmpty()) {
1956 CompilerType non_base_class_parent_compiler_type =
1957 non_base_class_parent->GetCompilerType();
1958 if (non_base_class_parent_compiler_type) {
1959 if (parent && parent->IsDereferenceOfParent() &&
1960 epformat == eGetExpressionPathFormatHonorPointers) {
1961 s.PutCString("->");
1962 } else {
1963 const uint32_t non_base_class_parent_type_info =
1964 non_base_class_parent_compiler_type.GetTypeInfo();
1965
1966 if (non_base_class_parent_type_info & eTypeIsPointer) {
1967 s.PutCString("->");
1968 } else if ((non_base_class_parent_type_info & eTypeHasChildren) &&
1969 !(non_base_class_parent_type_info & eTypeIsArray)) {
1970 s.PutChar('.');
1971 }
1972 }
1973 }
1974 }
1975
1976 const char *name = GetName().GetCString();
1977 if (name)
1978 s.PutCString(name);
1979 }
1980 }
1981
1982 if (is_deref_of_parent &&
1983 epformat == eGetExpressionPathFormatDereferencePointers) {
1984 s.PutChar(')');
1985 }
1986}
1987
1988ValueObjectSP ValueObject::GetValueForExpressionPath(
1989 llvm::StringRef expression, ExpressionPathScanEndReason *reason_to_stop,
1990 ExpressionPathEndResultType *final_value_type,
1991 const GetValueForExpressionPathOptions &options,
1992 ExpressionPathAftermath *final_task_on_target) {
1993
1994 ExpressionPathScanEndReason dummy_reason_to_stop =
1995 ValueObject::eExpressionPathScanEndReasonUnknown;
1996 ExpressionPathEndResultType dummy_final_value_type =
1997 ValueObject::eExpressionPathEndResultTypeInvalid;
1998 ExpressionPathAftermath dummy_final_task_on_target =
1999 ValueObject::eExpressionPathAftermathNothing;
2000
2001 ValueObjectSP ret_val = GetValueForExpressionPath_Impl(
2002 expression, reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2003 final_value_type ? final_value_type : &dummy_final_value_type, options,
2004 final_task_on_target ? final_task_on_target
2005 : &dummy_final_task_on_target);
2006
2007 if (!final_task_on_target ||
2008 *final_task_on_target == ValueObject::eExpressionPathAftermathNothing)
2009 return ret_val;
2010
2011 if (ret_val.get() &&
2012 ((final_value_type ? *final_value_type : dummy_final_value_type) ==
2013 eExpressionPathEndResultTypePlain)) // I can only deref and takeaddress
2014 // of plain objects
2015 {
2016 if ((final_task_on_target ? *final_task_on_target
2017 : dummy_final_task_on_target) ==
2018 ValueObject::eExpressionPathAftermathDereference) {
2019 Status error;
2020 ValueObjectSP final_value = ret_val->Dereference(error);
2021 if (error.Fail() || !final_value.get()) {
2022 if (reason_to_stop)
2023 *reason_to_stop =
2024 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2025 if (final_value_type)
2026 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2027 return ValueObjectSP();
2028 } else {
2029 if (final_task_on_target)
2030 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2031 return final_value;
2032 }
2033 }
2034 if (*final_task_on_target ==
2035 ValueObject::eExpressionPathAftermathTakeAddress) {
2036 Status error;
2037 ValueObjectSP final_value = ret_val->AddressOf(error);
2038 if (error.Fail() || !final_value.get()) {
2039 if (reason_to_stop)
2040 *reason_to_stop =
2041 ValueObject::eExpressionPathScanEndReasonTakingAddressFailed;
2042 if (final_value_type)
2043 *final_value_type = ValueObject::eExpressionPathEndResultTypeInvalid;
2044 return ValueObjectSP();
2045 } else {
2046 if (final_task_on_target)
2047 *final_task_on_target = ValueObject::eExpressionPathAftermathNothing;
2048 return final_value;
2049 }
2050 }
2051 }
2052 return ret_val; // final_task_on_target will still have its original value, so
2053 // you know I did not do it
2054}
2055
2056ValueObjectSP ValueObject::GetValueForExpressionPath_Impl(
2057 llvm::StringRef expression, ExpressionPathScanEndReason *reason_to_stop,
2058 ExpressionPathEndResultType *final_result,
2059 const GetValueForExpressionPathOptions &options,
2060 ExpressionPathAftermath *what_next) {
2061 ValueObjectSP root = GetSP();
2062
2063 if (!root)
2064 return nullptr;
2065
2066 llvm::StringRef remainder = expression;
2067
2068 while (true) {
2069 llvm::StringRef temp_expression = remainder;
2070
2071 CompilerType root_compiler_type = root->GetCompilerType();
2072 CompilerType pointee_compiler_type;
2073 Flags pointee_compiler_type_info;
2074
2075 Flags root_compiler_type_info(
2076 root_compiler_type.GetTypeInfo(&pointee_compiler_type));
2077 if (pointee_compiler_type)
2078 pointee_compiler_type_info.Reset(pointee_compiler_type.GetTypeInfo());
2079
2080 if (temp_expression.empty()) {
2081 *reason_to_stop = ValueObject::eExpressionPathScanEndReasonEndOfString;
2082 return root;
2083 }
2084
2085 switch (temp_expression.front()) {
2086 case '-': {
2087 temp_expression = temp_expression.drop_front();
2088 if (options.m_check_dot_vs_arrow_syntax &&
2089 root_compiler_type_info.Test(eTypeIsPointer)) // if you are trying to
2090 // use -> on a
2091 // non-pointer and I
2092 // must catch the error
2093 {
2094 *reason_to_stop =
2095 ValueObject::eExpressionPathScanEndReasonArrowInsteadOfDot;
2096 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2097 return ValueObjectSP();
2098 }
2099 if (root_compiler_type_info.Test(eTypeIsObjC) && // if yo are trying to
2100 // extract an ObjC IVar
2101 // when this is forbidden
2102 root_compiler_type_info.Test(eTypeIsPointer) &&
2103 options.m_no_fragile_ivar) {
2104 *reason_to_stop =
2105 ValueObject::eExpressionPathScanEndReasonFragileIVarNotAllowed;
2106 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2107 return ValueObjectSP();
2108 }
2109 if (!temp_expression.startswith(">")) {
2110 *reason_to_stop =
2111 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2112 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2113 return ValueObjectSP();
2114 }
2115 }
2116 [[fallthrough]];
2117 case '.': // or fallthrough from ->
2118 {
2119 if (options.m_check_dot_vs_arrow_syntax &&
2120 temp_expression.front() == '.' &&
2121 root_compiler_type_info.Test(eTypeIsPointer)) // if you are trying to
2122 // use . on a pointer
2123 // and I must catch the
2124 // error
2125 {
2126 *reason_to_stop =
2127 ValueObject::eExpressionPathScanEndReasonDotInsteadOfArrow;
2128 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2129 return nullptr;
2130 }
2131 temp_expression = temp_expression.drop_front(); // skip . or >
2132
2133 size_t next_sep_pos = temp_expression.find_first_of("-.[", 1);
2134 ConstString child_name;
2135 if (next_sep_pos == llvm::StringRef::npos) // if no other separator just
2136 // expand this last layer
2137 {
2138 child_name.SetString(temp_expression);
2139 ValueObjectSP child_valobj_sp =
2140 root->GetChildMemberWithName(child_name, true);
2141
2142 if (child_valobj_sp.get()) // we know we are done, so just return
2143 {
2144 *reason_to_stop =
2145 ValueObject::eExpressionPathScanEndReasonEndOfString;
2146 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2147 return child_valobj_sp;
2148 } else {
2149 switch (options.m_synthetic_children_traversal) {
2150 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2151 None:
2152 break;
2153 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2154 FromSynthetic:
2155 if (root->IsSynthetic()) {
2156 child_valobj_sp = root->GetNonSyntheticValue();
2157 if (child_valobj_sp.get())
2158 child_valobj_sp =
2159 child_valobj_sp->GetChildMemberWithName(child_name, true);
2160 }
2161 break;
2162 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2163 ToSynthetic:
2164 if (!root->IsSynthetic()) {
2165 child_valobj_sp = root->GetSyntheticValue();
2166 if (child_valobj_sp.get())
2167 child_valobj_sp =
2168 child_valobj_sp->GetChildMemberWithName(child_name, true);
2169 }
2170 break;
2171 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2172 Both:
2173 if (root->IsSynthetic()) {
2174 child_valobj_sp = root->GetNonSyntheticValue();
2175 if (child_valobj_sp.get())
2176 child_valobj_sp =
2177 child_valobj_sp->GetChildMemberWithName(child_name, true);
2178 } else {
2179 child_valobj_sp = root->GetSyntheticValue();
2180 if (child_valobj_sp.get())
2181 child_valobj_sp =
2182 child_valobj_sp->GetChildMemberWithName(child_name, true);
2183 }
2184 break;
2185 }
2186 }
2187
2188 // if we are here and options.m_no_synthetic_children is true,
2189 // child_valobj_sp is going to be a NULL SP, so we hit the "else"
2190 // branch, and return an error
2191 if (child_valobj_sp.get()) // if it worked, just return
2192 {
2193 *reason_to_stop =
2194 ValueObject::eExpressionPathScanEndReasonEndOfString;
2195 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2196 return child_valobj_sp;
2197 } else {
2198 *reason_to_stop =
2199 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2200 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2201 return nullptr;
2202 }
2203 } else // other layers do expand
2204 {
2205 llvm::StringRef next_separator = temp_expression.substr(next_sep_pos);
2206
2207 child_name.SetString(temp_expression.slice(0, next_sep_pos));
2208
2209 ValueObjectSP child_valobj_sp =
2210 root->GetChildMemberWithName(child_name, true);
2211 if (child_valobj_sp.get()) // store the new root and move on
2212 {
2213 root = child_valobj_sp;
2214 remainder = next_separator;
2215 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2216 continue;
2217 } else {
2218 switch (options.m_synthetic_children_traversal) {
2219 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2220 None:
2221 break;
2222 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2223 FromSynthetic:
2224 if (root->IsSynthetic()) {
2225 child_valobj_sp = root->GetNonSyntheticValue();
2226 if (child_valobj_sp.get())
2227 child_valobj_sp =
2228 child_valobj_sp->GetChildMemberWithName(child_name, true);
2229 }
2230 break;
2231 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2232 ToSynthetic:
2233 if (!root->IsSynthetic()) {
2234 child_valobj_sp = root->GetSyntheticValue();
2235 if (child_valobj_sp.get())
2236 child_valobj_sp =
2237 child_valobj_sp->GetChildMemberWithName(child_name, true);
2238 }
2239 break;
2240 case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2241 Both:
2242 if (root->IsSynthetic()) {
2243 child_valobj_sp = root->GetNonSyntheticValue();
2244 if (child_valobj_sp.get())
2245 child_valobj_sp =
2246 child_valobj_sp->GetChildMemberWithName(child_name, true);
2247 } else {
2248 child_valobj_sp = root->GetSyntheticValue();
2249 if (child_valobj_sp.get())
2250 child_valobj_sp =
2251 child_valobj_sp->GetChildMemberWithName(child_name, true);
2252 }
2253 break;
2254 }
2255 }
2256
2257 // if we are here and options.m_no_synthetic_children is true,
2258 // child_valobj_sp is going to be a NULL SP, so we hit the "else"
2259 // branch, and return an error
2260 if (child_valobj_sp.get()) // if it worked, move on
2261 {
2262 root = child_valobj_sp;
2263 remainder = next_separator;
2264 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2265 continue;
2266 } else {
2267 *reason_to_stop =
2268 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2269 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2270 return nullptr;
2271 }
2272 }
2273 break;
2274 }
2275 case '[': {
2276 if (!root_compiler_type_info.Test(eTypeIsArray) &&
2277 !root_compiler_type_info.Test(eTypeIsPointer) &&
2278 !root_compiler_type_info.Test(
2279 eTypeIsVector)) // if this is not a T[] nor a T*
2280 {
2281 if (!root_compiler_type_info.Test(
2282 eTypeIsScalar)) // if this is not even a scalar...
2283 {
2284 if (options.m_synthetic_children_traversal ==
2285 GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
2286 None) // ...only chance left is synthetic
2287 {
2288 *reason_to_stop =
2289 ValueObject::eExpressionPathScanEndReasonRangeOperatorInvalid;
2290 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2291 return ValueObjectSP();
2292 }
2293 } else if (!options.m_allow_bitfields_syntax) // if this is a scalar,
2294 // check that we can
2295 // expand bitfields
2296 {
2297 *reason_to_stop =
2298 ValueObject::eExpressionPathScanEndReasonRangeOperatorNotAllowed;
2299 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2300 return ValueObjectSP();
2301 }
2302 }
2303 if (temp_expression[1] ==
2304 ']') // if this is an unbounded range it only works for arrays
2305 {
2306 if (!root_compiler_type_info.Test(eTypeIsArray)) {
2307 *reason_to_stop =
2308 ValueObject::eExpressionPathScanEndReasonEmptyRangeNotAllowed;
2309 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2310 return nullptr;
2311 } else // even if something follows, we cannot expand unbounded ranges,
2312 // just let the caller do it
2313 {
2314 *reason_to_stop =
2315 ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2316 *final_result =
2317 ValueObject::eExpressionPathEndResultTypeUnboundedRange;
2318 return root;
2319 }
2320 }
2321
2322 size_t close_bracket_position = temp_expression.find(']', 1);
2323 if (close_bracket_position ==
2324 llvm::StringRef::npos) // if there is no ], this is a syntax error
2325 {
2326 *reason_to_stop =
2327 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2328 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2329 return nullptr;
2330 }
2331
2332 llvm::StringRef bracket_expr =
2333 temp_expression.slice(1, close_bracket_position);
2334
2335 // If this was an empty expression it would have been caught by the if
2336 // above.
2337 assert(!bracket_expr.empty());
2338
2339 if (!bracket_expr.contains('-')) {
2340 // if no separator, this is of the form [N]. Note that this cannot be
2341 // an unbounded range of the form [], because that case was handled
2342 // above with an unconditional return.
2343 unsigned long index = 0;
2344 if (bracket_expr.getAsInteger(0, index)) {
2345 *reason_to_stop =
2346 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2347 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2348 return nullptr;
2349 }
2350
2351 // from here on we do have a valid index
2352 if (root_compiler_type_info.Test(eTypeIsArray)) {
2353 ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
2354 if (!child_valobj_sp)
2355 child_valobj_sp = root->GetSyntheticArrayMember(index, true);
2356 if (!child_valobj_sp)
2357 if (root->HasSyntheticValue() &&
2358 root->GetSyntheticValue()->GetNumChildren() > index)
2359 child_valobj_sp =
2360 root->GetSyntheticValue()->GetChildAtIndex(index, true);
2361 if (child_valobj_sp) {
2362 root = child_valobj_sp;
2363 remainder =
2364 temp_expression.substr(close_bracket_position + 1); // skip ]
2365 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2366 continue;
2367 } else {
2368 *reason_to_stop =
2369 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2370 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2371 return nullptr;
2372 }
2373 } else if (root_compiler_type_info.Test(eTypeIsPointer)) {
2374 if (*what_next ==
2375 ValueObject::
2376 eExpressionPathAftermathDereference && // if this is a
2377 // ptr-to-scalar, I
2378 // am accessing it
2379 // by index and I
2380 // would have
2381 // deref'ed anyway,
2382 // then do it now
2383 // and use this as
2384 // a bitfield
2385 pointee_compiler_type_info.Test(eTypeIsScalar)) {
2386 Status error;
2387 root = root->Dereference(error);
2388 if (error.Fail() || !root) {
2389 *reason_to_stop =
2390 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2391 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2392 return nullptr;
2393 } else {
2394 *what_next = eExpressionPathAftermathNothing;
2395 continue;
2396 }
2397 } else {
2398 if (root->GetCompilerType().GetMinimumLanguage() ==
2399 eLanguageTypeObjC &&
2400 pointee_compiler_type_info.AllClear(eTypeIsPointer) &&
2401 root->HasSyntheticValue() &&
2402 (options.m_synthetic_children_traversal ==
2403 GetValueForExpressionPathOptions::
2404 SyntheticChildrenTraversal::ToSynthetic ||
2405 options.m_synthetic_children_traversal ==
2406 GetValueForExpressionPathOptions::
2407 SyntheticChildrenTraversal::Both)) {
2408 root = root->GetSyntheticValue()->GetChildAtIndex(index, true);
2409 } else
2410 root = root->GetSyntheticArrayMember(index, true);
2411 if (!root) {
2412 *reason_to_stop =
2413 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2414 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2415 return nullptr;
2416 } else {
2417 remainder =
2418 temp_expression.substr(close_bracket_position + 1); // skip ]
2419 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2420 continue;
2421 }
2422 }
2423 } else if (root_compiler_type_info.Test(eTypeIsScalar)) {
2424 root = root->GetSyntheticBitFieldChild(index, index, true);
2425 if (!root) {
2426 *reason_to_stop =
2427 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2428 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2429 return nullptr;
2430 } else // we do not know how to expand members of bitfields, so we
2431 // just return and let the caller do any further processing
2432 {
2433 *reason_to_stop = ValueObject::
2434 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
2435 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
2436 return root;
2437 }
2438 } else if (root_compiler_type_info.Test(eTypeIsVector)) {
2439 root = root->GetChildAtIndex(index, true);
2440 if (!root) {
2441 *reason_to_stop =
2442 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2443 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2444 return ValueObjectSP();
2445 } else {
2446 remainder =
2447 temp_expression.substr(close_bracket_position + 1); // skip ]
2448 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2449 continue;
2450 }
2451 } else if (options.m_synthetic_children_traversal ==
2452 GetValueForExpressionPathOptions::
2453 SyntheticChildrenTraversal::ToSynthetic ||
2454 options.m_synthetic_children_traversal ==
2455 GetValueForExpressionPathOptions::
2456 SyntheticChildrenTraversal::Both) {
2457 if (root->HasSyntheticValue())
2458 root = root->GetSyntheticValue();
2459 else if (!root->IsSynthetic()) {
2460 *reason_to_stop =
2461 ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2462 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2463 return nullptr;
2464 }
2465 // if we are here, then root itself is a synthetic VO.. should be
2466 // good to go
2467
2468 if (!root) {
2469 *reason_to_stop =
2470 ValueObject::eExpressionPathScanEndReasonSyntheticValueMissing;
2471 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2472 return nullptr;
2473 }
2474 root = root->GetChildAtIndex(index, true);
2475 if (!root) {
2476 *reason_to_stop =
2477 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2478 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2479 return nullptr;
2480 } else {
2481 remainder =
2482 temp_expression.substr(close_bracket_position + 1); // skip ]
2483 *final_result = ValueObject::eExpressionPathEndResultTypePlain;
2484 continue;
2485 }
2486 } else {
2487 *reason_to_stop =
2488 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2489 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2490 return nullptr;
2491 }
2492 } else {
2493 // we have a low and a high index
2494 llvm::StringRef sleft, sright;
2495 unsigned long low_index, high_index;
2496 std::tie(sleft, sright) = bracket_expr.split('-');
2497 if (sleft.getAsInteger(0, low_index) ||
2498 sright.getAsInteger(0, high_index)) {
2499 *reason_to_stop =
2500 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2501 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2502 return nullptr;
2503 }
2504
2505 if (low_index > high_index) // swap indices if required
2506 std::swap(low_index, high_index);
2507
2508 if (root_compiler_type_info.Test(
2509 eTypeIsScalar)) // expansion only works for scalars
2510 {
2511 root = root->GetSyntheticBitFieldChild(low_index, high_index, true);
2512 if (!root) {
2513 *reason_to_stop =
2514 ValueObject::eExpressionPathScanEndReasonNoSuchChild;
2515 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2516 return nullptr;
2517 } else {
2518 *reason_to_stop = ValueObject::
2519 eExpressionPathScanEndReasonBitfieldRangeOperatorMet;
2520 *final_result = ValueObject::eExpressionPathEndResultTypeBitfield;
2521 return root;
2522 }
2523 } else if (root_compiler_type_info.Test(
2524 eTypeIsPointer) && // if this is a ptr-to-scalar, I am
2525 // accessing it by index and I would
2526 // have deref'ed anyway, then do it
2527 // now and use this as a bitfield
2528 *what_next ==
2529 ValueObject::eExpressionPathAftermathDereference &&
2530 pointee_compiler_type_info.Test(eTypeIsScalar)) {
2531 Status error;
2532 root = root->Dereference(error);
2533 if (error.Fail() || !root) {
2534 *reason_to_stop =
2535 ValueObject::eExpressionPathScanEndReasonDereferencingFailed;
2536 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2537 return nullptr;
2538 } else {
2539 *what_next = ValueObject::eExpressionPathAftermathNothing;
2540 continue;
2541 }
2542 } else {
2543 *reason_to_stop =
2544 ValueObject::eExpressionPathScanEndReasonArrayRangeOperatorMet;
2545 *final_result = ValueObject::eExpressionPathEndResultTypeBoundedRange;
2546 return root;
2547 }
2548 }
2549 break;
2550 }
2551 default: // some non-separator is in the way
2552 {
2553 *reason_to_stop =
2554 ValueObject::eExpressionPathScanEndReasonUnexpectedSymbol;
2555 *final_result = ValueObject::eExpressionPathEndResultTypeInvalid;
2556 return nullptr;
2557 }
2558 }
2559 }
2560}
2561
2562void ValueObject::Dump(Stream &s) { Dump(s, DumpValueObjectOptions(*this)); }
2563
2564void ValueObject::Dump(Stream &s, const DumpValueObjectOptions &options) {
2565 ValueObjectPrinter printer(this, &s, options);
2566 printer.PrintValueObject();
2567}
2568
2569ValueObjectSP ValueObject::CreateConstantValue(ConstString name) {
2570 ValueObjectSP valobj_sp;
2571
2572 if (UpdateValueIfNeeded(false) && m_error.Success()) {
2573 ExecutionContext exe_ctx(GetExecutionContextRef());
2574
2575 DataExtractor data;
2576 data.SetByteOrder(m_data.GetByteOrder());
2577 data.SetAddressByteSize(m_data.GetAddressByteSize());
2578
2579 if (IsBitfield()) {
2580 Value v(Scalar(GetValueAsUnsigned(UINT64_MAX)));
2581 m_error = v.GetValueAsData(&exe_ctx, data, GetModule().get());
2582 } else
2583 m_error = m_value.GetValueAsData(&exe_ctx, data, GetModule().get());
2584
2585 valobj_sp = ValueObjectConstResult::Create(
2586 exe_ctx.GetBestExecutionContextScope(), GetCompilerType(), name, data,
2587 GetAddressOf());
2588 }
2589
2590 if (!valobj_sp) {
2591 ExecutionContext exe_ctx(GetExecutionContextRef());
2592 valobj_sp = ValueObjectConstResult::Create(
2593 exe_ctx.GetBestExecutionContextScope(), m_error);
2594 }
2595 return valobj_sp;
2596}
2597
2598ValueObjectSP ValueObject::GetQualifiedRepresentationIfAvailable(
2599 lldb::DynamicValueType dynValue, bool synthValue) {
2600 ValueObjectSP result_sp(GetSP());
2601
2602 switch (dynValue) {
2603 case lldb::eDynamicCanRunTarget:
2604 case lldb::eDynamicDontRunTarget: {
2605 if (!result_sp->IsDynamic()) {
2606 if (result_sp->GetDynamicValue(dynValue))
2607 result_sp = result_sp->GetDynamicValue(dynValue);
2608 }
2609 } break;
2610 case lldb::eNoDynamicValues: {
2611 if (result_sp->IsDynamic()) {
2612 if (result_sp->GetStaticValue())
2613 result_sp = result_sp->GetStaticValue();
2614 }
2615 } break;
2616 }
2617
2618 if (synthValue) {
2619 if (!result_sp->IsSynthetic()) {
2620 if (result_sp->GetSyntheticValue())
2621 result_sp = result_sp->GetSyntheticValue();
2622 }
2623 } else {
2624 if (result_sp->IsSynthetic()) {
2625 if (result_sp->GetNonSyntheticValue())
2626 result_sp = result_sp->GetNonSyntheticValue();
2627 }
2628 }
2629
2630 return result_sp;
2631}
2632
2633ValueObjectSP ValueObject::Dereference(Status &error) {
2634 if (m_deref_valobj)
2635 return m_deref_valobj->GetSP();
2636
2637 const bool is_pointer_or_reference_type = IsPointerOrReferenceType();
2638 if (is_pointer_or_reference_type) {
2639 bool omit_empty_base_classes = true;
2640 bool ignore_array_bounds = false;
2641
2642 std::string child_name_str;
2643 uint32_t child_byte_size = 0;
2644 int32_t child_byte_offset = 0;
2645 uint32_t child_bitfield_bit_size = 0;
2646 uint32_t child_bitfield_bit_offset = 0;
2647 bool child_is_base_class = false;
2648 bool child_is_deref_of_parent = false;
2649 const bool transparent_pointers = false;
2650 CompilerType compiler_type = GetCompilerType();
2651 CompilerType child_compiler_type;
2652 uint64_t language_flags = 0;
2653
2654 ExecutionContext exe_ctx(GetExecutionContextRef());
2655
2656 child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex(
2657 &exe_ctx, 0, transparent_pointers, omit_empty_base_classes,
2658 ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
2659 child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
2660 child_is_deref_of_parent, this, language_flags);
2661 if (child_compiler_type && child_byte_size) {
2662 ConstString child_name;
2663 if (!child_name_str.empty())
2664 child_name.SetCString(child_name_str.c_str());
2665
2666 m_deref_valobj = new ValueObjectChild(
2667 *this, child_compiler_type, child_name, child_byte_size,
2668 child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
2669 child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
2670 language_flags);
2671 }
2672
2673 // In case of incomplete child compiler type, use the pointee type and try
2674 // to recreate a new ValueObjectChild using it.
2675 if (!m_deref_valobj) {
2676 if (HasSyntheticValue()) {
2677 child_compiler_type = compiler_type.GetPointeeType();
2678
2679 if (child_compiler_type) {
2680 ConstString child_name;
2681 if (!child_name_str.empty())
2682 child_name.SetCString(child_name_str.c_str());
2683
2684 m_deref_valobj = new ValueObjectChild(
2685 *this, child_compiler_type, child_name, child_byte_size,
2686 child_byte_offset, child_bitfield_bit_size,
2687 child_bitfield_bit_offset, child_is_base_class,
2688 child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
2689 }
2690 }
2691 }
2692
2693 } else if (HasSyntheticValue()) {
2694 m_deref_valobj =
2695 GetSyntheticValue()
2696 ->GetChildMemberWithName(ConstString("$$dereference$$"), true)
2697 .get();
2698 } else if (IsSynthetic()) {
2699 m_deref_valobj =
2700 GetChildMemberWithName(ConstString("$$dereference$$"), true).get();
2701 }
2702
2703 if (m_deref_valobj) {
2704 error.Clear();
2705 return m_deref_valobj->GetSP();
2706 } else {
2707 StreamString strm;
2708 GetExpressionPath(strm);
2709
2710 if (is_pointer_or_reference_type)
2711 error.SetErrorStringWithFormat("dereference failed: (%s) %s",
2712 GetTypeName().AsCString("<invalid type>"),
2713 strm.GetData());
2714 else
2715 error.SetErrorStringWithFormat("not a pointer or reference type: (%s) %s",
2716 GetTypeName().AsCString("<invalid type>"),
2717 strm.GetData());
2718 return ValueObjectSP();
2719 }
2720}
2721
2722ValueObjectSP ValueObject::AddressOf(Status &error) {
2723 if (m_addr_of_valobj_sp)
2724 return m_addr_of_valobj_sp;
2725
2726 AddressType address_type = eAddressTypeInvalid;
2727 const bool scalar_is_load_address = false;
2728 addr_t addr = GetAddressOf(scalar_is_load_address, &address_type);
2729 error.Clear();
2730 if (addr != LLDB_INVALID_ADDRESS && address_type != eAddressTypeHost) {
2731 switch (address_type) {
2732 case eAddressTypeInvalid: {
2733 StreamString expr_path_strm;
2734 GetExpressionPath(expr_path_strm);
2735 error.SetErrorStringWithFormat("'%s' is not in memory",
2736 expr_path_strm.GetData());
2737 } break;
2738
2739 case eAddressTypeFile:
2740 case eAddressTypeLoad: {
2741 CompilerType compiler_type = GetCompilerType();
2742 if (compiler_type) {
2743 std::string name(1, '&');
2744 name.append(m_name.AsCString(""));
2745 ExecutionContext exe_ctx(GetExecutionContextRef());
2746 m_addr_of_valobj_sp = ValueObjectConstResult::Create(
2747 exe_ctx.GetBestExecutionContextScope(),
2748 compiler_type.GetPointerType(), ConstString(name.c_str()), addr,
2749 eAddressTypeInvalid, m_data.GetAddressByteSize());
2750 }
2751 } break;
2752 default:
2753 break;
2754 }
2755 } else {
2756 StreamString expr_path_strm;
2757 GetExpressionPath(expr_path_strm);
2758 error.SetErrorStringWithFormat("'%s' doesn't have a valid address",
2759 expr_path_strm.GetData());
2760 }
2761
2762 return m_addr_of_valobj_sp;
2763}
2764
2765ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) {
2766 return ValueObjectCast::Create(*this, GetName(), compiler_type);
2767}
2768
2769lldb::ValueObjectSP ValueObject::Clone(ConstString new_name) {
2770 return ValueObjectCast::Create(*this, new_name, GetCompilerType());
2771}
2772
2773ValueObjectSP ValueObject::CastPointerType(const char *name,
2774 CompilerType &compiler_type) {
2775 ValueObjectSP valobj_sp;
2776 AddressType address_type;
2777 addr_t ptr_value = GetPointerValue(&address_type);
2778
2779 if (ptr_value != LLDB_INVALID_ADDRESS) {
2780 Address ptr_addr(ptr_value);
2781 ExecutionContext exe_ctx(GetExecutionContextRef());
2782 valobj_sp = ValueObjectMemory::Create(
2783 exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, compiler_type);
2784 }
2785 return valobj_sp;
2786}
2787
2788ValueObjectSP ValueObject::CastPointerType(const char *name, TypeSP &type_sp) {
2789 ValueObjectSP valobj_sp;
2790 AddressType address_type;
2791 addr_t ptr_value = GetPointerValue(&address_type);
2792
2793 if (ptr_value != LLDB_INVALID_ADDRESS) {
2794 Address ptr_addr(ptr_value);
2795 ExecutionContext exe_ctx(GetExecutionContextRef());
2796 valobj_sp = ValueObjectMemory::Create(
2797 exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, type_sp);
2798 }
2799 return valobj_sp;
2800}
2801
2802ValueObject::EvaluationPoint::EvaluationPoint() : m_mod_id(), m_exe_ctx_ref() {}
2803
2804ValueObject::EvaluationPoint::EvaluationPoint(ExecutionContextScope *exe_scope,
2805 bool use_selected)
2806 : m_mod_id(), m_exe_ctx_ref() {
2807 ExecutionContext exe_ctx(exe_scope);
2808 TargetSP target_sp(exe_ctx.GetTargetSP());
2809 if (target_sp) {
2810 m_exe_ctx_ref.SetTargetSP(target_sp);
2811 ProcessSP process_sp(exe_ctx.GetProcessSP());
2812 if (!process_sp)
2813 process_sp = target_sp->GetProcessSP();
2814
2815 if (process_sp) {
2816 m_mod_id = process_sp->GetModID();
2817 m_exe_ctx_ref.SetProcessSP(process_sp);
2818
2819 ThreadSP thread_sp(exe_ctx.GetThreadSP());
2820
2821 if (!thread_sp) {
2822 if (use_selected)
2823 thread_sp = process_sp->GetThreadList().GetSelectedThread();
2824 }
2825
2826 if (thread_sp) {
2827 m_exe_ctx_ref.SetThreadSP(thread_sp);
2828
2829 StackFrameSP frame_sp(exe_ctx.GetFrameSP());
2830 if (!frame_sp) {
2831 if (use_selected)
2832 frame_sp = thread_sp->GetSelectedFrame();
2833 }
2834 if (frame_sp)
2835 m_exe_ctx_ref.SetFrameSP(frame_sp);
2836 }
2837 }
2838 }
2839}
2840
2841ValueObject::EvaluationPoint::EvaluationPoint(
2842 const ValueObject::EvaluationPoint &rhs)
2843 : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref) {}
2844
2845ValueObject::EvaluationPoint::~EvaluationPoint() = default;
2846
2847// This function checks the EvaluationPoint against the current process state.
2848// If the current state matches the evaluation point, or the evaluation point
2849// is already invalid, then we return false, meaning "no change". If the
2850// current state is different, we update our state, and return true meaning
2851// "yes, change". If we did see a change, we also set m_needs_update to true,
2852// so future calls to NeedsUpdate will return true. exe_scope will be set to
2853// the current execution context scope.
2854
2855bool ValueObject::EvaluationPoint::SyncWithProcessState(
2856 bool accept_invalid_exe_ctx) {
2857 // Start with the target, if it is NULL, then we're obviously not going to
2858 // get any further:
2859 const bool thread_and_frame_only_if_stopped = true;
2860 ExecutionContext exe_ctx(
2861 m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped));
2862
2863 if (exe_ctx.GetTargetPtr() == nullptr)
2864 return false;
2865
2866 // If we don't have a process nothing can change.
2867 Process *process = exe_ctx.GetProcessPtr();
2868 if (process == nullptr)
2869 return false;
2870
2871 // If our stop id is the current stop ID, nothing has changed:
2872 ProcessModID current_mod_id = process->GetModID();
2873
2874 // If the current stop id is 0, either we haven't run yet, or the process
2875 // state has been cleared. In either case, we aren't going to be able to sync
2876 // with the process state.
2877 if (current_mod_id.GetStopID() == 0)
2878 return false;
2879
2880 bool changed = false;
2881 const bool was_valid = m_mod_id.IsValid();
2882 if (was_valid) {
2883 if (m_mod_id == current_mod_id) {
2884 // Everything is already up to date in this object, no need to update the
2885 // execution context scope.
2886 changed = false;
2887 } else {
2888 m_mod_id = current_mod_id;
2889 m_needs_update = true;
2890 changed = true;
2891 }
2892 }
2893
2894 // Now re-look up the thread and frame in case the underlying objects have
2895 // gone away & been recreated. That way we'll be sure to return a valid
2896 // exe_scope. If we used to have a thread or a frame but can't find it
2897 // anymore, then mark ourselves as invalid.
2898
2899 if (!accept_invalid_exe_ctx) {
2900 if (m_exe_ctx_ref.HasThreadRef()) {
2901 ThreadSP thread_sp(m_exe_ctx_ref.GetThreadSP());
2902 if (thread_sp) {
2903 if (m_exe_ctx_ref.HasFrameRef()) {
2904 StackFrameSP frame_sp(m_exe_ctx_ref.GetFrameSP());
2905 if (!frame_sp) {
2906 // We used to have a frame, but now it is gone
2907 SetInvalid();
2908 changed = was_valid;
2909 }
2910 }
2911 } else {
2912 // We used to have a thread, but now it is gone
2913 SetInvalid();
2914 changed = was_valid;
2915 }
2916 }
2917 }
2918
2919 return changed;
2920}
2921
2922void ValueObject::EvaluationPoint::SetUpdated() {
2923 ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
2924 if (process_sp)
2925 m_mod_id = process_sp->GetModID();
2926 m_needs_update = false;
2927}
2928
2929void ValueObject::ClearUserVisibleData(uint32_t clear_mask) {
2930 if ((clear_mask & eClearUserVisibleDataItemsValue) ==
2931 eClearUserVisibleDataItemsValue)
2932 m_value_str.clear();
2933
2934 if ((clear_mask & eClearUserVisibleDataItemsLocation) ==
2935 eClearUserVisibleDataItemsLocation)
2936 m_location_str.clear();
2937
2938 if ((clear_mask & eClearUserVisibleDataItemsSummary) ==
2939 eClearUserVisibleDataItemsSummary)
2940 m_summary_str.clear();
2941
2942 if ((clear_mask & eClearUserVisibleDataItemsDescription) ==
2943 eClearUserVisibleDataItemsDescription)
2944 m_object_desc_str.clear();
2945
2946 if ((clear_mask & eClearUserVisibleDataItemsSyntheticChildren) ==
2947 eClearUserVisibleDataItemsSyntheticChildren) {
2948 if (m_synthetic_value)
2949 m_synthetic_value = nullptr;
2950 }
2951}
2952
2953SymbolContextScope *ValueObject::GetSymbolContextScope() {
2954 if (m_parent) {
2955 if (!m_parent->IsPointerOrReferenceType())
2956 return m_parent->GetSymbolContextScope();
2957 }
2958 return nullptr;
2959}
2960
2961lldb::ValueObjectSP
2962ValueObject::CreateValueObjectFromExpression(llvm::StringRef name,
2963 llvm::StringRef expression,
2964 const ExecutionContext &exe_ctx) {
2965 return CreateValueObjectFromExpression(name, expression, exe_ctx,
2966 EvaluateExpressionOptions());
2967}
2968
2969lldb::ValueObjectSP ValueObject::CreateValueObjectFromExpression(
2970 llvm::StringRef name, llvm::StringRef expression,
2971 const ExecutionContext &exe_ctx, const EvaluateExpressionOptions &options) {
2972 lldb::ValueObjectSP retval_sp;
2973 lldb::TargetSP target_sp(exe_ctx.GetTargetSP());
2974 if (!target_sp)
2975 return retval_sp;
2976 if (expression.empty())
2977 return retval_sp;
2978 target_sp->EvaluateExpression(expression, exe_ctx.GetFrameSP().get(),
2979 retval_sp, options);
2980 if (retval_sp && !name.empty())
2981 retval_sp->SetName(ConstString(name));
2982 return retval_sp;
2983}
2984
2985lldb::ValueObjectSP ValueObject::CreateValueObjectFromAddress(
2986 llvm::StringRef name, uint64_t address, const ExecutionContext &exe_ctx,
2987 CompilerType type) {
2988 if (type) {
2989 CompilerType pointer_type(type.GetPointerType());
2990 if (pointer_type) {
2991 lldb::DataBufferSP buffer(
2992 new lldb_private::DataBufferHeap(&address, sizeof(lldb::addr_t)));
2993 lldb::ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create(
2994 exe_ctx.GetBestExecutionContextScope(), pointer_type,
2995 ConstString(name), buffer, exe_ctx.GetByteOrder(),
2996 exe_ctx.GetAddressByteSize()));
2997 if (ptr_result_valobj_sp) {
2998 ptr_result_valobj_sp->GetValue().SetValueType(
2999 Value::ValueType::LoadAddress);
3000 Status err;
3001 ptr_result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
3002 if (ptr_result_valobj_sp && !name.empty())
3003 ptr_result_valobj_sp->SetName(ConstString(name));
3004 }
3005 return ptr_result_valobj_sp;
3006 }
3007 }
3008 return lldb::ValueObjectSP();
3009}
3010
3011lldb::ValueObjectSP ValueObject::CreateValueObjectFromData(
3012 llvm::StringRef name, const DataExtractor &data,
3013 const ExecutionContext &exe_ctx, CompilerType type) {
3014 lldb::ValueObjectSP new_value_sp;
3015 new_value_sp = ValueObjectConstResult::Create(
3016 exe_ctx.GetBestExecutionContextScope(), type, ConstString(name), data,
3017 LLDB_INVALID_ADDRESS);
3018 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
3019 if (new_value_sp && !name.empty())
3020 new_value_sp->SetName(ConstString(name));
3021 return new_value_sp;
3022}
3023
3024ModuleSP ValueObject::GetModule() {
3025 ValueObject *root(GetRoot());
3026 if (root != this)
3027 return root->GetModule();
3028 return lldb::ModuleSP();
3029}
3030
3031ValueObject *ValueObject::GetRoot() {
3032 if (m_root)
3033 return m_root;
3034 return (m_root = FollowParentChain([](ValueObject *vo) -> bool {
3035 return (vo->m_parent != nullptr);
3036 }));
3037}
3038
3039ValueObject *
3040ValueObject::FollowParentChain(std::function<bool(ValueObject *)> f) {
3041 ValueObject *vo = this;
3042 while (vo) {
3043 if (!f(vo))
3044 break;
3045 vo = vo->m_parent;
3046 }
3047 return vo;
3048}
3049
3050AddressType ValueObject::GetAddressTypeOfChildren() {
3051 if (m_address_type_of_ptr_or_ref_children == eAddressTypeInvalid) {
3052 ValueObject *root(GetRoot());
3053 if (root != this)
3054 return root->GetAddressTypeOfChildren();
3055 }
3056 return m_address_type_of_ptr_or_ref_children;
3057}
3058
3059lldb::DynamicValueType ValueObject::GetDynamicValueType() {
3060 ValueObject *with_dv_info = this;
3061 while (with_dv_info) {
3062 if (with_dv_info->HasDynamicValueTypeInfo())
3063 return with_dv_info->GetDynamicValueTypeImpl();
3064 with_dv_info = with_dv_info->m_parent;
3065 }
3066 return lldb::eNoDynamicValues;
3067}
3068
3069lldb::Format ValueObject::GetFormat() const {
3070 const ValueObject *with_fmt_info = this;
3071 while (with_fmt_info) {
3072 if (with_fmt_info->m_format != lldb::eFormatDefault)
3073 return with_fmt_info->m_format;
3074 with_fmt_info = with_fmt_info->m_parent;
3075 }
3076 return m_format;
3077}
3078
3079lldb::LanguageType ValueObject::GetPreferredDisplayLanguage() {
3080 lldb::LanguageType type = m_preferred_display_language;
3081 if (m_preferred_display_language == lldb::eLanguageTypeUnknown) {
3082 if (GetRoot()) {
3083 if (GetRoot() == this) {
3084 if (StackFrameSP frame_sp = GetFrameSP()) {
3085 const SymbolContext &sc(
3086 frame_sp->GetSymbolContext(eSymbolContextCompUnit));
3087 if (CompileUnit *cu = sc.comp_unit)
3088 type = cu->GetLanguage();
3089 }
3090 } else {
3091 type = GetRoot()->GetPreferredDisplayLanguage();
3092 }
3093 }
3094 }
3095 return (m_preferred_display_language = type); // only compute it once
3096}
3097
3098void ValueObject::SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType lt) {
3099 if (m_preferred_display_language == lldb::eLanguageTypeUnknown)
3100 SetPreferredDisplayLanguage(lt);
3101}
3102
3103bool ValueObject::CanProvideValue() {
3104 // we need to support invalid types as providers of values because some bare-
3105 // board debugging scenarios have no notion of types, but still manage to
3106 // have raw numeric values for things like registers. sigh.
3107 CompilerType type = GetCompilerType();
3108 return (!type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
3109}
3110
3111
3112
3113ValueObjectSP ValueObject::Persist() {
3114 if (!UpdateValueIfNeeded())
3115 return nullptr;
3116
3117 TargetSP target_sp(GetTargetSP());
3118 if (!target_sp)
3119 return nullptr;
3120
3121 PersistentExpressionState *persistent_state =
3122 target_sp->GetPersistentExpressionStateForLanguage(
3123 GetPreferredDisplayLanguage());
3124
3125 if (!persistent_state)
3126 return nullptr;
3127
3128 ConstString name = persistent_state->GetNextPersistentVariableName();
3129
3130 ValueObjectSP const_result_sp =
3131 ValueObjectConstResult::Create(target_sp.get(), GetValue(), name);
3132
3133 ExpressionVariableSP persistent_var_sp =
3134 persistent_state->CreatePersistentVariable(const_result_sp);
3135 persistent_var_sp->m_live_sp = persistent_var_sp->m_frozen_sp;
3136 persistent_var_sp->m_flags |= ExpressionVariable::EVIsProgramReference;
3137
3138 return persistent_var_sp->GetValueObject();
3139}
3140

source code of lldb/source/Core/ValueObject.cpp