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