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