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