1 //===-- SBValue.cpp ---------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/API/SBValue.h"
11 #include "lldb/API/SBStream.h"
12 
13 #include "lldb/Core/DataExtractor.h"
14 #include "lldb/Core/Log.h"
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/Scalar.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Core/ValueObject.h"
21 #include "lldb/Core/ValueObjectConstResult.h"
22 #include "lldb/Symbol/Block.h"
23 #include "lldb/Symbol/ObjectFile.h"
24 #include "lldb/Symbol/Variable.h"
25 #include "lldb/Target/ExecutionContext.h"
26 #include "lldb/Target/Process.h"
27 #include "lldb/Target/StackFrame.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Target/Thread.h"
30 
31 #include "lldb/API/SBProcess.h"
32 #include "lldb/API/SBTarget.h"
33 #include "lldb/API/SBThread.h"
34 #include "lldb/API/SBFrame.h"
35 #include "lldb/API/SBDebugger.h"
36 
37 using namespace lldb;
38 using namespace lldb_private;
39 
40 SBValue::SBValue () :
41     m_opaque_sp ()
42 {
43 }
44 
45 SBValue::SBValue (const lldb::ValueObjectSP &value_sp) :
46     m_opaque_sp (value_sp)
47 {
48 }
49 
50 SBValue::SBValue(const SBValue &rhs) :
51     m_opaque_sp (rhs.m_opaque_sp)
52 {
53 }
54 
55 const SBValue &
56 SBValue::operator = (const SBValue &rhs)
57 {
58     if (this != &rhs)
59         m_opaque_sp = rhs.m_opaque_sp;
60     return *this;
61 }
62 
63 SBValue::~SBValue()
64 {
65 }
66 
67 bool
68 SBValue::IsValid () const
69 {
70     // If this function ever changes to anything that does more than just
71     // check if the opaque shared pointer is non NULL, then we need to update
72     // all "if (m_opaque_sp)" code in this file.
73     return m_opaque_sp.get() != NULL;
74 }
75 
76 SBError
77 SBValue::GetError()
78 {
79     SBError sb_error;
80 
81     if (m_opaque_sp.get())
82         sb_error.SetError(m_opaque_sp->GetError());
83 
84     return sb_error;
85 }
86 
87 user_id_t
88 SBValue::GetID()
89 {
90     if (m_opaque_sp)
91         return m_opaque_sp->GetID();
92     return LLDB_INVALID_UID;
93 }
94 
95 const char *
96 SBValue::GetName()
97 {
98 
99     const char *name = NULL;
100     if (m_opaque_sp)
101         name = m_opaque_sp->GetName().GetCString();
102 
103     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
104     if (log)
105     {
106         if (name)
107             log->Printf ("SBValue(%p)::GetName () => \"%s\"", m_opaque_sp.get(), name);
108         else
109             log->Printf ("SBValue(%p)::GetName () => NULL", m_opaque_sp.get(), name);
110     }
111 
112     return name;
113 }
114 
115 const char *
116 SBValue::GetTypeName ()
117 {
118     const char *name = NULL;
119     if (m_opaque_sp)
120         name = m_opaque_sp->GetTypeName().GetCString();
121     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
122     if (log)
123     {
124         if (name)
125             log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", m_opaque_sp.get(), name);
126         else
127             log->Printf ("SBValue(%p)::GetTypeName () => NULL", m_opaque_sp.get());
128     }
129 
130     return name;
131 }
132 
133 size_t
134 SBValue::GetByteSize ()
135 {
136     size_t result = 0;
137 
138     if (m_opaque_sp)
139         result = m_opaque_sp->GetByteSize();
140 
141     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
142     if (log)
143         log->Printf ("SBValue(%p)::GetByteSize () => %zu", m_opaque_sp.get(), result);
144 
145     return result;
146 }
147 
148 bool
149 SBValue::IsInScope (const SBFrame &sb_frame)
150 {
151     return IsInScope();
152 }
153 
154 bool
155 SBValue::IsInScope ()
156 {
157     bool result = false;
158 
159     if (m_opaque_sp)
160     {
161         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
162         {
163             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
164             result = m_opaque_sp->IsInScope ();
165         }
166     }
167 
168     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
169     if (log)
170         log->Printf ("SBValue(%p)::IsInScope () => %i", m_opaque_sp.get(), result);
171 
172     return result;
173 }
174 
175 const char *
176 SBValue::GetValue (const SBFrame &sb_frame)
177 {
178     return GetValue();
179 }
180 
181 const char *
182 SBValue::GetValue ()
183 {
184     const char *cstr = NULL;
185     if (m_opaque_sp)
186     {
187         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
188         {
189             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
190             cstr = m_opaque_sp->GetValueAsCString ();
191         }
192     }
193     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
194     if (log)
195     {
196         if (cstr)
197             log->Printf ("SBValue(%p)::GetValue => \"%s\"", m_opaque_sp.get(), cstr);
198         else
199             log->Printf ("SBValue(%p)::GetValue => NULL", m_opaque_sp.get());
200     }
201 
202     return cstr;
203 }
204 
205 ValueType
206 SBValue::GetValueType ()
207 {
208     ValueType result = eValueTypeInvalid;
209     if (m_opaque_sp)
210         result = m_opaque_sp->GetValueType();
211     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
212     if (log)
213     {
214         switch (result)
215         {
216         case eValueTypeInvalid:         log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", m_opaque_sp.get()); break;
217         case eValueTypeVariableGlobal:  log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", m_opaque_sp.get()); break;
218         case eValueTypeVariableStatic:  log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", m_opaque_sp.get()); break;
219         case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", m_opaque_sp.get()); break;
220         case eValueTypeVariableLocal:   log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", m_opaque_sp.get()); break;
221         case eValueTypeRegister:        log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", m_opaque_sp.get()); break;
222         case eValueTypeRegisterSet:     log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", m_opaque_sp.get()); break;
223         case eValueTypeConstResult:     log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", m_opaque_sp.get()); break;
224         default:     log->Printf ("SBValue(%p)::GetValueType () => %i ???", m_opaque_sp.get(), result); break;
225         }
226     }
227     return result;
228 }
229 
230 const char *
231 SBValue::GetObjectDescription (const SBFrame &sb_frame)
232 {
233     return GetObjectDescription ();
234 }
235 
236 const char *
237 SBValue::GetObjectDescription ()
238 {
239     const char *cstr = NULL;
240     if (m_opaque_sp)
241     {
242         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
243         {
244             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
245             cstr = m_opaque_sp->GetObjectDescription ();
246         }
247     }
248     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
249     if (log)
250     {
251         if (cstr)
252             log->Printf ("SBValue(%p)::GetObjectDescription => \"%s\"", m_opaque_sp.get(), cstr);
253         else
254             log->Printf ("SBValue(%p)::GetObjectDescription => NULL", m_opaque_sp.get());
255     }
256     return cstr;
257 }
258 
259 bool
260 SBValue::GetValueDidChange (const SBFrame &sb_frame)
261 {
262     return GetValueDidChange ();
263 }
264 
265 SBType
266 SBValue::GetType()
267 {
268     SBType result;
269     if (m_opaque_sp)
270     {
271         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
272         {
273             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
274             result = SBType(ClangASTType (m_opaque_sp->GetClangAST(), m_opaque_sp->GetClangType()));
275         }
276     }
277     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
278     if (log)
279     {
280         if (result.IsValid())
281             log->Printf ("SBValue(%p)::GetType => %p", m_opaque_sp.get(), &result);
282         else
283             log->Printf ("SBValue(%p)::GetType => NULL", m_opaque_sp.get());
284     }
285     return result;
286 }
287 
288 bool
289 SBValue::GetValueDidChange ()
290 {
291     bool result = false;
292     if (m_opaque_sp)
293     {
294         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
295         {
296             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
297             result = m_opaque_sp->GetValueDidChange ();
298         }
299     }
300     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
301     if (log)
302         log->Printf ("SBValue(%p)::GetValueDidChange => %i", m_opaque_sp.get(), result);
303 
304     return result;
305 }
306 
307 const char *
308 SBValue::GetSummary (const SBFrame &sb_frame)
309 {
310     return GetSummary ();
311 }
312 
313 const char *
314 SBValue::GetSummary ()
315 {
316     const char *cstr = NULL;
317     if (m_opaque_sp)
318     {
319         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
320         {
321             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
322             cstr = m_opaque_sp->GetSummaryAsCString();
323         }
324     }
325     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
326     if (log)
327     {
328         if (cstr)
329             log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr);
330         else
331             log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get());
332     }
333     return cstr;
334 }
335 
336 const char *
337 SBValue::GetLocation (const SBFrame &sb_frame)
338 {
339     return GetLocation ();
340 }
341 
342 const char *
343 SBValue::GetLocation ()
344 {
345     const char *cstr = NULL;
346     if (m_opaque_sp)
347     {
348         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
349         {
350             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
351             cstr = m_opaque_sp->GetLocationAsCString();
352         }
353     }
354     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
355     if (log)
356     {
357         if (cstr)
358             log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr);
359         else
360             log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get());
361     }
362     return cstr;
363 }
364 
365 bool
366 SBValue::SetValueFromCString (const SBFrame &sb_frame, const char *value_str)
367 {
368     return SetValueFromCString (value_str);
369 }
370 
371 bool
372 SBValue::SetValueFromCString (const char *value_str)
373 {
374     bool success = false;
375     if (m_opaque_sp)
376     {
377         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
378         {
379             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
380             success = m_opaque_sp->SetValueFromCString (value_str);
381         }
382     }
383     return success;
384 }
385 
386 lldb::SBValue
387 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, const SBType& type)
388 {
389     lldb::SBValue result;
390     if (m_opaque_sp)
391     {
392         if (type.IsValid())
393         {
394             result = SBValue(m_opaque_sp->GetSyntheticChildAtOffset(offset, type.m_opaque_sp->GetClangASTType(), true));
395             result.m_opaque_sp->SetName(ConstString(name));
396         }
397     }
398     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
399     if (log)
400     {
401         if (result.IsValid())
402             log->Printf ("SBValue(%p)::GetChildAtOffset => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp.get());
403         else
404             log->Printf ("SBValue(%p)::GetChildAtOffset => NULL", m_opaque_sp.get());
405     }
406     return result;
407 }
408 
409 lldb::SBValue
410 SBValue::Cast(const SBType& type)
411 {
412     return CreateChildAtOffset(m_opaque_sp->GetName().GetCString(), 0, type);
413 }
414 
415 lldb::SBValue
416 SBValue::CreateValueFromExpression (const char *name, const char* expression)
417 {
418     lldb::SBValue result;
419     if (m_opaque_sp)
420     {
421         ValueObjectSP result_valobj_sp;
422         m_opaque_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression(expression,
423                                                                       m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame(),
424                                                                       true, true, eNoDynamicValues,
425                                                                       result_valobj_sp);
426         result_valobj_sp->SetName(ConstString(name));
427         result = SBValue(result_valobj_sp);
428     }
429     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
430     if (log)
431     {
432         if (result.IsValid())
433             log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp.get());
434         else
435             log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get());
436     }
437     return result;
438 }
439 
440 lldb::SBValue
441 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type)
442 {
443     lldb::SBValue result;
444     if (m_opaque_sp)
445     {
446 
447         SBType real_type(type.GetPointerType());
448 
449         lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
450 
451         ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope(),
452                                                                           real_type.m_opaque_sp->GetASTContext(),
453                                                                           real_type.m_opaque_sp->GetOpaqueQualType(),
454                                                                           ConstString(name),
455                                                                           buffer,
456                                                                           lldb::endian::InlHostByteOrder(),
457                                                                           GetTarget().GetProcess().GetAddressByteSize()));
458 
459         ValueObjectSP result_valobj_sp;
460 
461         ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
462         if (ptr_result_valobj_sp)
463         {
464             Error err;
465             result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
466             if (result_valobj_sp)
467                 result_valobj_sp->SetName(ConstString(name));
468         }
469         result = SBValue(result_valobj_sp);
470     }
471     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
472     if (log)
473     {
474         if (result.IsValid())
475             log->Printf ("SBValue(%p)::GetChildFromAddress => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp.get());
476         else
477             log->Printf ("SBValue(%p)::GetChildFromAddress => NULL", m_opaque_sp.get());
478     }
479     return result;
480 }
481 
482 SBValue
483 SBValue::GetChildAtIndex (uint32_t idx)
484 {
485     const bool can_create_synthetic = false;
486     lldb::DynamicValueType use_dynamic = eNoDynamicValues;
487     if (m_opaque_sp)
488         use_dynamic = m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue();
489     return GetChildAtIndex (idx, use_dynamic, can_create_synthetic);
490 }
491 
492 SBValue
493 SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic)
494 {
495     lldb::ValueObjectSP child_sp;
496 
497     if (m_opaque_sp)
498     {
499         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
500         {
501             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
502             const bool can_create = true;
503             child_sp = m_opaque_sp->GetChildAtIndex (idx, can_create);
504             if (can_create_synthetic && !child_sp)
505             {
506                 if (m_opaque_sp->IsPointerType())
507                 {
508                     child_sp = m_opaque_sp->GetSyntheticArrayMemberFromPointer(idx, can_create);
509                 }
510                 else if (m_opaque_sp->IsArrayType())
511                 {
512                     child_sp = m_opaque_sp->GetSyntheticArrayMemberFromArray(idx, can_create);
513                 }
514             }
515 
516             if (child_sp)
517             {
518                 if (use_dynamic != lldb::eNoDynamicValues)
519                 {
520                     lldb::ValueObjectSP dynamic_sp(child_sp->GetDynamicValue (use_dynamic));
521                     if (dynamic_sp)
522                         child_sp = dynamic_sp;
523                 }
524             }
525         }
526     }
527 
528     SBValue sb_value (child_sp);
529     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
530     if (log)
531         log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", m_opaque_sp.get(), idx, sb_value.get());
532 
533     return sb_value;
534 }
535 
536 uint32_t
537 SBValue::GetIndexOfChildWithName (const char *name)
538 {
539     uint32_t idx = UINT32_MAX;
540     if (m_opaque_sp)
541     {
542         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
543         {
544             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
545 
546             idx = m_opaque_sp->GetIndexOfChildWithName (ConstString(name));
547         }
548     }
549     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
550     if (log)
551     {
552         if (idx == UINT32_MAX)
553             log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", m_opaque_sp.get(), name, idx);
554         else
555             log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", m_opaque_sp.get(), name, idx);
556     }
557     return idx;
558 }
559 
560 SBValue
561 SBValue::GetChildMemberWithName (const char *name)
562 {
563     if (m_opaque_sp)
564     {
565         lldb::DynamicValueType use_dynamic_value = m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue();
566         return GetChildMemberWithName (name, use_dynamic_value);
567     }
568     else
569         return GetChildMemberWithName (name, eNoDynamicValues);
570 }
571 
572 SBValue
573 SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value)
574 {
575     lldb::ValueObjectSP child_sp;
576     const ConstString str_name (name);
577 
578 
579     if (m_opaque_sp)
580     {
581         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
582         {
583             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
584             child_sp = m_opaque_sp->GetChildMemberWithName (str_name, true);
585             if (use_dynamic_value != lldb::eNoDynamicValues)
586             {
587                 if (child_sp)
588                 {
589                     lldb::ValueObjectSP dynamic_sp = child_sp->GetDynamicValue (use_dynamic_value);
590                     if (dynamic_sp)
591                         child_sp = dynamic_sp;
592                 }
593             }
594         }
595     }
596 
597     SBValue sb_value (child_sp);
598 
599     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
600     if (log)
601         log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", m_opaque_sp.get(), name, sb_value.get());
602 
603     return sb_value;
604 }
605 
606 lldb::SBValue
607 SBValue::GetValueForExpressionPath(const char* expr_path)
608 {
609     lldb::ValueObjectSP child_sp;
610     if (m_opaque_sp)
611     {
612         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
613         {
614             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
615             // using default values for all the fancy options, just do it if you can
616             child_sp = m_opaque_sp->GetValueForExpressionPath(expr_path);
617         }
618     }
619 
620     SBValue sb_value (child_sp);
621 
622     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
623     if (log)
624         log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", m_opaque_sp.get(), expr_path, sb_value.get());
625 
626     return sb_value;
627 }
628 
629 int64_t
630 SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
631 {
632     if (m_opaque_sp)
633     {
634         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
635         {
636             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
637             Scalar scalar;
638             if (m_opaque_sp->ResolveValue (scalar))
639                 return scalar.GetRawBits64(fail_value);
640             else
641                 error.SetErrorString("could not get value");
642         }
643         else
644             error.SetErrorString("could not get target");
645     }
646     error.SetErrorString("invalid SBValue");
647     return fail_value;
648 }
649 
650 uint64_t
651 SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
652 {
653     if (m_opaque_sp)
654     {
655         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
656         {
657             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
658             Scalar scalar;
659             if (m_opaque_sp->ResolveValue (scalar))
660                 return scalar.GetRawBits64(fail_value);
661             else
662                 error.SetErrorString("could not get value");
663         }
664         else
665             error.SetErrorString("could not get target");
666     }
667     error.SetErrorString("invalid SBValue");
668     return fail_value;
669 }
670 
671 int64_t
672 SBValue::GetValueAsSigned(int64_t fail_value)
673 {
674     if (m_opaque_sp)
675     {
676         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
677         {
678             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
679             Scalar scalar;
680             if (m_opaque_sp->ResolveValue (scalar))
681                 return scalar.GetRawBits64(fail_value);
682         }
683     }
684     return fail_value;
685 }
686 
687 uint64_t
688 SBValue::GetValueAsUnsigned(uint64_t fail_value)
689 {
690     if (m_opaque_sp)
691     {
692         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
693         {
694             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
695             Scalar scalar;
696             if (m_opaque_sp->ResolveValue (scalar))
697                 return scalar.GetRawBits64(fail_value);
698         }
699     }
700     return fail_value;
701 }
702 
703 uint32_t
704 SBValue::GetNumChildren ()
705 {
706     uint32_t num_children = 0;
707 
708     if (m_opaque_sp)
709     {
710         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
711         {
712             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
713 
714             num_children = m_opaque_sp->GetNumChildren();
715         }
716     }
717 
718     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
719     if (log)
720         log->Printf ("SBValue(%p)::GetNumChildren () => %u", m_opaque_sp.get(), num_children);
721 
722     return num_children;
723 }
724 
725 
726 SBValue
727 SBValue::Dereference ()
728 {
729     SBValue sb_value;
730     if (m_opaque_sp)
731     {
732         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
733         {
734             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
735 
736             Error error;
737             sb_value = m_opaque_sp->Dereference (error);
738         }
739     }
740     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
741     if (log)
742         log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", m_opaque_sp.get(), sb_value.get());
743 
744     return sb_value;
745 }
746 
747 bool
748 SBValue::TypeIsPointerType ()
749 {
750     bool is_ptr_type = false;
751 
752     if (m_opaque_sp)
753     {
754         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
755         {
756             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
757 
758             is_ptr_type = m_opaque_sp->IsPointerType();
759         }
760     }
761 
762     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
763     if (log)
764         log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", m_opaque_sp.get(), is_ptr_type);
765 
766 
767     return is_ptr_type;
768 }
769 
770 void *
771 SBValue::GetOpaqueType()
772 {
773     if (m_opaque_sp)
774     {
775         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
776         {
777             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
778 
779             return m_opaque_sp->GetClangType();
780         }
781     }
782     return NULL;
783 }
784 
785 lldb::SBTarget
786 SBValue::GetTarget()
787 {
788     SBTarget result;
789     if (m_opaque_sp)
790     {
791         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
792         {
793             result = SBTarget(lldb::TargetSP(m_opaque_sp->GetUpdatePoint().GetTargetSP()));
794         }
795     }
796     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
797     if (log)
798     {
799         if (result.get() == NULL)
800             log->Printf ("SBValue(%p)::GetTarget () => NULL", m_opaque_sp.get());
801         else
802             log->Printf ("SBValue(%p)::GetTarget () => %p", m_opaque_sp.get(), result.get());
803     }
804     return result;
805 }
806 
807 lldb::SBProcess
808 SBValue::GetProcess()
809 {
810     SBProcess result;
811     if (m_opaque_sp)
812     {
813         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
814         {
815             result = SBProcess(lldb::ProcessSP(m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetProcessSP()));
816         }
817     }
818     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
819     if (log)
820     {
821         if (result.get() == NULL)
822             log->Printf ("SBValue(%p)::GetProcess () => NULL", m_opaque_sp.get());
823         else
824             log->Printf ("SBValue(%p)::GetProcess () => %p", m_opaque_sp.get(), result.get());
825     }
826     return result;
827 }
828 
829 lldb::SBThread
830 SBValue::GetThread()
831 {
832     SBThread result;
833     if (m_opaque_sp)
834     {
835         if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope())
836         {
837             result = SBThread(lldb::ThreadSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateThread()));
838         }
839     }
840     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
841     if (log)
842     {
843         if (result.get() == NULL)
844             log->Printf ("SBValue(%p)::GetThread () => NULL", m_opaque_sp.get());
845         else
846             log->Printf ("SBValue(%p)::GetThread () => %p", m_opaque_sp.get(), result.get());
847     }
848     return result;
849 }
850 
851 lldb::SBFrame
852 SBValue::GetFrame()
853 {
854     SBFrame result;
855     if (m_opaque_sp)
856     {
857         if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope())
858         {
859             result = SBFrame(lldb::StackFrameSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame()));
860         }
861     }
862     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
863     if (log)
864     {
865         if (result.get() == NULL)
866             log->Printf ("SBValue(%p)::GetFrame () => NULL", m_opaque_sp.get());
867         else
868             log->Printf ("SBValue(%p)::GetFrame () => %p", m_opaque_sp.get(), result.get());
869     }
870     return result;
871 }
872 
873 
874 // Mimic shared pointer...
875 lldb_private::ValueObject *
876 SBValue::get() const
877 {
878     return m_opaque_sp.get();
879 }
880 
881 lldb_private::ValueObject *
882 SBValue::operator->() const
883 {
884     return m_opaque_sp.get();
885 }
886 
887 lldb::ValueObjectSP &
888 SBValue::operator*()
889 {
890     return m_opaque_sp;
891 }
892 
893 const lldb::ValueObjectSP &
894 SBValue::operator*() const
895 {
896     return m_opaque_sp;
897 }
898 
899 bool
900 SBValue::GetExpressionPath (SBStream &description)
901 {
902     if (m_opaque_sp)
903     {
904         m_opaque_sp->GetExpressionPath (description.ref(), false);
905         return true;
906     }
907     return false;
908 }
909 
910 bool
911 SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
912 {
913     if (m_opaque_sp)
914     {
915         m_opaque_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
916         return true;
917     }
918     return false;
919 }
920 
921 bool
922 SBValue::GetDescription (SBStream &description)
923 {
924     if (m_opaque_sp)
925     {
926         uint32_t ptr_depth = 0;
927         uint32_t curr_depth = 0;
928         uint32_t max_depth = UINT32_MAX;
929         bool show_types = false;
930         bool show_location = false;
931         bool use_objc = false;
932         lldb::DynamicValueType use_dynamic = eNoDynamicValues;
933         bool scope_already_checked = false;
934         bool flat_output = false;
935         bool use_synthetic = true;
936         uint32_t no_summary_depth = 0;
937         bool ignore_cap = false;
938         ValueObject::DumpValueObject (description.ref(),
939                                       m_opaque_sp.get(),
940                                       m_opaque_sp->GetName().GetCString(),
941                                       ptr_depth,
942                                       curr_depth,
943                                       max_depth,
944                                       show_types, show_location,
945                                       use_objc,
946                                       use_dynamic,
947                                       use_synthetic,
948                                       scope_already_checked,
949                                       flat_output,
950                                       no_summary_depth,
951                                       ignore_cap);
952     }
953     else
954         description.Printf ("No value");
955 
956     return true;
957 }
958 
959 lldb::Format
960 SBValue::GetFormat () const
961 {
962     if (m_opaque_sp)
963         return m_opaque_sp->GetFormat();
964     return eFormatDefault;
965 }
966 
967 void
968 SBValue::SetFormat (lldb::Format format)
969 {
970     if (m_opaque_sp)
971         m_opaque_sp->SetFormat(format);
972 }
973 
974 lldb::SBValue
975 SBValue::AddressOf()
976 {
977     SBValue sb_value;
978     if (m_opaque_sp)
979     {
980         if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
981         {
982             Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
983 
984             Error error;
985             sb_value = m_opaque_sp->AddressOf (error);
986         }
987     }
988     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
989     if (log)
990         log->Printf ("SBValue(%p)::GetPointerToObject () => SBValue(%p)", m_opaque_sp.get(), sb_value.get());
991 
992     return sb_value;
993 }
994