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