1 //===-- SBValue.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/API/SBValue.h"
10 #include "lldb/Utility/Instrumentation.h"
11 
12 #include "lldb/API/SBDeclaration.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/API/SBTypeFilter.h"
15 #include "lldb/API/SBTypeFormat.h"
16 #include "lldb/API/SBTypeSummary.h"
17 #include "lldb/API/SBTypeSynthetic.h"
18 
19 #include "lldb/Breakpoint/Watchpoint.h"
20 #include "lldb/Core/Declaration.h"
21 #include "lldb/Core/Module.h"
22 #include "lldb/Core/Section.h"
23 #include "lldb/Core/Value.h"
24 #include "lldb/Core/ValueObject.h"
25 #include "lldb/Core/ValueObjectConstResult.h"
26 #include "lldb/DataFormatters/DataVisualization.h"
27 #include "lldb/Symbol/Block.h"
28 #include "lldb/Symbol/ObjectFile.h"
29 #include "lldb/Symbol/Type.h"
30 #include "lldb/Symbol/Variable.h"
31 #include "lldb/Symbol/VariableList.h"
32 #include "lldb/Target/ExecutionContext.h"
33 #include "lldb/Target/Process.h"
34 #include "lldb/Target/StackFrame.h"
35 #include "lldb/Target/Target.h"
36 #include "lldb/Target/Thread.h"
37 #include "lldb/Utility/DataExtractor.h"
38 #include "lldb/Utility/Scalar.h"
39 #include "lldb/Utility/Stream.h"
40 
41 #include "lldb/API/SBDebugger.h"
42 #include "lldb/API/SBExpressionOptions.h"
43 #include "lldb/API/SBFrame.h"
44 #include "lldb/API/SBProcess.h"
45 #include "lldb/API/SBTarget.h"
46 #include "lldb/API/SBThread.h"
47 
48 #include <memory>
49 
50 using namespace lldb;
51 using namespace lldb_private;
52 
53 class ValueImpl {
54 public:
55   ValueImpl() = default;
56 
57   ValueImpl(lldb::ValueObjectSP in_valobj_sp,
58             lldb::DynamicValueType use_dynamic, bool use_synthetic,
59             const char *name = nullptr)
60       : m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic),
61         m_name(name) {
62     if (in_valobj_sp) {
63       if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
64                lldb::eNoDynamicValues, false))) {
65         if (!m_name.IsEmpty())
66           m_valobj_sp->SetName(m_name);
67       }
68     }
69   }
70 
71   ValueImpl(const ValueImpl &rhs) = default;
72 
73   ValueImpl &operator=(const ValueImpl &rhs) {
74     if (this != &rhs) {
75       m_valobj_sp = rhs.m_valobj_sp;
76       m_use_dynamic = rhs.m_use_dynamic;
77       m_use_synthetic = rhs.m_use_synthetic;
78       m_name = rhs.m_name;
79     }
80     return *this;
81   }
82 
83   bool IsValid() {
84     if (m_valobj_sp.get() == nullptr)
85       return false;
86     else {
87       // FIXME: This check is necessary but not sufficient.  We for sure don't
88       // want to touch SBValues whose owning
89       // targets have gone away.  This check is a little weak in that it
90       // enforces that restriction when you call IsValid, but since IsValid
91       // doesn't lock the target, you have no guarantee that the SBValue won't
92       // go invalid after you call this... Also, an SBValue could depend on
93       // data from one of the modules in the target, and those could go away
94       // independently of the target, for instance if a module is unloaded.
95       // But right now, neither SBValues nor ValueObjects know which modules
96       // they depend on.  So I have no good way to make that check without
97       // tracking that in all the ValueObject subclasses.
98       TargetSP target_sp = m_valobj_sp->GetTargetSP();
99       return target_sp && target_sp->IsValid();
100     }
101   }
102 
103   lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }
104 
105   lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
106                             std::unique_lock<std::recursive_mutex> &lock,
107                             Status &error) {
108     if (!m_valobj_sp) {
109       error.SetErrorString("invalid value object");
110       return m_valobj_sp;
111     }
112 
113     lldb::ValueObjectSP value_sp = m_valobj_sp;
114 
115     Target *target = value_sp->GetTargetSP().get();
116     // If this ValueObject holds an error, then it is valuable for that.
117     if (value_sp->GetError().Fail())
118       return value_sp;
119 
120     if (!target)
121       return ValueObjectSP();
122 
123     lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
124 
125     ProcessSP process_sp(value_sp->GetProcessSP());
126     if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
127       // We don't allow people to play around with ValueObject if the process
128       // is running. If you want to look at values, pause the process, then
129       // look.
130       error.SetErrorString("process must be stopped.");
131       return ValueObjectSP();
132     }
133 
134     if (m_use_dynamic != eNoDynamicValues) {
135       ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
136       if (dynamic_sp)
137         value_sp = dynamic_sp;
138     }
139 
140     if (m_use_synthetic) {
141       ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue();
142       if (synthetic_sp)
143         value_sp = synthetic_sp;
144     }
145 
146     if (!value_sp)
147       error.SetErrorString("invalid value object");
148     if (!m_name.IsEmpty())
149       value_sp->SetName(m_name);
150 
151     return value_sp;
152   }
153 
154   void SetUseDynamic(lldb::DynamicValueType use_dynamic) {
155     m_use_dynamic = use_dynamic;
156   }
157 
158   void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; }
159 
160   lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; }
161 
162   bool GetUseSynthetic() { return m_use_synthetic; }
163 
164   // All the derived values that we would make from the m_valobj_sp will share
165   // the ExecutionContext with m_valobj_sp, so we don't need to do the
166   // calculations in GetSP to return the Target, Process, Thread or Frame.  It
167   // is convenient to provide simple accessors for these, which I do here.
168   TargetSP GetTargetSP() {
169     if (m_valobj_sp)
170       return m_valobj_sp->GetTargetSP();
171     else
172       return TargetSP();
173   }
174 
175   ProcessSP GetProcessSP() {
176     if (m_valobj_sp)
177       return m_valobj_sp->GetProcessSP();
178     else
179       return ProcessSP();
180   }
181 
182   ThreadSP GetThreadSP() {
183     if (m_valobj_sp)
184       return m_valobj_sp->GetThreadSP();
185     else
186       return ThreadSP();
187   }
188 
189   StackFrameSP GetFrameSP() {
190     if (m_valobj_sp)
191       return m_valobj_sp->GetFrameSP();
192     else
193       return StackFrameSP();
194   }
195 
196 private:
197   lldb::ValueObjectSP m_valobj_sp;
198   lldb::DynamicValueType m_use_dynamic;
199   bool m_use_synthetic;
200   ConstString m_name;
201 };
202 
203 class ValueLocker {
204 public:
205   ValueLocker() = default;
206 
207   ValueObjectSP GetLockedSP(ValueImpl &in_value) {
208     return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
209   }
210 
211   Status &GetError() { return m_lock_error; }
212 
213 private:
214   Process::StopLocker m_stop_locker;
215   std::unique_lock<std::recursive_mutex> m_lock;
216   Status m_lock_error;
217 };
218 
219 SBValue::SBValue() { LLDB_INSTRUMENT_VA(this); }
220 
221 SBValue::SBValue(const lldb::ValueObjectSP &value_sp) {
222   LLDB_INSTRUMENT_VA(this, value_sp);
223 
224   SetSP(value_sp);
225 }
226 
227 SBValue::SBValue(const SBValue &rhs) {
228   LLDB_INSTRUMENT_VA(this, rhs);
229 
230   SetSP(rhs.m_opaque_sp);
231 }
232 
233 SBValue &SBValue::operator=(const SBValue &rhs) {
234   LLDB_INSTRUMENT_VA(this, rhs);
235 
236   if (this != &rhs) {
237     SetSP(rhs.m_opaque_sp);
238   }
239   return *this;
240 }
241 
242 SBValue::~SBValue() = default;
243 
244 bool SBValue::IsValid() {
245   LLDB_INSTRUMENT_VA(this);
246   return this->operator bool();
247 }
248 SBValue::operator bool() const {
249   LLDB_INSTRUMENT_VA(this);
250 
251   // If this function ever changes to anything that does more than just check
252   // if the opaque shared pointer is non NULL, then we need to update all "if
253   // (m_opaque_sp)" code in this file.
254   return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid() &&
255          m_opaque_sp->GetRootSP().get() != nullptr;
256 }
257 
258 void SBValue::Clear() {
259   LLDB_INSTRUMENT_VA(this);
260 
261   m_opaque_sp.reset();
262 }
263 
264 SBError SBValue::GetError() {
265   LLDB_INSTRUMENT_VA(this);
266 
267   SBError sb_error;
268 
269   ValueLocker locker;
270   lldb::ValueObjectSP value_sp(GetSP(locker));
271   if (value_sp)
272     sb_error.SetError(value_sp->GetError());
273   else
274     sb_error.SetErrorStringWithFormat("error: %s",
275                                       locker.GetError().AsCString());
276 
277   return sb_error;
278 }
279 
280 user_id_t SBValue::GetID() {
281   LLDB_INSTRUMENT_VA(this);
282 
283   ValueLocker locker;
284   lldb::ValueObjectSP value_sp(GetSP(locker));
285   if (value_sp)
286     return value_sp->GetID();
287   return LLDB_INVALID_UID;
288 }
289 
290 const char *SBValue::GetName() {
291   LLDB_INSTRUMENT_VA(this);
292 
293   ValueLocker locker;
294   lldb::ValueObjectSP value_sp(GetSP(locker));
295   if (!value_sp)
296     return nullptr;
297 
298   return value_sp->GetName().GetCString();
299 }
300 
301 const char *SBValue::GetTypeName() {
302   LLDB_INSTRUMENT_VA(this);
303 
304   ValueLocker locker;
305   lldb::ValueObjectSP value_sp(GetSP(locker));
306   if (!value_sp)
307     return nullptr;
308 
309   return value_sp->GetQualifiedTypeName().GetCString();
310 }
311 
312 const char *SBValue::GetDisplayTypeName() {
313   LLDB_INSTRUMENT_VA(this);
314 
315   ValueLocker locker;
316   lldb::ValueObjectSP value_sp(GetSP(locker));
317   if (!value_sp)
318     return nullptr;
319 
320   return value_sp->GetDisplayTypeName().GetCString();
321 }
322 
323 size_t SBValue::GetByteSize() {
324   LLDB_INSTRUMENT_VA(this);
325 
326   size_t result = 0;
327 
328   ValueLocker locker;
329   lldb::ValueObjectSP value_sp(GetSP(locker));
330   if (value_sp) {
331     result = value_sp->GetByteSize().value_or(0);
332   }
333 
334   return result;
335 }
336 
337 bool SBValue::IsInScope() {
338   LLDB_INSTRUMENT_VA(this);
339 
340   bool result = false;
341 
342   ValueLocker locker;
343   lldb::ValueObjectSP value_sp(GetSP(locker));
344   if (value_sp) {
345     result = value_sp->IsInScope();
346   }
347 
348   return result;
349 }
350 
351 const char *SBValue::GetValue() {
352   LLDB_INSTRUMENT_VA(this);
353 
354   ValueLocker locker;
355   lldb::ValueObjectSP value_sp(GetSP(locker));
356   if (!value_sp)
357     return nullptr;
358   return ConstString(value_sp->GetValueAsCString()).GetCString();
359 }
360 
361 ValueType SBValue::GetValueType() {
362   LLDB_INSTRUMENT_VA(this);
363 
364   ValueType result = eValueTypeInvalid;
365   ValueLocker locker;
366   lldb::ValueObjectSP value_sp(GetSP(locker));
367   if (value_sp)
368     result = value_sp->GetValueType();
369 
370   return result;
371 }
372 
373 const char *SBValue::GetObjectDescription() {
374   LLDB_INSTRUMENT_VA(this);
375 
376   ValueLocker locker;
377   lldb::ValueObjectSP value_sp(GetSP(locker));
378   if (!value_sp)
379     return nullptr;
380 
381   return ConstString(value_sp->GetObjectDescription()).GetCString();
382 }
383 
384 SBType SBValue::GetType() {
385   LLDB_INSTRUMENT_VA(this);
386 
387   SBType sb_type;
388   ValueLocker locker;
389   lldb::ValueObjectSP value_sp(GetSP(locker));
390   TypeImplSP type_sp;
391   if (value_sp) {
392     type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
393     sb_type.SetSP(type_sp);
394   }
395 
396   return sb_type;
397 }
398 
399 bool SBValue::GetValueDidChange() {
400   LLDB_INSTRUMENT_VA(this);
401 
402   bool result = false;
403   ValueLocker locker;
404   lldb::ValueObjectSP value_sp(GetSP(locker));
405   if (value_sp) {
406     if (value_sp->UpdateValueIfNeeded(false))
407       result = value_sp->GetValueDidChange();
408   }
409 
410   return result;
411 }
412 
413 const char *SBValue::GetSummary() {
414   LLDB_INSTRUMENT_VA(this);
415 
416   ValueLocker locker;
417   lldb::ValueObjectSP value_sp(GetSP(locker));
418   if (!value_sp)
419     return nullptr;
420 
421   return ConstString(value_sp->GetSummaryAsCString()).GetCString();
422 }
423 
424 const char *SBValue::GetSummary(lldb::SBStream &stream,
425                                 lldb::SBTypeSummaryOptions &options) {
426   LLDB_INSTRUMENT_VA(this, stream, options);
427 
428   ValueLocker locker;
429   lldb::ValueObjectSP value_sp(GetSP(locker));
430   if (value_sp) {
431     std::string buffer;
432     if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
433       stream.Printf("%s", buffer.c_str());
434   }
435   return ConstString(stream.GetData()).GetCString();
436 }
437 
438 const char *SBValue::GetLocation() {
439   LLDB_INSTRUMENT_VA(this);
440 
441   ValueLocker locker;
442   lldb::ValueObjectSP value_sp(GetSP(locker));
443   if (!value_sp)
444     return nullptr;
445 
446   return ConstString(value_sp->GetLocationAsCString()).GetCString();
447 }
448 
449 // Deprecated - use the one that takes an lldb::SBError
450 bool SBValue::SetValueFromCString(const char *value_str) {
451   LLDB_INSTRUMENT_VA(this, value_str);
452 
453   lldb::SBError dummy;
454   return SetValueFromCString(value_str, dummy);
455 }
456 
457 bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
458   LLDB_INSTRUMENT_VA(this, value_str, error);
459 
460   bool success = false;
461   ValueLocker locker;
462   lldb::ValueObjectSP value_sp(GetSP(locker));
463   if (value_sp) {
464     success = value_sp->SetValueFromCString(value_str, error.ref());
465   } else
466     error.SetErrorStringWithFormat("Could not get value: %s",
467                                    locker.GetError().AsCString());
468 
469   return success;
470 }
471 
472 lldb::SBTypeFormat SBValue::GetTypeFormat() {
473   LLDB_INSTRUMENT_VA(this);
474 
475   lldb::SBTypeFormat format;
476   ValueLocker locker;
477   lldb::ValueObjectSP value_sp(GetSP(locker));
478   if (value_sp) {
479     if (value_sp->UpdateValueIfNeeded(true)) {
480       lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
481       if (format_sp)
482         format.SetSP(format_sp);
483     }
484   }
485   return format;
486 }
487 
488 lldb::SBTypeSummary SBValue::GetTypeSummary() {
489   LLDB_INSTRUMENT_VA(this);
490 
491   lldb::SBTypeSummary summary;
492   ValueLocker locker;
493   lldb::ValueObjectSP value_sp(GetSP(locker));
494   if (value_sp) {
495     if (value_sp->UpdateValueIfNeeded(true)) {
496       lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
497       if (summary_sp)
498         summary.SetSP(summary_sp);
499     }
500   }
501   return summary;
502 }
503 
504 lldb::SBTypeFilter SBValue::GetTypeFilter() {
505   LLDB_INSTRUMENT_VA(this);
506 
507   lldb::SBTypeFilter filter;
508   ValueLocker locker;
509   lldb::ValueObjectSP value_sp(GetSP(locker));
510   if (value_sp) {
511     if (value_sp->UpdateValueIfNeeded(true)) {
512       lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
513 
514       if (synthetic_sp && !synthetic_sp->IsScripted()) {
515         TypeFilterImplSP filter_sp =
516             std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
517         filter.SetSP(filter_sp);
518       }
519     }
520   }
521   return filter;
522 }
523 
524 lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
525   LLDB_INSTRUMENT_VA(this);
526 
527   lldb::SBTypeSynthetic synthetic;
528   ValueLocker locker;
529   lldb::ValueObjectSP value_sp(GetSP(locker));
530   if (value_sp) {
531     if (value_sp->UpdateValueIfNeeded(true)) {
532       lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
533 
534       if (children_sp && children_sp->IsScripted()) {
535         ScriptedSyntheticChildrenSP synth_sp =
536             std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
537         synthetic.SetSP(synth_sp);
538       }
539     }
540   }
541   return synthetic;
542 }
543 
544 lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
545                                            SBType type) {
546   LLDB_INSTRUMENT_VA(this, name, offset, type);
547 
548   lldb::SBValue sb_value;
549   ValueLocker locker;
550   lldb::ValueObjectSP value_sp(GetSP(locker));
551   lldb::ValueObjectSP new_value_sp;
552   if (value_sp) {
553     TypeImplSP type_sp(type.GetSP());
554     if (type.IsValid()) {
555       sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
556                          offset, type_sp->GetCompilerType(false), true),
557                      GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
558     }
559   }
560   return sb_value;
561 }
562 
563 lldb::SBValue SBValue::Cast(SBType type) {
564   LLDB_INSTRUMENT_VA(this, type);
565 
566   lldb::SBValue sb_value;
567   ValueLocker locker;
568   lldb::ValueObjectSP value_sp(GetSP(locker));
569   TypeImplSP type_sp(type.GetSP());
570   if (value_sp && type_sp)
571     sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
572                    GetPreferDynamicValue(), GetPreferSyntheticValue());
573   return sb_value;
574 }
575 
576 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
577                                                  const char *expression) {
578   LLDB_INSTRUMENT_VA(this, name, expression);
579 
580   SBExpressionOptions options;
581   options.ref().SetKeepInMemory(true);
582   return CreateValueFromExpression(name, expression, options);
583 }
584 
585 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
586                                                  const char *expression,
587                                                  SBExpressionOptions &options) {
588   LLDB_INSTRUMENT_VA(this, name, expression, options);
589 
590   lldb::SBValue sb_value;
591   ValueLocker locker;
592   lldb::ValueObjectSP value_sp(GetSP(locker));
593   lldb::ValueObjectSP new_value_sp;
594   if (value_sp) {
595     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
596     new_value_sp = ValueObject::CreateValueObjectFromExpression(
597         name, expression, exe_ctx, options.ref());
598     if (new_value_sp)
599       new_value_sp->SetName(ConstString(name));
600   }
601   sb_value.SetSP(new_value_sp);
602   return sb_value;
603 }
604 
605 lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
606                                               lldb::addr_t address,
607                                               SBType sb_type) {
608   LLDB_INSTRUMENT_VA(this, name, address, sb_type);
609 
610   lldb::SBValue sb_value;
611   ValueLocker locker;
612   lldb::ValueObjectSP value_sp(GetSP(locker));
613   lldb::ValueObjectSP new_value_sp;
614   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
615   if (value_sp && type_impl_sp) {
616     CompilerType ast_type(type_impl_sp->GetCompilerType(true));
617     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
618     new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address,
619                                                              exe_ctx, ast_type);
620   }
621   sb_value.SetSP(new_value_sp);
622   return sb_value;
623 }
624 
625 lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
626                                            SBType sb_type) {
627   LLDB_INSTRUMENT_VA(this, name, data, sb_type);
628 
629   lldb::SBValue sb_value;
630   lldb::ValueObjectSP new_value_sp;
631   ValueLocker locker;
632   lldb::ValueObjectSP value_sp(GetSP(locker));
633   lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
634   if (value_sp && type_impl_sp) {
635     ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
636     new_value_sp = ValueObject::CreateValueObjectFromData(
637         name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
638     new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
639   }
640   sb_value.SetSP(new_value_sp);
641   return sb_value;
642 }
643 
644 SBValue SBValue::GetChildAtIndex(uint32_t idx) {
645   LLDB_INSTRUMENT_VA(this, idx);
646 
647   const bool can_create_synthetic = false;
648   lldb::DynamicValueType use_dynamic = eNoDynamicValues;
649   TargetSP target_sp;
650   if (m_opaque_sp)
651     target_sp = m_opaque_sp->GetTargetSP();
652 
653   if (target_sp)
654     use_dynamic = target_sp->GetPreferDynamicValue();
655 
656   return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
657 }
658 
659 SBValue SBValue::GetChildAtIndex(uint32_t idx,
660                                  lldb::DynamicValueType use_dynamic,
661                                  bool can_create_synthetic) {
662   LLDB_INSTRUMENT_VA(this, idx, use_dynamic, can_create_synthetic);
663 
664   lldb::ValueObjectSP child_sp;
665 
666   ValueLocker locker;
667   lldb::ValueObjectSP value_sp(GetSP(locker));
668   if (value_sp) {
669     const bool can_create = true;
670     child_sp = value_sp->GetChildAtIndex(idx);
671     if (can_create_synthetic && !child_sp) {
672       child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
673     }
674   }
675 
676   SBValue sb_value;
677   sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
678 
679   return sb_value;
680 }
681 
682 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
683   LLDB_INSTRUMENT_VA(this, name);
684 
685   uint32_t idx = UINT32_MAX;
686   ValueLocker locker;
687   lldb::ValueObjectSP value_sp(GetSP(locker));
688   if (value_sp) {
689     idx = value_sp->GetIndexOfChildWithName(name);
690   }
691   return idx;
692 }
693 
694 SBValue SBValue::GetChildMemberWithName(const char *name) {
695   LLDB_INSTRUMENT_VA(this, name);
696 
697   lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
698   TargetSP target_sp;
699   if (m_opaque_sp)
700     target_sp = m_opaque_sp->GetTargetSP();
701 
702   if (target_sp)
703     use_dynamic_value = target_sp->GetPreferDynamicValue();
704   return GetChildMemberWithName(name, use_dynamic_value);
705 }
706 
707 SBValue
708 SBValue::GetChildMemberWithName(const char *name,
709                                 lldb::DynamicValueType use_dynamic_value) {
710   LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
711 
712   lldb::ValueObjectSP child_sp;
713 
714   ValueLocker locker;
715   lldb::ValueObjectSP value_sp(GetSP(locker));
716   if (value_sp) {
717     child_sp = value_sp->GetChildMemberWithName(name);
718   }
719 
720   SBValue sb_value;
721   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
722 
723   return sb_value;
724 }
725 
726 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
727   LLDB_INSTRUMENT_VA(this, use_dynamic);
728 
729   SBValue value_sb;
730   if (IsValid()) {
731     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
732                                        m_opaque_sp->GetUseSynthetic()));
733     value_sb.SetSP(proxy_sp);
734   }
735   return value_sb;
736 }
737 
738 lldb::SBValue SBValue::GetStaticValue() {
739   LLDB_INSTRUMENT_VA(this);
740 
741   SBValue value_sb;
742   if (IsValid()) {
743     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
744                                        eNoDynamicValues,
745                                        m_opaque_sp->GetUseSynthetic()));
746     value_sb.SetSP(proxy_sp);
747   }
748   return value_sb;
749 }
750 
751 lldb::SBValue SBValue::GetNonSyntheticValue() {
752   LLDB_INSTRUMENT_VA(this);
753 
754   SBValue value_sb;
755   if (IsValid()) {
756     ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
757                                        m_opaque_sp->GetUseDynamic(), false));
758     value_sb.SetSP(proxy_sp);
759   }
760   return value_sb;
761 }
762 
763 lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
764   LLDB_INSTRUMENT_VA(this);
765 
766   if (!IsValid())
767     return eNoDynamicValues;
768   return m_opaque_sp->GetUseDynamic();
769 }
770 
771 void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
772   LLDB_INSTRUMENT_VA(this, use_dynamic);
773 
774   if (IsValid())
775     return m_opaque_sp->SetUseDynamic(use_dynamic);
776 }
777 
778 bool SBValue::GetPreferSyntheticValue() {
779   LLDB_INSTRUMENT_VA(this);
780 
781   if (!IsValid())
782     return false;
783   return m_opaque_sp->GetUseSynthetic();
784 }
785 
786 void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
787   LLDB_INSTRUMENT_VA(this, use_synthetic);
788 
789   if (IsValid())
790     return m_opaque_sp->SetUseSynthetic(use_synthetic);
791 }
792 
793 bool SBValue::IsDynamic() {
794   LLDB_INSTRUMENT_VA(this);
795 
796   ValueLocker locker;
797   lldb::ValueObjectSP value_sp(GetSP(locker));
798   if (value_sp)
799     return value_sp->IsDynamic();
800   return false;
801 }
802 
803 bool SBValue::IsSynthetic() {
804   LLDB_INSTRUMENT_VA(this);
805 
806   ValueLocker locker;
807   lldb::ValueObjectSP value_sp(GetSP(locker));
808   if (value_sp)
809     return value_sp->IsSynthetic();
810   return false;
811 }
812 
813 bool SBValue::IsSyntheticChildrenGenerated() {
814   LLDB_INSTRUMENT_VA(this);
815 
816   ValueLocker locker;
817   lldb::ValueObjectSP value_sp(GetSP(locker));
818   if (value_sp)
819     return value_sp->IsSyntheticChildrenGenerated();
820   return false;
821 }
822 
823 void SBValue::SetSyntheticChildrenGenerated(bool is) {
824   LLDB_INSTRUMENT_VA(this, is);
825 
826   ValueLocker locker;
827   lldb::ValueObjectSP value_sp(GetSP(locker));
828   if (value_sp)
829     return value_sp->SetSyntheticChildrenGenerated(is);
830 }
831 
832 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
833   LLDB_INSTRUMENT_VA(this, expr_path);
834 
835   lldb::ValueObjectSP child_sp;
836   ValueLocker locker;
837   lldb::ValueObjectSP value_sp(GetSP(locker));
838   if (value_sp) {
839     // using default values for all the fancy options, just do it if you can
840     child_sp = value_sp->GetValueForExpressionPath(expr_path);
841   }
842 
843   SBValue sb_value;
844   sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
845 
846   return sb_value;
847 }
848 
849 int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
850   LLDB_INSTRUMENT_VA(this, error, fail_value);
851 
852   error.Clear();
853   ValueLocker locker;
854   lldb::ValueObjectSP value_sp(GetSP(locker));
855   if (value_sp) {
856     bool success = true;
857     uint64_t ret_val = fail_value;
858     ret_val = value_sp->GetValueAsSigned(fail_value, &success);
859     if (!success)
860       error.SetErrorString("could not resolve value");
861     return ret_val;
862   } else
863     error.SetErrorStringWithFormat("could not get SBValue: %s",
864                                    locker.GetError().AsCString());
865 
866   return fail_value;
867 }
868 
869 uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
870   LLDB_INSTRUMENT_VA(this, error, fail_value);
871 
872   error.Clear();
873   ValueLocker locker;
874   lldb::ValueObjectSP value_sp(GetSP(locker));
875   if (value_sp) {
876     bool success = true;
877     uint64_t ret_val = fail_value;
878     ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
879     if (!success)
880       error.SetErrorString("could not resolve value");
881     return ret_val;
882   } else
883     error.SetErrorStringWithFormat("could not get SBValue: %s",
884                                    locker.GetError().AsCString());
885 
886   return fail_value;
887 }
888 
889 int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
890   LLDB_INSTRUMENT_VA(this, fail_value);
891 
892   ValueLocker locker;
893   lldb::ValueObjectSP value_sp(GetSP(locker));
894   if (value_sp) {
895     return value_sp->GetValueAsSigned(fail_value);
896   }
897   return fail_value;
898 }
899 
900 uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
901   LLDB_INSTRUMENT_VA(this, fail_value);
902 
903   ValueLocker locker;
904   lldb::ValueObjectSP value_sp(GetSP(locker));
905   if (value_sp) {
906     return value_sp->GetValueAsUnsigned(fail_value);
907   }
908   return fail_value;
909 }
910 
911 bool SBValue::MightHaveChildren() {
912   LLDB_INSTRUMENT_VA(this);
913 
914   bool has_children = false;
915   ValueLocker locker;
916   lldb::ValueObjectSP value_sp(GetSP(locker));
917   if (value_sp)
918     has_children = value_sp->MightHaveChildren();
919 
920   return has_children;
921 }
922 
923 bool SBValue::IsRuntimeSupportValue() {
924   LLDB_INSTRUMENT_VA(this);
925 
926   bool is_support = false;
927   ValueLocker locker;
928   lldb::ValueObjectSP value_sp(GetSP(locker));
929   if (value_sp)
930     is_support = value_sp->IsRuntimeSupportValue();
931 
932   return is_support;
933 }
934 
935 uint32_t SBValue::GetNumChildren() {
936   LLDB_INSTRUMENT_VA(this);
937 
938   return GetNumChildren(UINT32_MAX);
939 }
940 
941 uint32_t SBValue::GetNumChildren(uint32_t max) {
942   LLDB_INSTRUMENT_VA(this, max);
943 
944   uint32_t num_children = 0;
945 
946   ValueLocker locker;
947   lldb::ValueObjectSP value_sp(GetSP(locker));
948   if (value_sp)
949     num_children = value_sp->GetNumChildren(max);
950 
951   return num_children;
952 }
953 
954 SBValue SBValue::Dereference() {
955   LLDB_INSTRUMENT_VA(this);
956 
957   SBValue sb_value;
958   ValueLocker locker;
959   lldb::ValueObjectSP value_sp(GetSP(locker));
960   if (value_sp) {
961     Status error;
962     sb_value = value_sp->Dereference(error);
963   }
964 
965   return sb_value;
966 }
967 
968 // Deprecated - please use GetType().IsPointerType() instead.
969 bool SBValue::TypeIsPointerType() {
970   LLDB_INSTRUMENT_VA(this);
971 
972   return GetType().IsPointerType();
973 }
974 
975 void *SBValue::GetOpaqueType() {
976   LLDB_INSTRUMENT_VA(this);
977 
978   ValueLocker locker;
979   lldb::ValueObjectSP value_sp(GetSP(locker));
980   if (value_sp)
981     return value_sp->GetCompilerType().GetOpaqueQualType();
982   return nullptr;
983 }
984 
985 lldb::SBTarget SBValue::GetTarget() {
986   LLDB_INSTRUMENT_VA(this);
987 
988   SBTarget sb_target;
989   TargetSP target_sp;
990   if (m_opaque_sp) {
991     target_sp = m_opaque_sp->GetTargetSP();
992     sb_target.SetSP(target_sp);
993   }
994 
995   return sb_target;
996 }
997 
998 lldb::SBProcess SBValue::GetProcess() {
999   LLDB_INSTRUMENT_VA(this);
1000 
1001   SBProcess sb_process;
1002   ProcessSP process_sp;
1003   if (m_opaque_sp) {
1004     process_sp = m_opaque_sp->GetProcessSP();
1005     sb_process.SetSP(process_sp);
1006   }
1007 
1008   return sb_process;
1009 }
1010 
1011 lldb::SBThread SBValue::GetThread() {
1012   LLDB_INSTRUMENT_VA(this);
1013 
1014   SBThread sb_thread;
1015   ThreadSP thread_sp;
1016   if (m_opaque_sp) {
1017     thread_sp = m_opaque_sp->GetThreadSP();
1018     sb_thread.SetThread(thread_sp);
1019   }
1020 
1021   return sb_thread;
1022 }
1023 
1024 lldb::SBFrame SBValue::GetFrame() {
1025   LLDB_INSTRUMENT_VA(this);
1026 
1027   SBFrame sb_frame;
1028   StackFrameSP frame_sp;
1029   if (m_opaque_sp) {
1030     frame_sp = m_opaque_sp->GetFrameSP();
1031     sb_frame.SetFrameSP(frame_sp);
1032   }
1033 
1034   return sb_frame;
1035 }
1036 
1037 lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
1038   // IsValid means that the SBValue has a value in it.  But that's not the
1039   // only time that ValueObjects are useful.  We also want to return the value
1040   // if there's an error state in it.
1041   if (!m_opaque_sp || (!m_opaque_sp->IsValid()
1042       && (m_opaque_sp->GetRootSP()
1043           && !m_opaque_sp->GetRootSP()->GetError().Fail()))) {
1044     locker.GetError().SetErrorString("No value");
1045     return ValueObjectSP();
1046   }
1047   return locker.GetLockedSP(*m_opaque_sp.get());
1048 }
1049 
1050 lldb::ValueObjectSP SBValue::GetSP() const {
1051   LLDB_INSTRUMENT_VA(this);
1052 
1053   ValueLocker locker;
1054   return GetSP(locker);
1055 }
1056 
1057 void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
1058 
1059 void SBValue::SetSP(const lldb::ValueObjectSP &sp) {
1060   if (sp) {
1061     lldb::TargetSP target_sp(sp->GetTargetSP());
1062     if (target_sp) {
1063       lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
1064       bool use_synthetic =
1065           target_sp->TargetProperties::GetEnableSyntheticValue();
1066       m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
1067     } else
1068       m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, true));
1069   } else
1070     m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, false));
1071 }
1072 
1073 void SBValue::SetSP(const lldb::ValueObjectSP &sp,
1074                     lldb::DynamicValueType use_dynamic) {
1075   if (sp) {
1076     lldb::TargetSP target_sp(sp->GetTargetSP());
1077     if (target_sp) {
1078       bool use_synthetic =
1079           target_sp->TargetProperties::GetEnableSyntheticValue();
1080       SetSP(sp, use_dynamic, use_synthetic);
1081     } else
1082       SetSP(sp, use_dynamic, true);
1083   } else
1084     SetSP(sp, use_dynamic, false);
1085 }
1086 
1087 void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) {
1088   if (sp) {
1089     lldb::TargetSP target_sp(sp->GetTargetSP());
1090     if (target_sp) {
1091       lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
1092       SetSP(sp, use_dynamic, use_synthetic);
1093     } else
1094       SetSP(sp, eNoDynamicValues, use_synthetic);
1095   } else
1096     SetSP(sp, eNoDynamicValues, use_synthetic);
1097 }
1098 
1099 void SBValue::SetSP(const lldb::ValueObjectSP &sp,
1100                     lldb::DynamicValueType use_dynamic, bool use_synthetic) {
1101   m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
1102 }
1103 
1104 void SBValue::SetSP(const lldb::ValueObjectSP &sp,
1105                     lldb::DynamicValueType use_dynamic, bool use_synthetic,
1106                     const char *name) {
1107   m_opaque_sp =
1108       ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name));
1109 }
1110 
1111 bool SBValue::GetExpressionPath(SBStream &description) {
1112   LLDB_INSTRUMENT_VA(this, description);
1113 
1114   ValueLocker locker;
1115   lldb::ValueObjectSP value_sp(GetSP(locker));
1116   if (value_sp) {
1117     value_sp->GetExpressionPath(description.ref());
1118     return true;
1119   }
1120   return false;
1121 }
1122 
1123 bool SBValue::GetExpressionPath(SBStream &description,
1124                                 bool qualify_cxx_base_classes) {
1125   LLDB_INSTRUMENT_VA(this, description, qualify_cxx_base_classes);
1126 
1127   ValueLocker locker;
1128   lldb::ValueObjectSP value_sp(GetSP(locker));
1129   if (value_sp) {
1130     value_sp->GetExpressionPath(description.ref());
1131     return true;
1132   }
1133   return false;
1134 }
1135 
1136 lldb::SBValue SBValue::EvaluateExpression(const char *expr) const {
1137   LLDB_INSTRUMENT_VA(this, expr);
1138 
1139   ValueLocker locker;
1140   lldb::ValueObjectSP value_sp(GetSP(locker));
1141   if (!value_sp)
1142     return SBValue();
1143 
1144   lldb::TargetSP target_sp = value_sp->GetTargetSP();
1145   if (!target_sp)
1146     return SBValue();
1147 
1148   lldb::SBExpressionOptions options;
1149   options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
1150   options.SetUnwindOnError(true);
1151   options.SetIgnoreBreakpoints(true);
1152 
1153   return EvaluateExpression(expr, options, nullptr);
1154 }
1155 
1156 lldb::SBValue
1157 SBValue::EvaluateExpression(const char *expr,
1158                             const SBExpressionOptions &options) const {
1159   LLDB_INSTRUMENT_VA(this, expr, options);
1160 
1161   return EvaluateExpression(expr, options, nullptr);
1162 }
1163 
1164 lldb::SBValue SBValue::EvaluateExpression(const char *expr,
1165                                           const SBExpressionOptions &options,
1166                                           const char *name) const {
1167   LLDB_INSTRUMENT_VA(this, expr, options, name);
1168 
1169   if (!expr || expr[0] == '\0') {
1170     return SBValue();
1171   }
1172 
1173 
1174   ValueLocker locker;
1175   lldb::ValueObjectSP value_sp(GetSP(locker));
1176   if (!value_sp) {
1177     return SBValue();
1178   }
1179 
1180   lldb::TargetSP target_sp = value_sp->GetTargetSP();
1181   if (!target_sp) {
1182     return SBValue();
1183   }
1184 
1185   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1186   ExecutionContext exe_ctx(target_sp.get());
1187 
1188   StackFrame *frame = exe_ctx.GetFramePtr();
1189   if (!frame) {
1190     return SBValue();
1191   }
1192 
1193   ValueObjectSP res_val_sp;
1194   target_sp->EvaluateExpression(expr, frame, res_val_sp, options.ref(), nullptr,
1195                                 value_sp.get());
1196 
1197   if (name)
1198     res_val_sp->SetName(ConstString(name));
1199 
1200   SBValue result;
1201   result.SetSP(res_val_sp, options.GetFetchDynamicValue());
1202   return result;
1203 }
1204 
1205 bool SBValue::GetDescription(SBStream &description) {
1206   LLDB_INSTRUMENT_VA(this, description);
1207 
1208   Stream &strm = description.ref();
1209 
1210   ValueLocker locker;
1211   lldb::ValueObjectSP value_sp(GetSP(locker));
1212   if (value_sp)
1213     value_sp->Dump(strm);
1214   else
1215     strm.PutCString("No value");
1216 
1217   return true;
1218 }
1219 
1220 lldb::Format SBValue::GetFormat() {
1221   LLDB_INSTRUMENT_VA(this);
1222 
1223   ValueLocker locker;
1224   lldb::ValueObjectSP value_sp(GetSP(locker));
1225   if (value_sp)
1226     return value_sp->GetFormat();
1227   return eFormatDefault;
1228 }
1229 
1230 void SBValue::SetFormat(lldb::Format format) {
1231   LLDB_INSTRUMENT_VA(this, format);
1232 
1233   ValueLocker locker;
1234   lldb::ValueObjectSP value_sp(GetSP(locker));
1235   if (value_sp)
1236     value_sp->SetFormat(format);
1237 }
1238 
1239 lldb::SBValue SBValue::AddressOf() {
1240   LLDB_INSTRUMENT_VA(this);
1241 
1242   SBValue sb_value;
1243   ValueLocker locker;
1244   lldb::ValueObjectSP value_sp(GetSP(locker));
1245   if (value_sp) {
1246     Status error;
1247     sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
1248                    GetPreferSyntheticValue());
1249   }
1250 
1251   return sb_value;
1252 }
1253 
1254 lldb::addr_t SBValue::GetLoadAddress() {
1255   LLDB_INSTRUMENT_VA(this);
1256 
1257   lldb::addr_t value = LLDB_INVALID_ADDRESS;
1258   ValueLocker locker;
1259   lldb::ValueObjectSP value_sp(GetSP(locker));
1260   if (value_sp) {
1261     TargetSP target_sp(value_sp->GetTargetSP());
1262     if (target_sp) {
1263       const bool scalar_is_load_address = true;
1264       AddressType addr_type;
1265       value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1266       if (addr_type == eAddressTypeFile) {
1267         ModuleSP module_sp(value_sp->GetModule());
1268         if (!module_sp)
1269           value = LLDB_INVALID_ADDRESS;
1270         else {
1271           Address addr;
1272           module_sp->ResolveFileAddress(value, addr);
1273           value = addr.GetLoadAddress(target_sp.get());
1274         }
1275       } else if (addr_type == eAddressTypeHost ||
1276                  addr_type == eAddressTypeInvalid)
1277         value = LLDB_INVALID_ADDRESS;
1278     }
1279   }
1280 
1281   return value;
1282 }
1283 
1284 lldb::SBAddress SBValue::GetAddress() {
1285   LLDB_INSTRUMENT_VA(this);
1286 
1287   Address addr;
1288   ValueLocker locker;
1289   lldb::ValueObjectSP value_sp(GetSP(locker));
1290   if (value_sp) {
1291     TargetSP target_sp(value_sp->GetTargetSP());
1292     if (target_sp) {
1293       lldb::addr_t value = LLDB_INVALID_ADDRESS;
1294       const bool scalar_is_load_address = true;
1295       AddressType addr_type;
1296       value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1297       if (addr_type == eAddressTypeFile) {
1298         ModuleSP module_sp(value_sp->GetModule());
1299         if (module_sp)
1300           module_sp->ResolveFileAddress(value, addr);
1301       } else if (addr_type == eAddressTypeLoad) {
1302         // no need to check the return value on this.. if it can actually do
1303         // the resolve addr will be in the form (section,offset), otherwise it
1304         // will simply be returned as (NULL, value)
1305         addr.SetLoadAddress(value, target_sp.get());
1306       }
1307     }
1308   }
1309 
1310   return SBAddress(addr);
1311 }
1312 
1313 lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
1314   LLDB_INSTRUMENT_VA(this, item_idx, item_count);
1315 
1316   lldb::SBData sb_data;
1317   ValueLocker locker;
1318   lldb::ValueObjectSP value_sp(GetSP(locker));
1319   if (value_sp) {
1320     TargetSP target_sp(value_sp->GetTargetSP());
1321     if (target_sp) {
1322       DataExtractorSP data_sp(new DataExtractor());
1323       value_sp->GetPointeeData(*data_sp, item_idx, item_count);
1324       if (data_sp->GetByteSize() > 0)
1325         *sb_data = data_sp;
1326     }
1327   }
1328 
1329   return sb_data;
1330 }
1331 
1332 lldb::SBData SBValue::GetData() {
1333   LLDB_INSTRUMENT_VA(this);
1334 
1335   lldb::SBData sb_data;
1336   ValueLocker locker;
1337   lldb::ValueObjectSP value_sp(GetSP(locker));
1338   if (value_sp) {
1339     DataExtractorSP data_sp(new DataExtractor());
1340     Status error;
1341     value_sp->GetData(*data_sp, error);
1342     if (error.Success())
1343       *sb_data = data_sp;
1344   }
1345 
1346   return sb_data;
1347 }
1348 
1349 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
1350   LLDB_INSTRUMENT_VA(this, data, error);
1351 
1352   ValueLocker locker;
1353   lldb::ValueObjectSP value_sp(GetSP(locker));
1354   bool ret = true;
1355 
1356   if (value_sp) {
1357     DataExtractor *data_extractor = data.get();
1358 
1359     if (!data_extractor) {
1360       error.SetErrorString("No data to set");
1361       ret = false;
1362     } else {
1363       Status set_error;
1364 
1365       value_sp->SetData(*data_extractor, set_error);
1366 
1367       if (!set_error.Success()) {
1368         error.SetErrorStringWithFormat("Couldn't set data: %s",
1369                                        set_error.AsCString());
1370         ret = false;
1371       }
1372     }
1373   } else {
1374     error.SetErrorStringWithFormat(
1375         "Couldn't set data: could not get SBValue: %s",
1376         locker.GetError().AsCString());
1377     ret = false;
1378   }
1379 
1380   return ret;
1381 }
1382 
1383 lldb::SBValue SBValue::Clone(const char *new_name) {
1384   LLDB_INSTRUMENT_VA(this, new_name);
1385 
1386   ValueLocker locker;
1387   lldb::ValueObjectSP value_sp(GetSP(locker));
1388 
1389   if (value_sp)
1390     return lldb::SBValue(value_sp->Clone(ConstString(new_name)));
1391   else
1392     return lldb::SBValue();
1393 }
1394 
1395 lldb::SBDeclaration SBValue::GetDeclaration() {
1396   LLDB_INSTRUMENT_VA(this);
1397 
1398   ValueLocker locker;
1399   lldb::ValueObjectSP value_sp(GetSP(locker));
1400   SBDeclaration decl_sb;
1401   if (value_sp) {
1402     Declaration decl;
1403     if (value_sp->GetDeclaration(decl))
1404       decl_sb.SetDeclaration(decl);
1405   }
1406   return decl_sb;
1407 }
1408 
1409 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
1410                                   SBError &error) {
1411   LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
1412 
1413   SBWatchpoint sb_watchpoint;
1414 
1415   // If the SBValue is not valid, there's no point in even trying to watch it.
1416   ValueLocker locker;
1417   lldb::ValueObjectSP value_sp(GetSP(locker));
1418   TargetSP target_sp(GetTarget().GetSP());
1419   if (value_sp && target_sp) {
1420     // Read and Write cannot both be false.
1421     if (!read && !write)
1422       return sb_watchpoint;
1423 
1424     // If the value is not in scope, don't try and watch and invalid value
1425     if (!IsInScope())
1426       return sb_watchpoint;
1427 
1428     addr_t addr = GetLoadAddress();
1429     if (addr == LLDB_INVALID_ADDRESS)
1430       return sb_watchpoint;
1431     size_t byte_size = GetByteSize();
1432     if (byte_size == 0)
1433       return sb_watchpoint;
1434 
1435     uint32_t watch_type = 0;
1436     if (read) {
1437       watch_type |= LLDB_WATCH_TYPE_READ;
1438       // read + write, the most likely intention
1439       // is to catch all writes to this, not just
1440       // value modifications.
1441       if (write)
1442         watch_type |= LLDB_WATCH_TYPE_WRITE;
1443     } else {
1444       if (write)
1445         watch_type |= LLDB_WATCH_TYPE_MODIFY;
1446     }
1447 
1448     Status rc;
1449     CompilerType type(value_sp->GetCompilerType());
1450     WatchpointSP watchpoint_sp =
1451         target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
1452     error.SetError(rc);
1453 
1454     if (watchpoint_sp) {
1455       sb_watchpoint.SetSP(watchpoint_sp);
1456       Declaration decl;
1457       if (value_sp->GetDeclaration(decl)) {
1458         if (decl.GetFile()) {
1459           StreamString ss;
1460           // True to show fullpath for declaration file.
1461           decl.DumpStopContext(&ss, true);
1462           watchpoint_sp->SetDeclInfo(std::string(ss.GetString()));
1463         }
1464       }
1465     }
1466   } else if (target_sp) {
1467     error.SetErrorStringWithFormat("could not get SBValue: %s",
1468                                    locker.GetError().AsCString());
1469   } else {
1470     error.SetErrorString("could not set watchpoint, a target is required");
1471   }
1472 
1473   return sb_watchpoint;
1474 }
1475 
1476 // FIXME: Remove this method impl (as well as the decl in .h) once it is no
1477 // longer needed.
1478 // Backward compatibility fix in the interim.
1479 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
1480                                   bool write) {
1481   LLDB_INSTRUMENT_VA(this, resolve_location, read, write);
1482 
1483   SBError error;
1484   return Watch(resolve_location, read, write, error);
1485 }
1486 
1487 lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
1488                                          bool write, SBError &error) {
1489   LLDB_INSTRUMENT_VA(this, resolve_location, read, write, error);
1490 
1491   SBWatchpoint sb_watchpoint;
1492   if (IsInScope() && GetType().IsPointerType())
1493     sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
1494   return sb_watchpoint;
1495 }
1496 
1497 lldb::SBValue SBValue::Persist() {
1498   LLDB_INSTRUMENT_VA(this);
1499 
1500   ValueLocker locker;
1501   lldb::ValueObjectSP value_sp(GetSP(locker));
1502   SBValue persisted_sb;
1503   if (value_sp) {
1504     persisted_sb.SetSP(value_sp->Persist());
1505   }
1506   return persisted_sb;
1507 }
1508 
1509 lldb::SBValue SBValue::GetVTable() {
1510   SBValue vtable_sb;
1511   ValueLocker locker;
1512   lldb::ValueObjectSP value_sp(GetSP(locker));
1513   if (!value_sp)
1514     return vtable_sb;
1515 
1516   vtable_sb.SetSP(value_sp->GetVTable());
1517   return vtable_sb;
1518 }
1519