SBValue.cpp revision c48ca82920bd333c7ccb6ec0e579207add130296 
1//===-- SBValue.cpp ---------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/API/SBValue.h"
11
12#include "lldb/API/SBStream.h"
13#include "lldb/API/SBTypeFilter.h"
14#include "lldb/API/SBTypeFormat.h"
15#include "lldb/API/SBTypeSummary.h"
16#include "lldb/API/SBTypeSynthetic.h"
17
18#include "lldb/Breakpoint/Watchpoint.h"
19#include "lldb/Core/DataExtractor.h"
20#include "lldb/Core/DataVisualization.h"
21#include "lldb/Core/Log.h"
22#include "lldb/Core/Module.h"
23#include "lldb/Core/Scalar.h"
24#include "lldb/Core/Stream.h"
25#include "lldb/Core/StreamFile.h"
26#include "lldb/Core/Value.h"
27#include "lldb/Core/ValueObject.h"
28#include "lldb/Core/ValueObjectConstResult.h"
29#include "lldb/Symbol/Block.h"
30#include "lldb/Symbol/ObjectFile.h"
31#include "lldb/Symbol/Type.h"
32#include "lldb/Symbol/Variable.h"
33#include "lldb/Symbol/VariableList.h"
34#include "lldb/Target/ExecutionContext.h"
35#include "lldb/Target/Process.h"
36#include "lldb/Target/StackFrame.h"
37#include "lldb/Target/Target.h"
38#include "lldb/Target/Thread.h"
39
40#include "lldb/API/SBProcess.h"
41#include "lldb/API/SBTarget.h"
42#include "lldb/API/SBThread.h"
43#include "lldb/API/SBFrame.h"
44#include "lldb/API/SBDebugger.h"
45
46using namespace lldb;
47using namespace lldb_private;
48
49SBValue::SBValue () :
50    m_opaque_sp ()
51{
52}
53
54SBValue::SBValue (const lldb::ValueObjectSP &value_sp) :
55    m_opaque_sp (value_sp)
56{
57}
58
59SBValue::SBValue(const SBValue &rhs) :
60    m_opaque_sp (rhs.m_opaque_sp)
61{
62}
63
64SBValue &
65SBValue::operator = (const SBValue &rhs)
66{
67    if (this != &rhs)
68        m_opaque_sp = rhs.m_opaque_sp;
69    return *this;
70}
71
72SBValue::~SBValue()
73{
74}
75
76bool
77SBValue::IsValid ()
78{
79    // If this function ever changes to anything that does more than just
80    // check if the opaque shared pointer is non NULL, then we need to update
81    // all "if (m_opaque_sp)" code in this file.
82    return m_opaque_sp.get() != NULL;
83}
84
85void
86SBValue::Clear()
87{
88    m_opaque_sp.reset();
89}
90
91SBError
92SBValue::GetError()
93{
94    SBError sb_error;
95
96    lldb::ValueObjectSP value_sp(GetSP());
97    if (value_sp)
98        sb_error.SetError(value_sp->GetError());
99    else
100        sb_error.SetErrorString("error: invalid value");
101
102    return sb_error;
103}
104
105user_id_t
106SBValue::GetID()
107{
108    lldb::ValueObjectSP value_sp(GetSP());
109    if (value_sp)
110        return value_sp->GetID();
111    return LLDB_INVALID_UID;
112}
113
114const char *
115SBValue::GetName()
116{
117
118    const char *name = NULL;
119    lldb::ValueObjectSP value_sp(GetSP());
120    if (value_sp)
121        name = value_sp->GetName().GetCString();
122
123    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
124    if (log)
125    {
126        if (name)
127            log->Printf ("SBValue(%p)::GetName () => \"%s\"", value_sp.get(), name);
128        else
129            log->Printf ("SBValue(%p)::GetName () => NULL", value_sp.get());
130    }
131
132    return name;
133}
134
135const char *
136SBValue::GetTypeName ()
137{
138    const char *name = NULL;
139    lldb::ValueObjectSP value_sp(GetSP());
140    if (value_sp)
141        name = value_sp->GetTypeName().GetCString();
142    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
143    if (log)
144    {
145        if (name)
146            log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", value_sp.get(), name);
147        else
148            log->Printf ("SBValue(%p)::GetTypeName () => NULL", value_sp.get());
149    }
150
151    return name;
152}
153
154size_t
155SBValue::GetByteSize ()
156{
157    size_t result = 0;
158
159    lldb::ValueObjectSP value_sp(GetSP());
160    if (value_sp)
161        result = value_sp->GetByteSize();
162
163    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
164    if (log)
165        log->Printf ("SBValue(%p)::GetByteSize () => %zu", value_sp.get(), result);
166
167    return result;
168}
169
170bool
171SBValue::IsInScope ()
172{
173    bool result = false;
174
175    lldb::ValueObjectSP value_sp(GetSP());
176    if (value_sp)
177    {
178        TargetSP target_sp(value_sp->GetTargetSP());
179        if (target_sp)
180        {
181            Mutex::Locker api_locker (target_sp->GetAPIMutex());
182            result = value_sp->IsInScope ();
183        }
184    }
185
186    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
187    if (log)
188        log->Printf ("SBValue(%p)::IsInScope () => %i", value_sp.get(), result);
189
190    return result;
191}
192
193const char *
194SBValue::GetValue ()
195{
196    const char *cstr = NULL;
197    lldb::ValueObjectSP value_sp(GetSP());
198    if (value_sp)
199    {
200        TargetSP target_sp(value_sp->GetTargetSP());
201        if (target_sp)
202        {
203            Mutex::Locker api_locker (target_sp->GetAPIMutex());
204            cstr = value_sp->GetValueAsCString ();
205        }
206    }
207    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
208    if (log)
209    {
210        if (cstr)
211            log->Printf ("SBValue(%p)::GetValue => \"%s\"", value_sp.get(), cstr);
212        else
213            log->Printf ("SBValue(%p)::GetValue => NULL", value_sp.get());
214    }
215
216    return cstr;
217}
218
219ValueType
220SBValue::GetValueType ()
221{
222    ValueType result = eValueTypeInvalid;
223    lldb::ValueObjectSP value_sp(GetSP());
224    if (value_sp)
225        result = value_sp->GetValueType();
226    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
227    if (log)
228    {
229        switch (result)
230        {
231        case eValueTypeInvalid:         log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", value_sp.get()); break;
232        case eValueTypeVariableGlobal:  log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", value_sp.get()); break;
233        case eValueTypeVariableStatic:  log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", value_sp.get()); break;
234        case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", value_sp.get()); break;
235        case eValueTypeVariableLocal:   log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", value_sp.get()); break;
236        case eValueTypeRegister:        log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", value_sp.get()); break;
237        case eValueTypeRegisterSet:     log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", value_sp.get()); break;
238        case eValueTypeConstResult:     log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", value_sp.get()); break;
239        default:     log->Printf ("SBValue(%p)::GetValueType () => %i ???", value_sp.get(), result); break;
240        }
241    }
242    return result;
243}
244
245const char *
246SBValue::GetObjectDescription ()
247{
248    const char *cstr = NULL;
249    lldb::ValueObjectSP value_sp(GetSP());
250    if (value_sp)
251    {
252        TargetSP target_sp(value_sp->GetTargetSP());
253        if (target_sp)
254        {
255            Mutex::Locker api_locker (target_sp->GetAPIMutex());
256            cstr = value_sp->GetObjectDescription ();
257        }
258    }
259    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
260    if (log)
261    {
262        if (cstr)
263            log->Printf ("SBValue(%p)::GetObjectDescription => \"%s\"", value_sp.get(), cstr);
264        else
265            log->Printf ("SBValue(%p)::GetObjectDescription => NULL", value_sp.get());
266    }
267    return cstr;
268}
269
270SBType
271SBValue::GetType()
272{
273    SBType sb_type;
274    lldb::ValueObjectSP value_sp(GetSP());
275    TypeImplSP type_sp;
276    if (value_sp)
277    {
278        type_sp.reset (new TypeImpl(ClangASTType (value_sp->GetClangAST(), value_sp->GetClangType())));
279        sb_type.SetSP(type_sp);
280    }
281    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
282    if (log)
283    {
284        if (type_sp)
285            log->Printf ("SBValue(%p)::GetType => SBType(%p)", value_sp.get(), type_sp.get());
286        else
287            log->Printf ("SBValue(%p)::GetType => NULL", value_sp.get());
288    }
289    return sb_type;
290}
291
292bool
293SBValue::GetValueDidChange ()
294{
295    bool result = false;
296    lldb::ValueObjectSP value_sp(GetSP());
297    if (value_sp)
298    {
299        TargetSP target_sp(value_sp->GetTargetSP());
300        if (target_sp)
301        {
302            Mutex::Locker api_locker (target_sp->GetAPIMutex());
303            result = value_sp->GetValueDidChange ();
304        }
305    }
306    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
307    if (log)
308        log->Printf ("SBValue(%p)::GetValueDidChange => %i", value_sp.get(), result);
309
310    return result;
311}
312
313#ifndef LLDB_DISABLE_PYTHON
314const char *
315SBValue::GetSummary ()
316{
317    const char *cstr = NULL;
318    lldb::ValueObjectSP value_sp(GetSP());
319    if (value_sp)
320    {
321        TargetSP target_sp(value_sp->GetTargetSP());
322        if (target_sp)
323        {
324            Mutex::Locker api_locker (target_sp->GetAPIMutex());
325            cstr = value_sp->GetSummaryAsCString();
326        }
327    }
328    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
329    if (log)
330    {
331        if (cstr)
332            log->Printf ("SBValue(%p)::GetSummary => \"%s\"", value_sp.get(), cstr);
333        else
334            log->Printf ("SBValue(%p)::GetSummary => NULL", value_sp.get());
335    }
336    return cstr;
337}
338#endif // LLDB_DISABLE_PYTHON
339
340const char *
341SBValue::GetLocation ()
342{
343    const char *cstr = NULL;
344    lldb::ValueObjectSP value_sp(GetSP());
345    if (value_sp)
346    {
347        TargetSP target_sp(value_sp->GetTargetSP());
348        if (target_sp)
349        {
350            Mutex::Locker api_locker (target_sp->GetAPIMutex());
351            cstr = value_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\"", value_sp.get(), cstr);
359        else
360            log->Printf ("SBValue(%p)::GetSummary => NULL", value_sp.get());
361    }
362    return cstr;
363}
364
365bool
366SBValue::SetValueFromCString (const char *value_str)
367{
368    bool success = false;
369    lldb::ValueObjectSP value_sp(GetSP());
370    if (value_sp)
371    {
372        TargetSP target_sp(value_sp->GetTargetSP());
373        if (target_sp)
374        {
375            Mutex::Locker api_locker (target_sp->GetAPIMutex());
376            success = value_sp->SetValueFromCString (value_str);
377        }
378    }
379    return success;
380}
381
382lldb::SBTypeFormat
383SBValue::GetTypeFormat ()
384{
385    lldb::SBTypeFormat format;
386    lldb::ValueObjectSP value_sp(GetSP());
387    if (value_sp)
388    {
389        TargetSP target_sp(value_sp->GetTargetSP());
390        if (target_sp)
391        {
392            Mutex::Locker api_locker (target_sp->GetAPIMutex());
393            if (value_sp->UpdateValueIfNeeded(true))
394            {
395                lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
396                if (format_sp)
397                    format.SetSP(format_sp);
398            }
399        }
400    }
401    return format;
402}
403
404#ifndef LLDB_DISABLE_PYTHON
405lldb::SBTypeSummary
406SBValue::GetTypeSummary ()
407{
408    lldb::SBTypeSummary summary;
409    lldb::ValueObjectSP value_sp(GetSP());
410    if (value_sp)
411    {
412        TargetSP target_sp(value_sp->GetTargetSP());
413        if (target_sp)
414        {
415            Mutex::Locker api_locker (target_sp->GetAPIMutex());
416            if (value_sp->UpdateValueIfNeeded(true))
417            {
418                lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
419                if (summary_sp)
420                    summary.SetSP(summary_sp);
421            }
422        }
423    }
424    return summary;
425}
426#endif // LLDB_DISABLE_PYTHON
427
428lldb::SBTypeFilter
429SBValue::GetTypeFilter ()
430{
431    lldb::SBTypeFilter filter;
432    lldb::ValueObjectSP value_sp(GetSP());
433    if (value_sp)
434    {
435        TargetSP target_sp(value_sp->GetTargetSP());
436        if (target_sp)
437        {
438            Mutex::Locker api_locker (target_sp->GetAPIMutex());
439            if (value_sp->UpdateValueIfNeeded(true))
440            {
441                lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
442
443                if (synthetic_sp && !synthetic_sp->IsScripted())
444                {
445                    TypeFilterImplSP filter_sp = std::tr1::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
446                    filter.SetSP(filter_sp);
447                }
448            }
449        }
450    }
451    return filter;
452}
453
454#ifndef LLDB_DISABLE_PYTHON
455lldb::SBTypeSynthetic
456SBValue::GetTypeSynthetic ()
457{
458    lldb::SBTypeSynthetic synthetic;
459    lldb::ValueObjectSP value_sp(GetSP());
460    if (value_sp)
461    {
462        TargetSP target_sp(value_sp->GetTargetSP());
463        if (target_sp)
464        {
465            Mutex::Locker api_locker (target_sp->GetAPIMutex());
466            if (value_sp->UpdateValueIfNeeded(true))
467            {
468                lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
469
470                if (children_sp && children_sp->IsScripted())
471                {
472                    TypeSyntheticImplSP synth_sp = std::tr1::static_pointer_cast<TypeSyntheticImpl>(children_sp);
473                    synthetic.SetSP(synth_sp);
474                }
475            }
476        }
477    }
478    return synthetic;
479}
480#endif
481
482lldb::SBValue
483SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type)
484{
485    lldb::SBValue sb_value;
486    lldb::ValueObjectSP value_sp(GetSP());
487    lldb::ValueObjectSP new_value_sp;
488    if (value_sp)
489    {
490        TypeImplSP type_sp (type.GetSP());
491        if (type.IsValid())
492        {
493            sb_value = SBValue(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetClangASTType(), true));
494            new_value_sp = sb_value.GetSP();
495            if (new_value_sp)
496                new_value_sp->SetName(ConstString(name));
497        }
498    }
499    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
500    if (log)
501    {
502        if (new_value_sp)
503            log->Printf ("SBValue(%p)::GetChildAtOffset => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
504        else
505            log->Printf ("SBValue(%p)::GetChildAtOffset => NULL", value_sp.get());
506    }
507    return sb_value;
508}
509
510lldb::SBValue
511SBValue::Cast (SBType type)
512{
513    lldb::SBValue sb_value;
514    lldb::ValueObjectSP value_sp(GetSP());
515    TypeImplSP type_sp (type.GetSP());
516    if (value_sp && type_sp)
517        sb_value.SetSP(value_sp->Cast(type_sp->GetClangASTType()));
518    return sb_value;
519}
520
521lldb::SBValue
522SBValue::CreateValueFromExpression (const char *name, const char* expression)
523{
524    lldb::SBValue sb_value;
525    lldb::ValueObjectSP value_sp(GetSP());
526    lldb::ValueObjectSP new_value_sp;
527    if (value_sp)
528    {
529        ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
530        Target* target = exe_ctx.GetTargetPtr();
531        if (target)
532        {
533            target->EvaluateExpression (expression,
534                                        exe_ctx.GetFramePtr(),
535                                        eExecutionPolicyOnlyWhenNeeded,
536                                        false, // coerce to id
537                                        true, // unwind on error
538                                        true, // keep in memory
539                                        eNoDynamicValues,
540                                        new_value_sp);
541            if (new_value_sp)
542            {
543                new_value_sp->SetName(ConstString(name));
544                sb_value.SetSP(new_value_sp);
545            }
546        }
547    }
548    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
549    if (log)
550    {
551        if (new_value_sp)
552            log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
553        else
554            log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", value_sp.get());
555    }
556    return sb_value;
557}
558
559lldb::SBValue
560SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type)
561{
562    lldb::SBValue sb_value;
563    lldb::ValueObjectSP value_sp(GetSP());
564    lldb::ValueObjectSP new_value_sp;
565    lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
566    if (value_sp && type_impl_sp)
567    {
568        ClangASTType pointee_ast_type(type_impl_sp->GetASTContext(), type_impl_sp->GetClangASTType().GetPointerType ());
569        lldb::TypeImplSP pointee_type_impl_sp (new TypeImpl(pointee_ast_type));
570        if (pointee_type_impl_sp)
571        {
572
573            lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
574
575            ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
576            ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
577                                                                               pointee_type_impl_sp->GetASTContext(),
578                                                                               pointee_type_impl_sp->GetOpaqueQualType(),
579                                                                               ConstString(name),
580                                                                               buffer,
581                                                                               lldb::endian::InlHostByteOrder(),
582                                                                               exe_ctx.GetAddressByteSize()));
583
584            if (ptr_result_valobj_sp)
585            {
586                ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
587                Error err;
588                new_value_sp = ptr_result_valobj_sp->Dereference(err);
589                if (new_value_sp)
590                    new_value_sp->SetName(ConstString(name));
591            }
592            sb_value.SetSP(new_value_sp);
593        }
594    }
595    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
596    if (log)
597    {
598        if (new_value_sp)
599            log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
600        else
601            log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", value_sp.get());
602    }
603    return sb_value;
604}
605
606lldb::SBValue
607SBValue::CreateValueFromData (const char* name, SBData data, SBType type)
608{
609    lldb::SBValue sb_value;
610    lldb::ValueObjectSP new_value_sp;
611    lldb::ValueObjectSP value_sp(GetSP());
612    if (value_sp)
613    {
614        ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
615
616        new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
617                                                       type.m_opaque_sp->GetASTContext() ,
618                                                       type.m_opaque_sp->GetOpaqueQualType(),
619                                                       ConstString(name),
620                                                       *data.m_opaque_sp,
621                                                       LLDB_INVALID_ADDRESS);
622        new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
623        sb_value.SetSP(new_value_sp);
624    }
625    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
626    if (log)
627    {
628        if (new_value_sp)
629            log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", value_sp.get(), new_value_sp->GetName().AsCString());
630        else
631            log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", value_sp.get());
632    }
633    return sb_value;
634}
635
636SBValue
637SBValue::GetChildAtIndex (uint32_t idx)
638{
639    const bool can_create_synthetic = false;
640    lldb::DynamicValueType use_dynamic = eNoDynamicValues;
641    lldb::ValueObjectSP value_sp(GetSP());
642    if (value_sp)
643    {
644        TargetSP target_sp(value_sp->GetTargetSP());
645        if (target_sp)
646            use_dynamic = target_sp->GetPreferDynamicValue();
647    }
648    return GetChildAtIndex (idx, use_dynamic, can_create_synthetic);
649}
650
651SBValue
652SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic)
653{
654    lldb::ValueObjectSP child_sp;
655
656    lldb::ValueObjectSP value_sp(GetSP());
657    if (value_sp)
658    {
659        TargetSP target_sp(value_sp->GetTargetSP());
660        if (target_sp)
661        {
662            Mutex::Locker api_locker (target_sp->GetAPIMutex());
663            const bool can_create = true;
664            child_sp = value_sp->GetChildAtIndex (idx, can_create);
665            if (can_create_synthetic && !child_sp)
666            {
667                if (value_sp->IsPointerType())
668                {
669                    child_sp = value_sp->GetSyntheticArrayMemberFromPointer(idx, can_create);
670                }
671                else if (value_sp->IsArrayType())
672                {
673                    child_sp = value_sp->GetSyntheticArrayMemberFromArray(idx, can_create);
674                }
675            }
676
677            if (child_sp)
678            {
679                if (use_dynamic != lldb::eNoDynamicValues)
680                {
681                    lldb::ValueObjectSP dynamic_sp(child_sp->GetDynamicValue (use_dynamic));
682                    if (dynamic_sp)
683                        child_sp = dynamic_sp;
684                }
685            }
686        }
687    }
688
689    SBValue sb_value (child_sp);
690    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
691    if (log)
692        log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", value_sp.get(), idx, value_sp.get());
693
694    return sb_value;
695}
696
697uint32_t
698SBValue::GetIndexOfChildWithName (const char *name)
699{
700    uint32_t idx = UINT32_MAX;
701    lldb::ValueObjectSP value_sp(GetSP());
702    if (value_sp)
703    {
704        TargetSP target_sp(value_sp->GetTargetSP());
705        if (target_sp)
706        {
707            Mutex::Locker api_locker (target_sp->GetAPIMutex());
708
709            idx = value_sp->GetIndexOfChildWithName (ConstString(name));
710        }
711    }
712    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
713    if (log)
714    {
715        if (idx == UINT32_MAX)
716            log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", value_sp.get(), name);
717        else
718            log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", value_sp.get(), name, idx);
719    }
720    return idx;
721}
722
723SBValue
724SBValue::GetChildMemberWithName (const char *name)
725{
726    lldb::ValueObjectSP value_sp(GetSP());
727    if (value_sp)
728    {
729        lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
730        TargetSP target_sp(value_sp->GetTargetSP());
731        if (target_sp)
732        {
733            Mutex::Locker api_locker (target_sp->GetAPIMutex());
734            use_dynamic_value = target_sp->GetPreferDynamicValue();
735        }
736        return GetChildMemberWithName (name, use_dynamic_value);
737    }
738    return SBValue();
739}
740
741SBValue
742SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value)
743{
744    lldb::ValueObjectSP child_sp;
745    const ConstString str_name (name);
746
747
748    lldb::ValueObjectSP value_sp(GetSP());
749    if (value_sp)
750    {
751        TargetSP target_sp(value_sp->GetTargetSP());
752        if (target_sp)
753        {
754            Mutex::Locker api_locker (target_sp->GetAPIMutex());
755            child_sp = value_sp->GetChildMemberWithName (str_name, true);
756            if (use_dynamic_value != lldb::eNoDynamicValues)
757            {
758                if (child_sp)
759                {
760                    lldb::ValueObjectSP dynamic_sp = child_sp->GetDynamicValue (use_dynamic_value);
761                    if (dynamic_sp)
762                        child_sp = dynamic_sp;
763                }
764            }
765        }
766    }
767
768    SBValue sb_value (child_sp);
769
770    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
771    if (log)
772        log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", value_sp.get(), name, value_sp.get());
773
774    return sb_value;
775}
776
777lldb::SBValue
778SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic)
779{
780    lldb::ValueObjectSP value_sp(GetSP());
781    if (value_sp)
782    {
783        TargetSP target_sp(value_sp->GetTargetSP());
784        if (target_sp)
785        {
786            Mutex::Locker api_locker (target_sp->GetAPIMutex());
787            return SBValue (value_sp->GetDynamicValue(use_dynamic));
788        }
789    }
790
791    return SBValue();
792}
793
794lldb::SBValue
795SBValue::GetStaticValue ()
796{
797    lldb::ValueObjectSP value_sp(GetSP());
798    if (value_sp)
799    {
800        TargetSP target_sp(value_sp->GetTargetSP());
801        if (target_sp)
802        {
803            Mutex::Locker api_locker (target_sp->GetAPIMutex());
804            return SBValue(value_sp->GetStaticValue());
805        }
806    }
807
808    return SBValue();
809}
810
811bool
812SBValue::IsDynamic()
813{
814    lldb::ValueObjectSP value_sp(GetSP());
815    if (value_sp)
816    {
817        TargetSP target_sp(value_sp->GetTargetSP());
818        if (target_sp)
819        {
820            Mutex::Locker api_locker (target_sp->GetAPIMutex());
821            return value_sp->IsDynamic();
822        }
823    }
824    return false;
825}
826
827lldb::SBValue
828SBValue::GetValueForExpressionPath(const char* expr_path)
829{
830    lldb::ValueObjectSP child_sp;
831    lldb::ValueObjectSP value_sp(GetSP());
832    if (value_sp)
833    {
834        TargetSP target_sp(value_sp->GetTargetSP());
835        if (target_sp)
836        {
837            Mutex::Locker api_locker (target_sp->GetAPIMutex());
838            // using default values for all the fancy options, just do it if you can
839            child_sp = value_sp->GetValueForExpressionPath(expr_path);
840        }
841    }
842
843    SBValue sb_value (child_sp);
844
845    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
846    if (log)
847        log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", value_sp.get(), expr_path, value_sp.get());
848
849    return sb_value;
850}
851
852int64_t
853SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
854{
855    error.Clear();
856    lldb::ValueObjectSP value_sp(GetSP());
857    if (value_sp)
858    {
859        TargetSP target_sp(value_sp->GetTargetSP());
860        if (target_sp)
861        {
862            Mutex::Locker api_locker (target_sp->GetAPIMutex());
863            Scalar scalar;
864            if (value_sp->ResolveValue (scalar))
865                return scalar.GetRawBits64(fail_value);
866            else
867                error.SetErrorString("could not get value");
868        }
869        else
870            error.SetErrorString("could not get target");
871    }
872    error.SetErrorString("invalid SBValue");
873    return fail_value;
874}
875
876uint64_t
877SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
878{
879    error.Clear();
880    lldb::ValueObjectSP value_sp(GetSP());
881    if (value_sp)
882    {
883        TargetSP target_sp(value_sp->GetTargetSP());
884        if (target_sp)
885        {
886            Mutex::Locker api_locker (target_sp->GetAPIMutex());
887            Scalar scalar;
888            if (value_sp->ResolveValue (scalar))
889                return scalar.GetRawBits64(fail_value);
890            else
891                error.SetErrorString("could not get value");
892        }
893        else
894            error.SetErrorString("could not get target");
895    }
896    error.SetErrorString("invalid SBValue");
897    return fail_value;
898}
899
900int64_t
901SBValue::GetValueAsSigned(int64_t fail_value)
902{
903    lldb::ValueObjectSP value_sp(GetSP());
904    if (value_sp)
905    {
906        TargetSP target_sp(value_sp->GetTargetSP());
907        if (target_sp)
908        {
909            Mutex::Locker api_locker (target_sp->GetAPIMutex());
910            Scalar scalar;
911            if (value_sp->ResolveValue (scalar))
912                return scalar.GetRawBits64(fail_value);
913        }
914    }
915    return fail_value;
916}
917
918uint64_t
919SBValue::GetValueAsUnsigned(uint64_t fail_value)
920{
921    lldb::ValueObjectSP value_sp(GetSP());
922    if (value_sp)
923    {
924        TargetSP target_sp(value_sp->GetTargetSP());
925        if (target_sp)
926        {
927            Mutex::Locker api_locker (target_sp->GetAPIMutex());
928            Scalar scalar;
929            if (value_sp->ResolveValue (scalar))
930                return scalar.GetRawBits64(fail_value);
931        }
932    }
933    return fail_value;
934}
935
936uint32_t
937SBValue::GetNumChildren ()
938{
939    uint32_t num_children = 0;
940
941    lldb::ValueObjectSP value_sp(GetSP());
942    if (value_sp)
943    {
944        TargetSP target_sp(value_sp->GetTargetSP());
945        if (target_sp)
946        {
947            Mutex::Locker api_locker (target_sp->GetAPIMutex());
948
949            num_children = value_sp->GetNumChildren();
950        }
951    }
952
953    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
954    if (log)
955        log->Printf ("SBValue(%p)::GetNumChildren () => %u", value_sp.get(), num_children);
956
957    return num_children;
958}
959
960
961SBValue
962SBValue::Dereference ()
963{
964    SBValue sb_value;
965    lldb::ValueObjectSP value_sp(GetSP());
966    if (value_sp)
967    {
968        TargetSP target_sp(value_sp->GetTargetSP());
969        if (target_sp)
970        {
971            Mutex::Locker api_locker (target_sp->GetAPIMutex());
972
973            Error error;
974            sb_value = value_sp->Dereference (error);
975        }
976    }
977    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
978    if (log)
979        log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", value_sp.get(), value_sp.get());
980
981    return sb_value;
982}
983
984bool
985SBValue::TypeIsPointerType ()
986{
987    bool is_ptr_type = false;
988
989    lldb::ValueObjectSP value_sp(GetSP());
990    if (value_sp)
991    {
992        TargetSP target_sp(value_sp->GetTargetSP());
993        if (target_sp)
994        {
995            Mutex::Locker api_locker (target_sp->GetAPIMutex());
996
997            is_ptr_type = value_sp->IsPointerType();
998        }
999    }
1000
1001    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1002    if (log)
1003        log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", value_sp.get(), is_ptr_type);
1004
1005
1006    return is_ptr_type;
1007}
1008
1009void *
1010SBValue::GetOpaqueType()
1011{
1012    lldb::ValueObjectSP value_sp(GetSP());
1013    if (value_sp)
1014    {
1015        TargetSP target_sp(value_sp->GetTargetSP());
1016        if (target_sp)
1017        {
1018            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1019
1020            return value_sp->GetClangType();
1021        }
1022    }
1023    return NULL;
1024}
1025
1026lldb::SBTarget
1027SBValue::GetTarget()
1028{
1029    SBTarget sb_target;
1030    TargetSP target_sp;
1031    lldb::ValueObjectSP value_sp(GetSP());
1032    if (value_sp)
1033    {
1034        target_sp = value_sp->GetTargetSP();
1035        sb_target.SetSP (target_sp);
1036    }
1037    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1038    if (log)
1039    {
1040        if (target_sp.get() == NULL)
1041            log->Printf ("SBValue(%p)::GetTarget () => NULL", value_sp.get());
1042        else
1043            log->Printf ("SBValue(%p)::GetTarget () => %p", value_sp.get(), target_sp.get());
1044    }
1045    return sb_target;
1046}
1047
1048lldb::SBProcess
1049SBValue::GetProcess()
1050{
1051    SBProcess sb_process;
1052    ProcessSP process_sp;
1053    lldb::ValueObjectSP value_sp(GetSP());
1054    if (value_sp)
1055    {
1056        process_sp = value_sp->GetProcessSP();
1057        if (process_sp)
1058            sb_process.SetSP (process_sp);
1059    }
1060    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1061    if (log)
1062    {
1063        if (process_sp.get() == NULL)
1064            log->Printf ("SBValue(%p)::GetProcess () => NULL", value_sp.get());
1065        else
1066            log->Printf ("SBValue(%p)::GetProcess () => %p", value_sp.get(), process_sp.get());
1067    }
1068    return sb_process;
1069}
1070
1071lldb::SBThread
1072SBValue::GetThread()
1073{
1074    SBThread sb_thread;
1075    ThreadSP thread_sp;
1076    lldb::ValueObjectSP value_sp(GetSP());
1077    if (value_sp)
1078    {
1079        thread_sp = value_sp->GetThreadSP();
1080        sb_thread.SetThread(thread_sp);
1081    }
1082    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1083    if (log)
1084    {
1085        if (thread_sp.get() == NULL)
1086            log->Printf ("SBValue(%p)::GetThread () => NULL", value_sp.get());
1087        else
1088            log->Printf ("SBValue(%p)::GetThread () => %p", value_sp.get(), thread_sp.get());
1089    }
1090    return sb_thread;
1091}
1092
1093lldb::SBFrame
1094SBValue::GetFrame()
1095{
1096    SBFrame sb_frame;
1097    StackFrameSP frame_sp;
1098    lldb::ValueObjectSP value_sp(GetSP());
1099    if (value_sp)
1100    {
1101        frame_sp = value_sp->GetFrameSP();
1102        sb_frame.SetFrameSP (frame_sp);
1103    }
1104    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1105    if (log)
1106    {
1107        if (frame_sp.get() == NULL)
1108            log->Printf ("SBValue(%p)::GetFrame () => NULL", value_sp.get());
1109        else
1110            log->Printf ("SBValue(%p)::GetFrame () => %p", value_sp.get(), frame_sp.get());
1111    }
1112    return sb_frame;
1113}
1114
1115
1116lldb::ValueObjectSP
1117SBValue::GetSP () const
1118{
1119    return m_opaque_sp;
1120}
1121
1122void
1123SBValue::SetSP (const lldb::ValueObjectSP &sp)
1124{
1125    m_opaque_sp = sp;
1126}
1127
1128
1129bool
1130SBValue::GetExpressionPath (SBStream &description)
1131{
1132    lldb::ValueObjectSP value_sp(GetSP());
1133    if (value_sp)
1134    {
1135        value_sp->GetExpressionPath (description.ref(), false);
1136        return true;
1137    }
1138    return false;
1139}
1140
1141bool
1142SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
1143{
1144    lldb::ValueObjectSP value_sp(GetSP());
1145    if (value_sp)
1146    {
1147        value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
1148        return true;
1149    }
1150    return false;
1151}
1152
1153bool
1154SBValue::GetDescription (SBStream &description)
1155{
1156    Stream &strm = description.ref();
1157
1158    lldb::ValueObjectSP value_sp(GetSP());
1159    if (value_sp)
1160    {
1161        ValueObject::DumpValueObject (strm, value_sp.get());
1162    }
1163    else
1164        strm.PutCString ("No value");
1165
1166    return true;
1167}
1168
1169lldb::Format
1170SBValue::GetFormat ()
1171{
1172    lldb::ValueObjectSP value_sp(GetSP());
1173    if (value_sp)
1174        return value_sp->GetFormat();
1175    return eFormatDefault;
1176}
1177
1178void
1179SBValue::SetFormat (lldb::Format format)
1180{
1181    lldb::ValueObjectSP value_sp(GetSP());
1182    if (value_sp)
1183        value_sp->SetFormat(format);
1184}
1185
1186lldb::SBValue
1187SBValue::AddressOf()
1188{
1189    SBValue sb_value;
1190    lldb::ValueObjectSP value_sp(GetSP());
1191    if (value_sp)
1192    {
1193        TargetSP target_sp (value_sp->GetTargetSP());
1194        if (target_sp)
1195        {
1196            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1197            Error error;
1198            sb_value = value_sp->AddressOf (error);
1199        }
1200    }
1201    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1202    if (log)
1203        log->Printf ("SBValue(%p)::GetPointerToObject () => SBValue(%p)", value_sp.get(), value_sp.get());
1204
1205    return sb_value;
1206}
1207
1208lldb::addr_t
1209SBValue::GetLoadAddress()
1210{
1211    lldb::addr_t value = LLDB_INVALID_ADDRESS;
1212    lldb::ValueObjectSP value_sp(GetSP());
1213    if (value_sp)
1214    {
1215        TargetSP target_sp (value_sp->GetTargetSP());
1216        if (target_sp)
1217        {
1218            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1219            const bool scalar_is_load_address = true;
1220            AddressType addr_type;
1221            value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1222            if (addr_type == eAddressTypeFile)
1223            {
1224                Module* module = value_sp->GetModule();
1225                if (!module)
1226                    value = LLDB_INVALID_ADDRESS;
1227                else
1228                {
1229                    Address addr;
1230                    module->ResolveFileAddress(value, addr);
1231                    value = addr.GetLoadAddress(target_sp.get());
1232                }
1233            }
1234            else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid)
1235                value = LLDB_INVALID_ADDRESS;
1236        }
1237    }
1238    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1239    if (log)
1240        log->Printf ("SBValue(%p)::GetLoadAddress () => (%llu)", value_sp.get(), value);
1241
1242    return value;
1243}
1244
1245lldb::SBAddress
1246SBValue::GetAddress()
1247{
1248    Address addr;
1249    lldb::ValueObjectSP value_sp(GetSP());
1250    if (value_sp)
1251    {
1252        TargetSP target_sp (value_sp->GetTargetSP());
1253        if (target_sp)
1254        {
1255            lldb::addr_t value = LLDB_INVALID_ADDRESS;
1256            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1257            const bool scalar_is_load_address = true;
1258            AddressType addr_type;
1259            value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
1260            if (addr_type == eAddressTypeFile)
1261            {
1262                Module* module = value_sp->GetModule();
1263                if (module)
1264                    module->ResolveFileAddress(value, addr);
1265            }
1266            else if (addr_type == eAddressTypeLoad)
1267            {
1268                // no need to check the return value on this.. if it can actually do the resolve
1269                // addr will be in the form (section,offset), otherwise it will simply be returned
1270                // as (NULL, value)
1271                addr.SetLoadAddress(value, target_sp.get());
1272            }
1273        }
1274    }
1275    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1276    if (log)
1277        log->Printf ("SBValue(%p)::GetAddress () => (%s,%llu)", value_sp.get(), (addr.GetSection() ? addr.GetSection()->GetName().GetCString() : "NULL"), addr.GetOffset());
1278    return SBAddress(new Address(addr));
1279}
1280
1281lldb::SBData
1282SBValue::GetPointeeData (uint32_t item_idx,
1283                         uint32_t item_count)
1284{
1285    lldb::SBData sb_data;
1286    lldb::ValueObjectSP value_sp(GetSP());
1287    if (value_sp)
1288    {
1289        TargetSP target_sp (value_sp->GetTargetSP());
1290        if (target_sp)
1291        {
1292			DataExtractorSP data_sp(new DataExtractor());
1293            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1294            value_sp->GetPointeeData(*data_sp, item_idx, item_count);
1295            if (data_sp->GetByteSize() > 0)
1296                *sb_data = data_sp;
1297        }
1298    }
1299    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1300    if (log)
1301        log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
1302                     value_sp.get(),
1303                     item_idx,
1304                     item_count,
1305                     sb_data.get());
1306
1307    return sb_data;
1308}
1309
1310lldb::SBData
1311SBValue::GetData ()
1312{
1313    lldb::SBData sb_data;
1314    lldb::ValueObjectSP value_sp(GetSP());
1315    if (value_sp)
1316    {
1317        TargetSP target_sp (value_sp->GetTargetSP());
1318        if (target_sp)
1319        {
1320            Mutex::Locker api_locker (target_sp->GetAPIMutex());
1321			DataExtractorSP data_sp(new DataExtractor());
1322            value_sp->GetData(*data_sp);
1323            if (data_sp->GetByteSize() > 0)
1324                *sb_data = data_sp;
1325        }
1326    }
1327    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1328    if (log)
1329        log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
1330                     value_sp.get(),
1331                     sb_data.get());
1332
1333    return sb_data;
1334}
1335
1336lldb::SBWatchpoint
1337SBValue::Watch (bool resolve_location, bool read, bool write)
1338{
1339    SBWatchpoint sb_watchpoint;
1340
1341    // If the SBValue is not valid, there's no point in even trying to watch it.
1342    lldb::ValueObjectSP value_sp(GetSP());
1343    TargetSP target_sp (GetTarget().GetSP());
1344    if (value_sp && target_sp)
1345    {
1346        // Read and Write cannot both be false.
1347        if (!read && !write)
1348            return sb_watchpoint;
1349
1350        // If the value is not in scope, don't try and watch and invalid value
1351        if (!IsInScope())
1352            return sb_watchpoint;
1353
1354        addr_t addr = GetLoadAddress();
1355        if (addr == LLDB_INVALID_ADDRESS)
1356            return sb_watchpoint;
1357        size_t byte_size = GetByteSize();
1358        if (byte_size == 0)
1359            return sb_watchpoint;
1360
1361        uint32_t watch_type = 0;
1362        if (read)
1363            watch_type |= LLDB_WATCH_TYPE_READ;
1364        if (write)
1365            watch_type |= LLDB_WATCH_TYPE_WRITE;
1366
1367        WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, watch_type);
1368
1369        if (watchpoint_sp)
1370        {
1371            sb_watchpoint.SetSP (watchpoint_sp);
1372            Declaration decl;
1373            if (value_sp->GetDeclaration (decl))
1374            {
1375                if (decl.GetFile())
1376                {
1377                    StreamString ss;
1378                    // True to show fullpath for declaration file.
1379                    decl.DumpStopContext(&ss, true);
1380                    watchpoint_sp->SetDeclInfo(ss.GetString());
1381                }
1382            }
1383        }
1384    }
1385    return sb_watchpoint;
1386}
1387
1388lldb::SBWatchpoint
1389SBValue::WatchPointee (bool resolve_location, bool read, bool write)
1390{
1391    SBWatchpoint sb_watchpoint;
1392    if (IsInScope() && GetType().IsPointerType())
1393        sb_watchpoint = Dereference().Watch (resolve_location, read, write);
1394    return sb_watchpoint;
1395}
1396
1397