ValueObject.cpp revision 0a19a1b9c25117854f226256805239d95153ed2d 
1//===-- ValueObject.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/Core/ValueObject.h"
11
12// C Includes
13#include <stdlib.h>
14
15// C++ Includes
16// Other libraries and framework includes
17#include "llvm/Support/raw_ostream.h"
18#include "clang/AST/Type.h"
19
20// Project includes
21#include "lldb/Core/DataBufferHeap.h"
22#include "lldb/Core/DataVisualization.h"
23#include "lldb/Core/Debugger.h"
24#include "lldb/Core/Log.h"
25#include "lldb/Core/StreamString.h"
26#include "lldb/Core/ValueObjectChild.h"
27#include "lldb/Core/ValueObjectConstResult.h"
28#include "lldb/Core/ValueObjectDynamicValue.h"
29#include "lldb/Core/ValueObjectList.h"
30#include "lldb/Core/ValueObjectMemory.h"
31#include "lldb/Core/ValueObjectSyntheticFilter.h"
32
33#include "lldb/Host/Endian.h"
34
35#include "lldb/Interpreter/CommandInterpreter.h"
36#include "lldb/Interpreter/ScriptInterpreterPython.h"
37
38#include "lldb/Symbol/ClangASTType.h"
39#include "lldb/Symbol/ClangASTContext.h"
40#include "lldb/Symbol/Type.h"
41
42#include "lldb/Target/ExecutionContext.h"
43#include "lldb/Target/LanguageRuntime.h"
44#include "lldb/Target/ObjCLanguageRuntime.h"
45#include "lldb/Target/Process.h"
46#include "lldb/Target/RegisterContext.h"
47#include "lldb/Target/Target.h"
48#include "lldb/Target/Thread.h"
49
50#include "lldb/Utility/RefCounter.h"
51
52using namespace lldb;
53using namespace lldb_private;
54using namespace lldb_utility;
55
56static user_id_t g_value_obj_uid = 0;
57
58//----------------------------------------------------------------------
59// ValueObject constructor
60//----------------------------------------------------------------------
61ValueObject::ValueObject (ValueObject &parent) :
62    UserID (++g_value_obj_uid), // Unique identifier for every value object
63    m_parent (&parent),
64    m_update_point (parent.GetUpdatePoint ()),
65    m_name (),
66    m_data (),
67    m_value (),
68    m_error (),
69    m_value_str (),
70    m_old_value_str (),
71    m_location_str (),
72    m_summary_str (),
73    m_object_desc_str (),
74    m_manager(parent.GetManager()),
75    m_children (),
76    m_synthetic_children (),
77    m_dynamic_value (NULL),
78    m_synthetic_value(NULL),
79    m_deref_valobj(NULL),
80    m_format (eFormatDefault),
81    m_last_format_mgr_revision(0),
82    m_last_format_mgr_dynamic(parent.m_last_format_mgr_dynamic),
83    m_last_summary_format(),
84    m_forced_summary_format(),
85    m_last_value_format(),
86    m_last_synthetic_filter(),
87    m_user_id_of_forced_summary(),
88    m_address_type_of_ptr_or_ref_children(eAddressTypeInvalid),
89    m_value_is_valid (false),
90    m_value_did_change (false),
91    m_children_count_valid (false),
92    m_old_value_valid (false),
93    m_is_deref_of_parent (false),
94    m_is_array_item_for_pointer(false),
95    m_is_bitfield_for_scalar(false),
96    m_is_expression_path_child(false),
97    m_is_child_at_offset(false),
98    m_is_getting_summary(false)
99{
100    m_manager->ManageObject(this);
101}
102
103//----------------------------------------------------------------------
104// ValueObject constructor
105//----------------------------------------------------------------------
106ValueObject::ValueObject (ExecutionContextScope *exe_scope,
107                          AddressType child_ptr_or_ref_addr_type) :
108    UserID (++g_value_obj_uid), // Unique identifier for every value object
109    m_parent (NULL),
110    m_update_point (exe_scope),
111    m_name (),
112    m_data (),
113    m_value (),
114    m_error (),
115    m_value_str (),
116    m_old_value_str (),
117    m_location_str (),
118    m_summary_str (),
119    m_object_desc_str (),
120    m_manager(),
121    m_children (),
122    m_synthetic_children (),
123    m_dynamic_value (NULL),
124    m_synthetic_value(NULL),
125    m_deref_valobj(NULL),
126    m_format (eFormatDefault),
127    m_last_format_mgr_revision(0),
128    m_last_format_mgr_dynamic(eNoDynamicValues),
129    m_last_summary_format(),
130    m_forced_summary_format(),
131    m_last_value_format(),
132    m_last_synthetic_filter(),
133    m_user_id_of_forced_summary(),
134    m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type),
135    m_value_is_valid (false),
136    m_value_did_change (false),
137    m_children_count_valid (false),
138    m_old_value_valid (false),
139    m_is_deref_of_parent (false),
140    m_is_array_item_for_pointer(false),
141    m_is_bitfield_for_scalar(false),
142    m_is_expression_path_child(false),
143    m_is_child_at_offset(false),
144    m_is_getting_summary(false)
145{
146    m_manager = new ValueObjectManager();
147    m_manager->ManageObject (this);
148}
149
150//----------------------------------------------------------------------
151// Destructor
152//----------------------------------------------------------------------
153ValueObject::~ValueObject ()
154{
155}
156
157bool
158ValueObject::UpdateValueIfNeeded (bool update_format)
159{
160    return UpdateValueIfNeeded(m_last_format_mgr_dynamic, update_format);
161}
162
163bool
164ValueObject::UpdateValueIfNeeded (DynamicValueType use_dynamic, bool update_format)
165{
166
167    bool did_change_formats = false;
168
169    if (update_format)
170        did_change_formats = UpdateFormatsIfNeeded(use_dynamic);
171
172    // If this is a constant value, then our success is predicated on whether
173    // we have an error or not
174    if (GetIsConstant())
175    {
176        // if you were asked to update your formatters, but did not get a chance to do it
177        // clear your own values (this serves the purpose of faking a stop-id for frozen
178        // objects (which are regarded as constant, but could have changes behind their backs
179        // because of the frozen-pointer depth limit)
180		// TODO: decouple summary from value and then remove this code and only force-clear the summary
181        if (update_format && !did_change_formats)
182            m_summary_str.clear();
183        return m_error.Success();
184    }
185
186    bool first_update = m_update_point.IsFirstEvaluation();
187
188    if (m_update_point.NeedsUpdating())
189    {
190        m_update_point.SetUpdated();
191
192        // Save the old value using swap to avoid a string copy which
193        // also will clear our m_value_str
194        if (m_value_str.empty())
195        {
196            m_old_value_valid = false;
197        }
198        else
199        {
200            m_old_value_valid = true;
201            m_old_value_str.swap (m_value_str);
202            m_value_str.clear();
203        }
204
205        ClearUserVisibleData();
206
207        const bool value_was_valid = GetValueIsValid();
208        SetValueDidChange (false);
209
210        m_error.Clear();
211
212        // Call the pure virtual function to update the value
213        bool success = UpdateValue ();
214
215        SetValueIsValid (success);
216
217        if (first_update)
218            SetValueDidChange (false);
219        else if (!m_value_did_change && success == false)
220        {
221            // The value wasn't gotten successfully, so we mark this
222            // as changed if the value used to be valid and now isn't
223            SetValueDidChange (value_was_valid);
224        }
225    }
226    return m_error.Success();
227}
228
229bool
230ValueObject::UpdateFormatsIfNeeded(DynamicValueType use_dynamic)
231{
232    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
233    if (log)
234        log->Printf("checking for FormatManager revisions. VO named %s is at revision %d, while the format manager is at revision %d",
235           GetName().GetCString(),
236           m_last_format_mgr_revision,
237           DataVisualization::GetCurrentRevision());
238
239    bool any_change = false;
240
241    if (HasCustomSummaryFormat() && m_update_point.GetModID() != m_user_id_of_forced_summary)
242    {
243        ClearCustomSummaryFormat();
244
245        any_change = true;
246    }
247
248    if ( (m_last_format_mgr_revision != DataVisualization::GetCurrentRevision()) ||
249          m_last_format_mgr_dynamic != use_dynamic)
250    {
251        SetValueFormat(DataVisualization::ValueFormats::GetFormat (*this, eNoDynamicValues));
252        SetSummaryFormat(DataVisualization::GetSummaryFormat (*this, use_dynamic));
253        SetSyntheticChildren(DataVisualization::GetSyntheticChildren (*this, use_dynamic));
254
255        m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
256        m_last_format_mgr_dynamic = use_dynamic;
257
258        any_change = true;
259    }
260
261    return any_change;
262
263}
264
265void
266ValueObject::SetNeedsUpdate ()
267{
268    m_update_point.SetNeedsUpdate();
269    // We have to clear the value string here so ConstResult children will notice if their values are
270    // changed by hand (i.e. with SetValueAsCString).
271    m_value_str.clear();
272}
273
274DataExtractor &
275ValueObject::GetDataExtractor ()
276{
277    UpdateValueIfNeeded(false);
278    return m_data;
279}
280
281const Error &
282ValueObject::GetError()
283{
284    UpdateValueIfNeeded(false);
285    return m_error;
286}
287
288const ConstString &
289ValueObject::GetName() const
290{
291    return m_name;
292}
293
294const char *
295ValueObject::GetLocationAsCString ()
296{
297    if (UpdateValueIfNeeded(false))
298    {
299        if (m_location_str.empty())
300        {
301            StreamString sstr;
302
303            switch (m_value.GetValueType())
304            {
305            default:
306                break;
307
308            case Value::eValueTypeScalar:
309                if (m_value.GetContextType() == Value::eContextTypeRegisterInfo)
310                {
311                    RegisterInfo *reg_info = m_value.GetRegisterInfo();
312                    if (reg_info)
313                    {
314                        if (reg_info->name)
315                            m_location_str = reg_info->name;
316                        else if (reg_info->alt_name)
317                            m_location_str = reg_info->alt_name;
318                        break;
319                    }
320                }
321                m_location_str = "scalar";
322                break;
323
324            case Value::eValueTypeLoadAddress:
325            case Value::eValueTypeFileAddress:
326            case Value::eValueTypeHostAddress:
327                {
328                    uint32_t addr_nibble_size = m_data.GetAddressByteSize() * 2;
329                    sstr.Printf("0x%*.*llx", addr_nibble_size, addr_nibble_size, m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS));
330                    m_location_str.swap(sstr.GetString());
331                }
332                break;
333            }
334        }
335    }
336    return m_location_str.c_str();
337}
338
339Value &
340ValueObject::GetValue()
341{
342    return m_value;
343}
344
345const Value &
346ValueObject::GetValue() const
347{
348    return m_value;
349}
350
351bool
352ValueObject::ResolveValue (Scalar &scalar)
353{
354    if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything
355    {
356        ExecutionContext exe_ctx;
357        ExecutionContextScope *exe_scope = GetExecutionContextScope();
358        if (exe_scope)
359            exe_scope->CalculateExecutionContext(exe_ctx);
360        Value tmp_value(m_value);
361        scalar = tmp_value.ResolveValue(&exe_ctx, GetClangAST ());
362        if (scalar.IsValid())
363        {
364            const uint32_t bitfield_bit_size = GetBitfieldBitSize();
365            if (bitfield_bit_size)
366                return scalar.ExtractBitfield (bitfield_bit_size, GetBitfieldBitOffset());
367            return true;
368        }
369    }
370    return false;
371}
372
373bool
374ValueObject::GetValueIsValid () const
375{
376    return m_value_is_valid;
377}
378
379
380void
381ValueObject::SetValueIsValid (bool b)
382{
383    m_value_is_valid = b;
384}
385
386bool
387ValueObject::GetValueDidChange ()
388{
389    GetValueAsCString ();
390    return m_value_did_change;
391}
392
393void
394ValueObject::SetValueDidChange (bool value_changed)
395{
396    m_value_did_change = value_changed;
397}
398
399ValueObjectSP
400ValueObject::GetChildAtIndex (uint32_t idx, bool can_create)
401{
402    ValueObjectSP child_sp;
403    // We may need to update our value if we are dynamic
404    if (IsPossibleDynamicType ())
405        UpdateValueIfNeeded(false);
406    if (idx < GetNumChildren())
407    {
408        // Check if we have already made the child value object?
409        if (can_create && m_children[idx] == NULL)
410        {
411            // No we haven't created the child at this index, so lets have our
412            // subclass do it and cache the result for quick future access.
413            m_children[idx] = CreateChildAtIndex (idx, false, 0);
414        }
415
416        if (m_children[idx] != NULL)
417            return m_children[idx]->GetSP();
418    }
419    return child_sp;
420}
421
422uint32_t
423ValueObject::GetIndexOfChildWithName (const ConstString &name)
424{
425    bool omit_empty_base_classes = true;
426    return ClangASTContext::GetIndexOfChildWithName (GetClangAST(),
427                                                     GetClangType(),
428                                                     name.GetCString(),
429                                                     omit_empty_base_classes);
430}
431
432ValueObjectSP
433ValueObject::GetChildMemberWithName (const ConstString &name, bool can_create)
434{
435    // when getting a child by name, it could be buried inside some base
436    // classes (which really aren't part of the expression path), so we
437    // need a vector of indexes that can get us down to the correct child
438    ValueObjectSP child_sp;
439
440    // We may need to update our value if we are dynamic
441    if (IsPossibleDynamicType ())
442        UpdateValueIfNeeded(false);
443
444    std::vector<uint32_t> child_indexes;
445    clang::ASTContext *clang_ast = GetClangAST();
446    void *clang_type = GetClangType();
447    bool omit_empty_base_classes = true;
448    const size_t num_child_indexes =  ClangASTContext::GetIndexOfChildMemberWithName (clang_ast,
449                                                                                      clang_type,
450                                                                                      name.GetCString(),
451                                                                                      omit_empty_base_classes,
452                                                                                      child_indexes);
453    if (num_child_indexes > 0)
454    {
455        std::vector<uint32_t>::const_iterator pos = child_indexes.begin ();
456        std::vector<uint32_t>::const_iterator end = child_indexes.end ();
457
458        child_sp = GetChildAtIndex(*pos, can_create);
459        for (++pos; pos != end; ++pos)
460        {
461            if (child_sp)
462            {
463                ValueObjectSP new_child_sp(child_sp->GetChildAtIndex (*pos, can_create));
464                child_sp = new_child_sp;
465            }
466            else
467            {
468                child_sp.reset();
469            }
470
471        }
472    }
473    return child_sp;
474}
475
476
477uint32_t
478ValueObject::GetNumChildren ()
479{
480    if (!m_children_count_valid)
481    {
482        SetNumChildren (CalculateNumChildren());
483    }
484    return m_children.size();
485}
486void
487ValueObject::SetNumChildren (uint32_t num_children)
488{
489    m_children_count_valid = true;
490    m_children.resize(num_children);
491}
492
493void
494ValueObject::SetName (const ConstString &name)
495{
496    m_name = name;
497}
498
499ValueObject *
500ValueObject::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index)
501{
502    ValueObject *valobj = NULL;
503
504    bool omit_empty_base_classes = true;
505    bool ignore_array_bounds = synthetic_array_member;
506    std::string child_name_str;
507    uint32_t child_byte_size = 0;
508    int32_t child_byte_offset = 0;
509    uint32_t child_bitfield_bit_size = 0;
510    uint32_t child_bitfield_bit_offset = 0;
511    bool child_is_base_class = false;
512    bool child_is_deref_of_parent = false;
513
514    const bool transparent_pointers = synthetic_array_member == false;
515    clang::ASTContext *clang_ast = GetClangAST();
516    clang_type_t clang_type = GetClangType();
517    clang_type_t child_clang_type;
518
519    ExecutionContext exe_ctx;
520    GetExecutionContextScope()->CalculateExecutionContext (exe_ctx);
521
522    child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx,
523                                                                  clang_ast,
524                                                                  GetName().GetCString(),
525                                                                  clang_type,
526                                                                  idx,
527                                                                  transparent_pointers,
528                                                                  omit_empty_base_classes,
529                                                                  ignore_array_bounds,
530                                                                  child_name_str,
531                                                                  child_byte_size,
532                                                                  child_byte_offset,
533                                                                  child_bitfield_bit_size,
534                                                                  child_bitfield_bit_offset,
535                                                                  child_is_base_class,
536                                                                  child_is_deref_of_parent);
537    if (child_clang_type && child_byte_size)
538    {
539        if (synthetic_index)
540            child_byte_offset += child_byte_size * synthetic_index;
541
542        ConstString child_name;
543        if (!child_name_str.empty())
544            child_name.SetCString (child_name_str.c_str());
545
546        valobj = new ValueObjectChild (*this,
547                                       clang_ast,
548                                       child_clang_type,
549                                       child_name,
550                                       child_byte_size,
551                                       child_byte_offset,
552                                       child_bitfield_bit_size,
553                                       child_bitfield_bit_offset,
554                                       child_is_base_class,
555                                       child_is_deref_of_parent,
556                                       eAddressTypeInvalid);
557        //if (valobj)
558        //    valobj->SetAddressTypeOfChildren(eAddressTypeInvalid);
559   }
560
561    return valobj;
562}
563
564const char *
565ValueObject::GetSummaryAsCString ()
566{
567    // Watch for recursion which can happen with summary strings and other
568    // variable formatting options.
569    if (m_is_getting_summary)
570        return NULL;
571
572    m_is_getting_summary = true;
573
574    if (UpdateValueIfNeeded (true))
575    {
576        if (m_summary_str.empty())
577        {
578            SummaryFormat *summary_format = GetSummaryFormat().get();
579
580            if (summary_format)
581            {
582                m_summary_str = summary_format->FormatObject(GetSP());
583            }
584            else
585            {
586                clang_type_t clang_type = GetClangType();
587
588                // Do some default printout for function pointers
589                if (clang_type)
590                {
591                    StreamString sstr;
592                    clang_type_t elem_or_pointee_clang_type;
593                    const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type,
594                                                                          GetClangAST(),
595                                                                          &elem_or_pointee_clang_type));
596
597                    ExecutionContextScope *exe_scope = GetExecutionContextScope();
598                    if (exe_scope)
599                    {
600                        if (ClangASTContext::IsFunctionPointerType (clang_type))
601                        {
602                            AddressType func_ptr_address_type = eAddressTypeInvalid;
603                            addr_t func_ptr_address = GetPointerValue (&func_ptr_address_type);
604                            if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS)
605                            {
606                                switch (func_ptr_address_type)
607                                {
608                                case eAddressTypeInvalid:
609                                case eAddressTypeFile:
610                                    break;
611
612                                case eAddressTypeLoad:
613                                    {
614                                        Address so_addr;
615                                        Target *target = exe_scope->CalculateTarget();
616                                        if (target && target->GetSectionLoadList().IsEmpty() == false)
617                                        {
618                                            if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr))
619                                            {
620                                                so_addr.Dump (&sstr,
621                                                              exe_scope,
622                                                              Address::DumpStyleResolvedDescription,
623                                                              Address::DumpStyleSectionNameOffset);
624                                            }
625                                        }
626                                    }
627                                    break;
628
629                                case eAddressTypeHost:
630                                    break;
631                                }
632                            }
633                            if (sstr.GetSize() > 0)
634                            {
635                                m_summary_str.assign (1, '(');
636                                m_summary_str.append (sstr.GetData(), sstr.GetSize());
637                                m_summary_str.append (1, ')');
638                            }
639                        }
640                    }
641                }
642            }
643        }
644    }
645    m_is_getting_summary = false;
646    if (m_summary_str.empty())
647        return NULL;
648    return m_summary_str.c_str();
649}
650
651bool
652ValueObject::IsCStringContainer(bool check_pointer)
653{
654    clang_type_t elem_or_pointee_clang_type;
655    const Flags type_flags (ClangASTContext::GetTypeInfo (GetClangType(),
656                                                          GetClangAST(),
657                                                          &elem_or_pointee_clang_type));
658    bool is_char_arr_ptr (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) &&
659            ClangASTContext::IsCharType (elem_or_pointee_clang_type));
660    if (!is_char_arr_ptr)
661        return false;
662    if (!check_pointer)
663        return true;
664    if (type_flags.Test(ClangASTContext::eTypeIsArray))
665        return true;
666    addr_t cstr_address = LLDB_INVALID_ADDRESS;
667    AddressType cstr_address_type = eAddressTypeInvalid;
668    cstr_address = GetAddressOf (true, &cstr_address_type);
669    return (cstr_address != LLDB_INVALID_ADDRESS);
670}
671
672size_t
673ValueObject::GetPointeeData (DataExtractor& data,
674                             uint32_t item_idx,
675                             uint32_t item_count)
676{
677    if (!IsPointerType() && !IsArrayType())
678        return 0;
679
680    if (item_count == 0)
681        return 0;
682
683    uint32_t stride = 0;
684
685    ClangASTType type(GetClangAST(),
686                      GetClangType());
687
688    const uint64_t item_type_size = (IsPointerType() ? ClangASTType::GetTypeByteSize(GetClangAST(), type.GetPointeeType()) :
689                                     ClangASTType::GetTypeByteSize(GetClangAST(), type.GetArrayElementType(stride)));
690
691    const uint64_t bytes = item_count * item_type_size;
692
693    const uint64_t offset = item_idx * item_type_size;
694
695    if (item_idx == 0 && item_count == 1) // simply a deref
696    {
697        if (IsPointerType())
698        {
699            Error error;
700            ValueObjectSP pointee_sp = Dereference(error);
701            if (error.Fail() || pointee_sp.get() == NULL)
702                return 0;
703            return pointee_sp->GetDataExtractor().Copy(data);
704        }
705        else
706        {
707            ValueObjectSP child_sp = GetChildAtIndex(0, true);
708            if (child_sp.get() == NULL)
709                return 0;
710            return child_sp->GetDataExtractor().Copy(data);
711        }
712        return true;
713    }
714    else /* (items > 1) */
715    {
716        Error error;
717        lldb_private::DataBufferHeap* heap_buf_ptr = NULL;
718        lldb::DataBufferSP data_sp(heap_buf_ptr = new lldb_private::DataBufferHeap());
719
720        AddressType addr_type;
721        lldb::addr_t addr = IsPointerType() ? GetPointerValue(&addr_type) : GetAddressOf(true, &addr_type);
722
723        ExecutionContextScope *exe_scope = GetExecutionContextScope();
724
725
726        switch (addr_type)
727        {
728            case eAddressTypeFile:
729                {
730                    Module* module = GetModule();
731                    if (module)
732                    {
733                        Address so_addr;
734                        module->ResolveFileAddress(addr, so_addr);
735                        if (exe_scope)
736                        {
737                            Target* target = exe_scope->CalculateTarget();
738                            if (target)
739                            {
740                                heap_buf_ptr->SetByteSize(bytes);
741                                size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error);
742                                if (error.Success())
743                                {
744                                    data.SetData(data_sp);
745                                    return bytes_read;
746                                }
747                            }
748                        }
749                    }
750                }
751                break;
752            case eAddressTypeLoad:
753                if (exe_scope)
754                {
755                    Process *process = exe_scope->CalculateProcess();
756                    if (process)
757                    {
758                        heap_buf_ptr->SetByteSize(bytes);
759                        size_t bytes_read = process->ReadMemory(addr + offset, heap_buf_ptr->GetBytes(), bytes, error);
760                        if (error.Success())
761                        {
762                            data.SetData(data_sp);
763                            return bytes_read;
764                        }
765                    }
766                }
767                break;
768            case eAddressTypeHost:
769                {
770                    heap_buf_ptr->CopyData((uint8_t*)(addr + offset), bytes);
771                    data.SetData(data_sp);
772                    return bytes;
773                }
774                break;
775            case eAddressTypeInvalid:
776            default:
777                break;
778        }
779    }
780    return 0;
781}
782
783size_t
784ValueObject::GetData (DataExtractor& data)
785{
786    UpdateValueIfNeeded(false);
787    ExecutionContext exe_ctx;
788    GetExecutionContextScope()->CalculateExecutionContext(exe_ctx);
789    Error error = m_value.GetValueAsData(&exe_ctx, GetClangAST(), data, 0, GetModule());
790    if (error.Fail())
791        return 0;
792    data.SetAddressByteSize(m_data.GetAddressByteSize());
793    data.SetByteOrder(m_data.GetByteOrder());
794    return data.GetByteSize();
795}
796
797// will compute strlen(str), but without consuming more than
798// maxlen bytes out of str (this serves the purpose of reading
799// chunks of a string without having to worry about
800// missing NULL terminators in the chunk)
801// of course, if strlen(str) > maxlen, the function will return
802// maxlen_value (which should be != maxlen, because that allows you
803// to know whether strlen(str) == maxlen or strlen(str) > maxlen)
804static uint32_t
805strlen_or_inf (const char* str,
806               uint32_t maxlen,
807               uint32_t maxlen_value)
808{
809    uint32_t len = 0;
810    if (str)
811    {
812        while(*str)
813        {
814            len++;str++;
815            if (len > maxlen)
816                return maxlen_value;
817        }
818    }
819    return len;
820}
821
822void
823ValueObject::ReadPointedString(Stream& s,
824                               Error& error,
825                               uint32_t max_length,
826                               bool honor_array,
827                               Format item_format)
828{
829
830    if (max_length == 0)
831        max_length = GetUpdatePoint().GetTargetSP()->GetMaximumSizeOfStringSummary();
832
833    clang_type_t clang_type = GetClangType();
834    clang_type_t elem_or_pointee_clang_type;
835    const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type,
836                                                          GetClangAST(),
837                                                          &elem_or_pointee_clang_type));
838    if (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) &&
839        ClangASTContext::IsCharType (elem_or_pointee_clang_type))
840    {
841        ExecutionContextScope *exe_scope = GetExecutionContextScope();
842            if (exe_scope)
843            {
844                Target *target = exe_scope->CalculateTarget();
845                if (target == NULL)
846                {
847                    s << "<no target to read from>";
848                }
849                else
850                {
851                    addr_t cstr_address = LLDB_INVALID_ADDRESS;
852                    AddressType cstr_address_type = eAddressTypeInvalid;
853
854                    size_t cstr_len = 0;
855                    bool capped_data = false;
856                    if (type_flags.Test (ClangASTContext::eTypeIsArray))
857                    {
858                        // We have an array
859                        cstr_len = ClangASTContext::GetArraySize (clang_type);
860                        if (cstr_len > max_length)
861                        {
862                            capped_data = true;
863                            cstr_len = max_length;
864                        }
865                        cstr_address = GetAddressOf (true, &cstr_address_type);
866                    }
867                    else
868                    {
869                        // We have a pointer
870                        cstr_address = GetPointerValue (&cstr_address_type);
871                    }
872                    if (cstr_address != 0 && cstr_address != LLDB_INVALID_ADDRESS)
873                    {
874                        Address cstr_so_addr (NULL, cstr_address);
875                        DataExtractor data;
876                        size_t bytes_read = 0;
877                        if (cstr_len > 0 && honor_array)
878                        {
879                            // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
880						    // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
881                            GetPointeeData(data, 0, cstr_len);
882
883                            if ((bytes_read = data.GetByteSize()) > 0)
884                            {
885                                s << '"';
886                                data.Dump (&s,
887                                           0,                 // Start offset in "data"
888                                           item_format,
889                                           1,                 // Size of item (1 byte for a char!)
890                                           bytes_read,        // How many bytes to print?
891                                           UINT32_MAX,        // num per line
892                                           LLDB_INVALID_ADDRESS,// base address
893                                           0,                 // bitfield bit size
894                                           0);                // bitfield bit offset
895                                if (capped_data)
896                                    s << "...";
897                                s << '"';
898                            }
899                        }
900                        else
901                        {
902                            cstr_len = max_length;
903                            const size_t k_max_buf_size = 64;
904
905                            size_t offset = 0;
906
907                            int cstr_len_displayed = -1;
908                            bool capped_cstr = false;
909							// I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host
910						    // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this
911                            while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0)
912                            {
913                                const char *cstr = data.PeekCStr(0);
914                                size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1);
915                                if (len > k_max_buf_size)
916                                    len = k_max_buf_size;
917                                if (cstr && cstr_len_displayed < 0)
918                                    s << '"';
919
920                                if (cstr_len_displayed < 0)
921                                    cstr_len_displayed = len;
922
923                                if (len == 0)
924                                    break;
925                                cstr_len_displayed += len;
926                                if (len > bytes_read)
927                                    len = bytes_read;
928                                if (len > cstr_len)
929                                    len = cstr_len;
930
931                                data.Dump (&s,
932                                           0,                 // Start offset in "data"
933                                           item_format,
934                                           1,                 // Size of item (1 byte for a char!)
935                                           len,               // How many bytes to print?
936                                           UINT32_MAX,        // num per line
937                                           LLDB_INVALID_ADDRESS,// base address
938                                           0,                 // bitfield bit size
939                                           0);                // bitfield bit offset
940
941                                if (len < k_max_buf_size)
942                                    break;
943
944                                if (len >= cstr_len)
945                                {
946                                    capped_cstr = true;
947                                    break;
948                                }
949
950                                cstr_len -= len;
951                                offset += len;
952                            }
953
954                            if (cstr_len_displayed >= 0)
955                            {
956                                s << '"';
957                                if (capped_cstr)
958                                    s << "...";
959                            }
960                        }
961                    }
962                }
963            }
964    }
965    else
966    {
967        error.SetErrorString("impossible to read a string from this object");
968        s << "<not a string object>";
969    }
970}
971
972const char *
973ValueObject::GetObjectDescription ()
974{
975
976    if (!UpdateValueIfNeeded (true))
977        return NULL;
978
979    if (!m_object_desc_str.empty())
980        return m_object_desc_str.c_str();
981
982    ExecutionContextScope *exe_scope = GetExecutionContextScope();
983    if (exe_scope == NULL)
984        return NULL;
985
986    Process *process = exe_scope->CalculateProcess();
987    if (process == NULL)
988        return NULL;
989
990    StreamString s;
991
992    LanguageType language = GetObjectRuntimeLanguage();
993    LanguageRuntime *runtime = process->GetLanguageRuntime(language);
994
995    if (runtime == NULL)
996    {
997        // Aw, hell, if the things a pointer, or even just an integer, let's try ObjC anyway...
998        clang_type_t opaque_qual_type = GetClangType();
999        if (opaque_qual_type != NULL)
1000        {
1001            bool is_signed;
1002            if (ClangASTContext::IsIntegerType (opaque_qual_type, is_signed)
1003                || ClangASTContext::IsPointerType (opaque_qual_type))
1004            {
1005                runtime = process->GetLanguageRuntime(eLanguageTypeObjC);
1006            }
1007        }
1008    }
1009
1010    if (runtime && runtime->GetObjectDescription(s, *this))
1011    {
1012        m_object_desc_str.append (s.GetData());
1013    }
1014
1015    if (m_object_desc_str.empty())
1016        return NULL;
1017    else
1018        return m_object_desc_str.c_str();
1019}
1020
1021const char *
1022ValueObject::GetValueAsCString ()
1023{
1024    // If our byte size is zero this is an aggregate type that has children
1025    if (ClangASTContext::IsAggregateType (GetClangType()) == false)
1026    {
1027        if (UpdateValueIfNeeded(true))
1028        {
1029            if (m_value_str.empty())
1030            {
1031                const Value::ContextType context_type = m_value.GetContextType();
1032
1033                switch (context_type)
1034                {
1035                case Value::eContextTypeClangType:
1036                case Value::eContextTypeLLDBType:
1037                case Value::eContextTypeVariable:
1038                    {
1039                        lldb::Format my_format = GetFormat();
1040                        clang_type_t clang_type = GetClangType ();
1041                        if (clang_type)
1042                        {
1043                            if (m_format == lldb::eFormatDefault)
1044                            {
1045                                if (m_last_value_format)
1046                                    my_format = m_last_value_format->GetFormat();
1047                                else
1048                                {
1049                                    if (m_is_bitfield_for_scalar)
1050                                        my_format = eFormatUnsigned;
1051                                    else
1052                                        my_format = ClangASTType::GetFormat(clang_type);
1053                                }
1054                            }
1055                            StreamString sstr;
1056                            if (ClangASTType::DumpTypeValue (GetClangAST(),            // The clang AST
1057                                                             clang_type,               // The clang type to display
1058                                                             &sstr,
1059                                                             my_format,                   // Format to display this type with
1060                                                             m_data,                   // Data to extract from
1061                                                             0,                        // Byte offset into "m_data"
1062                                                             GetByteSize(),            // Byte size of item in "m_data"
1063                                                             GetBitfieldBitSize(),     // Bitfield bit size
1064                                                             GetBitfieldBitOffset(),
1065                                                             GetExecutionContextScope()))  // Bitfield bit offset
1066                                m_value_str.swap(sstr.GetString());
1067                            else
1068                            {
1069                                m_error.SetErrorStringWithFormat ("unsufficient data for value (only %lu of %lu bytes available)",
1070                                                                  m_data.GetByteSize(),
1071                                                                  GetByteSize());
1072                                m_value_str.clear();
1073                            }
1074                        }
1075                    }
1076                    break;
1077
1078                case Value::eContextTypeRegisterInfo:
1079                    {
1080                        const RegisterInfo *reg_info = m_value.GetRegisterInfo();
1081                        if (reg_info)
1082                        {
1083                            lldb::Format my_format = GetFormat();
1084                            if (m_format == lldb::eFormatDefault)
1085                            {
1086                                if (m_last_value_format)
1087                                    my_format = m_last_value_format->GetFormat();
1088                                else
1089                                    my_format = reg_info->format;
1090                            }
1091
1092                            StreamString reg_sstr;
1093                            m_data.Dump(&reg_sstr, 0, my_format, reg_info->byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0, GetExecutionContextScope());
1094                            m_value_str.swap(reg_sstr.GetString());
1095                        }
1096                    }
1097                    break;
1098
1099                default:
1100                    break;
1101                }
1102            }
1103
1104            if (!m_value_did_change && m_old_value_valid)
1105            {
1106                // The value was gotten successfully, so we consider the
1107                // value as changed if the value string differs
1108                SetValueDidChange (m_old_value_str != m_value_str);
1109            }
1110        }
1111    }
1112    if (m_value_str.empty())
1113        return NULL;
1114    return m_value_str.c_str();
1115}
1116
1117// if > 8bytes, 0 is returned. this method should mostly be used
1118// to read address values out of pointers
1119uint64_t
1120ValueObject::GetValueAsUnsigned (uint64_t fail_value)
1121{
1122    // If our byte size is zero this is an aggregate type that has children
1123    if (ClangASTContext::IsAggregateType (GetClangType()) == false)
1124    {
1125        Scalar scalar;
1126        if (ResolveValue (scalar))
1127            return scalar.GetRawBits64(fail_value);
1128    }
1129    return fail_value;
1130}
1131
1132bool
1133ValueObject::GetPrintableRepresentation(Stream& s,
1134                                        ValueObjectRepresentationStyle val_obj_display,
1135                                        Format custom_format)
1136{
1137
1138    if (custom_format != eFormatInvalid)
1139        SetFormat(custom_format);
1140
1141    const char * return_value;
1142    std::string alloc_mem;
1143
1144    switch(val_obj_display)
1145    {
1146        case eDisplayValue:
1147            return_value = GetValueAsCString();
1148            break;
1149
1150        case eDisplaySummary:
1151            return_value = GetSummaryAsCString();
1152            break;
1153
1154        case eDisplayLanguageSpecific:
1155            return_value = GetObjectDescription();
1156            break;
1157
1158        case eDisplayLocation:
1159            return_value = GetLocationAsCString();
1160            break;
1161
1162        case eDisplayChildrenCount:
1163            {
1164                alloc_mem.resize(512);
1165                return_value = &alloc_mem[0];
1166                int count = GetNumChildren();
1167                snprintf((char*)return_value, 512, "%d", count);
1168            }
1169            break;
1170
1171        case eDisplayType:
1172            return_value = GetTypeName().AsCString();
1173            break;
1174
1175        default:
1176            break;
1177    }
1178
1179    if (!return_value)
1180    {
1181        if (val_obj_display == eDisplayValue)
1182            return_value = GetSummaryAsCString();
1183        else if (val_obj_display == eDisplaySummary)
1184        {
1185            if (ClangASTContext::IsAggregateType (GetClangType()) == true)
1186            {
1187                // this thing has no value, and it seems to have no summary
1188                // some combination of unitialized data and other factors can also
1189                // raise this condition, so let's print a nice generic description
1190                {
1191                    alloc_mem.resize(684);
1192                    return_value = &alloc_mem[0];
1193                    snprintf((char*)return_value, 684, "%s @ %s", GetTypeName().AsCString(), GetLocationAsCString());
1194                }
1195            }
1196            else
1197                return_value = GetValueAsCString();
1198        }
1199    }
1200
1201    if (return_value)
1202        s.PutCString(return_value);
1203    else
1204    {
1205        if (m_error.Fail())
1206            s.Printf("<%s>", m_error.AsCString());
1207        else if (val_obj_display == eDisplaySummary)
1208            s.PutCString("<no summary available>");
1209        else if (val_obj_display == eDisplayValue)
1210            s.PutCString("<no value available>");
1211        else if (val_obj_display == eDisplayLanguageSpecific)
1212            s.PutCString("<not a valid Objective-C object>"); // edit this if we have other runtimes that support a description
1213        else
1214            s.PutCString("<no printable representation>");
1215    }
1216
1217    // we should only return false here if we could not do *anything*
1218    // even if we have an error message as output, that's a success
1219    // from our callers' perspective, so return true
1220    return true;
1221
1222}
1223
1224// if any more "special cases" are added to ValueObject::DumpPrintableRepresentation() please keep
1225// this call up to date by returning true for your new special cases. We will eventually move
1226// to checking this call result before trying to display special cases
1227bool
1228ValueObject::HasSpecialCasesForPrintableRepresentation(ValueObjectRepresentationStyle val_obj_display,
1229                                                       Format custom_format)
1230{
1231    clang_type_t elem_or_pointee_type;
1232    Flags flags(ClangASTContext::GetTypeInfo(GetClangType(), GetClangAST(), &elem_or_pointee_type));
1233
1234    if (flags.AnySet(ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer)
1235        && val_obj_display == ValueObject::eDisplayValue)
1236    {
1237        if (IsCStringContainer(true) &&
1238            (custom_format == eFormatCString ||
1239             custom_format == eFormatCharArray ||
1240             custom_format == eFormatChar ||
1241             custom_format == eFormatVectorOfChar))
1242            return true;
1243
1244        if (flags.Test(ClangASTContext::eTypeIsArray))
1245        {
1246            if ((custom_format == eFormatBytes) ||
1247                (custom_format == eFormatBytesWithASCII))
1248                return true;
1249
1250            if ((custom_format == eFormatVectorOfChar) ||
1251                (custom_format == eFormatVectorOfFloat32) ||
1252                (custom_format == eFormatVectorOfFloat64) ||
1253                (custom_format == eFormatVectorOfSInt16) ||
1254                (custom_format == eFormatVectorOfSInt32) ||
1255                (custom_format == eFormatVectorOfSInt64) ||
1256                (custom_format == eFormatVectorOfSInt8) ||
1257                (custom_format == eFormatVectorOfUInt128) ||
1258                (custom_format == eFormatVectorOfUInt16) ||
1259                (custom_format == eFormatVectorOfUInt32) ||
1260                (custom_format == eFormatVectorOfUInt64) ||
1261                (custom_format == eFormatVectorOfUInt8))
1262                return true;
1263        }
1264    }
1265    return false;
1266}
1267
1268bool
1269ValueObject::DumpPrintableRepresentation(Stream& s,
1270                                         ValueObjectRepresentationStyle val_obj_display,
1271                                         Format custom_format,
1272                                         bool only_special)
1273{
1274
1275    clang_type_t elem_or_pointee_type;
1276    Flags flags(ClangASTContext::GetTypeInfo(GetClangType(), GetClangAST(), &elem_or_pointee_type));
1277
1278    if (flags.AnySet(ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer)
1279         && val_obj_display == ValueObject::eDisplayValue)
1280    {
1281        // when being asked to get a printable display an array or pointer type directly,
1282        // try to "do the right thing"
1283
1284        if (IsCStringContainer(true) &&
1285            (custom_format == eFormatCString ||
1286             custom_format == eFormatCharArray ||
1287             custom_format == eFormatChar ||
1288             custom_format == eFormatVectorOfChar)) // print char[] & char* directly
1289        {
1290            Error error;
1291            ReadPointedString(s,
1292                              error,
1293                              0,
1294                              (custom_format == eFormatVectorOfChar) ||
1295                              (custom_format == eFormatCharArray));
1296            return !error.Fail();
1297        }
1298
1299        if (custom_format == eFormatEnum)
1300            return false;
1301
1302        // this only works for arrays, because I have no way to know when
1303        // the pointed memory ends, and no special \0 end of data marker
1304        if (flags.Test(ClangASTContext::eTypeIsArray))
1305        {
1306            if ((custom_format == eFormatBytes) ||
1307                (custom_format == eFormatBytesWithASCII))
1308            {
1309                uint32_t count = GetNumChildren();
1310
1311                s << '[';
1312                for (uint32_t low = 0; low < count; low++)
1313                {
1314
1315                    if (low)
1316                        s << ',';
1317
1318                    ValueObjectSP child = GetChildAtIndex(low,true);
1319                    if (!child.get())
1320                    {
1321                        s << "<invalid child>";
1322                        continue;
1323                    }
1324                    child->DumpPrintableRepresentation(s, ValueObject::eDisplayValue, custom_format);
1325                }
1326
1327                s << ']';
1328
1329                return true;
1330            }
1331
1332            if ((custom_format == eFormatVectorOfChar) ||
1333                (custom_format == eFormatVectorOfFloat32) ||
1334                (custom_format == eFormatVectorOfFloat64) ||
1335                (custom_format == eFormatVectorOfSInt16) ||
1336                (custom_format == eFormatVectorOfSInt32) ||
1337                (custom_format == eFormatVectorOfSInt64) ||
1338                (custom_format == eFormatVectorOfSInt8) ||
1339                (custom_format == eFormatVectorOfUInt128) ||
1340                (custom_format == eFormatVectorOfUInt16) ||
1341                (custom_format == eFormatVectorOfUInt32) ||
1342                (custom_format == eFormatVectorOfUInt64) ||
1343                (custom_format == eFormatVectorOfUInt8)) // arrays of bytes, bytes with ASCII or any vector format should be printed directly
1344            {
1345                uint32_t count = GetNumChildren();
1346
1347                Format format = FormatManager::GetSingleItemFormat(custom_format);
1348
1349                s << '[';
1350                for (uint32_t low = 0; low < count; low++)
1351                {
1352
1353                    if (low)
1354                        s << ',';
1355
1356                    ValueObjectSP child = GetChildAtIndex(low,true);
1357                    if (!child.get())
1358                    {
1359                        s << "<invalid child>";
1360                        continue;
1361                    }
1362                    child->DumpPrintableRepresentation(s, ValueObject::eDisplayValue, format);
1363                }
1364
1365                s << ']';
1366
1367                return true;
1368            }
1369        }
1370
1371        if ((custom_format == eFormatBoolean) ||
1372            (custom_format == eFormatBinary) ||
1373            (custom_format == eFormatChar) ||
1374            (custom_format == eFormatCharPrintable) ||
1375            (custom_format == eFormatComplexFloat) ||
1376            (custom_format == eFormatDecimal) ||
1377            (custom_format == eFormatHex) ||
1378            (custom_format == eFormatFloat) ||
1379            (custom_format == eFormatOctal) ||
1380            (custom_format == eFormatOSType) ||
1381            (custom_format == eFormatUnicode16) ||
1382            (custom_format == eFormatUnicode32) ||
1383            (custom_format == eFormatUnsigned) ||
1384            (custom_format == eFormatPointer) ||
1385            (custom_format == eFormatComplexInteger) ||
1386            (custom_format == eFormatComplex) ||
1387            (custom_format == eFormatDefault)) // use the [] operator
1388            return false;
1389    }
1390
1391    if (only_special)
1392        return false;
1393
1394    bool var_success = GetPrintableRepresentation(s, val_obj_display, custom_format);
1395    if (custom_format != eFormatInvalid)
1396        SetFormat(eFormatDefault);
1397    return var_success;
1398}
1399
1400addr_t
1401ValueObject::GetAddressOf (bool scalar_is_load_address, AddressType *address_type)
1402{
1403    if (!UpdateValueIfNeeded(false))
1404        return LLDB_INVALID_ADDRESS;
1405
1406    switch (m_value.GetValueType())
1407    {
1408    case Value::eValueTypeScalar:
1409        if (scalar_is_load_address)
1410        {
1411            if(address_type)
1412                *address_type = eAddressTypeLoad;
1413            return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1414        }
1415        break;
1416
1417    case Value::eValueTypeLoadAddress:
1418    case Value::eValueTypeFileAddress:
1419    case Value::eValueTypeHostAddress:
1420        {
1421            if(address_type)
1422                *address_type = m_value.GetValueAddressType ();
1423            return m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1424        }
1425        break;
1426    }
1427    if (address_type)
1428        *address_type = eAddressTypeInvalid;
1429    return LLDB_INVALID_ADDRESS;
1430}
1431
1432addr_t
1433ValueObject::GetPointerValue (AddressType *address_type)
1434{
1435    addr_t address = LLDB_INVALID_ADDRESS;
1436    if(address_type)
1437        *address_type = eAddressTypeInvalid;
1438
1439    if (!UpdateValueIfNeeded(false))
1440        return address;
1441
1442    switch (m_value.GetValueType())
1443    {
1444    case Value::eValueTypeScalar:
1445        address = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
1446        break;
1447
1448    case Value::eValueTypeHostAddress:
1449    case Value::eValueTypeLoadAddress:
1450    case Value::eValueTypeFileAddress:
1451        {
1452            uint32_t data_offset = 0;
1453            address = m_data.GetPointer(&data_offset);
1454        }
1455        break;
1456    }
1457
1458    if (address_type)
1459        *address_type = GetAddressTypeOfChildren();
1460
1461    return address;
1462}
1463
1464bool
1465ValueObject::SetValueFromCString (const char *value_str)
1466{
1467    // Make sure our value is up to date first so that our location and location
1468    // type is valid.
1469    if (!UpdateValueIfNeeded(false))
1470        return false;
1471
1472    uint32_t count = 0;
1473    Encoding encoding = ClangASTType::GetEncoding (GetClangType(), count);
1474
1475    const size_t byte_size = GetByteSize();
1476
1477    Value::ValueType value_type = m_value.GetValueType();
1478
1479    if (value_type == Value::eValueTypeScalar)
1480    {
1481        // If the value is already a scalar, then let the scalar change itself:
1482        m_value.GetScalar().SetValueFromCString (value_str, encoding, byte_size);
1483    }
1484    else if (byte_size <= Scalar::GetMaxByteSize())
1485    {
1486        // If the value fits in a scalar, then make a new scalar and again let the
1487        // scalar code do the conversion, then figure out where to put the new value.
1488        Scalar new_scalar;
1489        Error error;
1490        error = new_scalar.SetValueFromCString (value_str, encoding, byte_size);
1491        if (error.Success())
1492        {
1493            switch (value_type)
1494            {
1495                case Value::eValueTypeLoadAddress:
1496                {
1497                    // If it is a load address, then the scalar value is the storage location
1498                    // of the data, and we have to shove this value down to that load location.
1499                    ProcessSP process_sp = GetUpdatePoint().GetProcessSP();
1500                    if (process_sp)
1501                    {
1502                        addr_t target_addr = m_value.GetScalar().GetRawBits64(LLDB_INVALID_ADDRESS);
1503                        size_t bytes_written = process_sp->WriteScalarToMemory (target_addr,
1504                                                                            new_scalar,
1505                                                                            byte_size,
1506                                                                            error);
1507                        if (!error.Success() || bytes_written != byte_size)
1508                            return false;
1509                    }
1510                }
1511                break;
1512                case Value::eValueTypeHostAddress:
1513                {
1514                    // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data.
1515                    DataExtractor new_data;
1516                    new_data.SetByteOrder (m_data.GetByteOrder());
1517
1518                    DataBufferSP buffer_sp (new DataBufferHeap(byte_size, 0));
1519                    m_data.SetData(buffer_sp, 0);
1520                    bool success = new_scalar.GetData(new_data);
1521                    if (success)
1522                    {
1523                        new_data.CopyByteOrderedData(0,
1524                                                     byte_size,
1525                                                     const_cast<uint8_t *>(m_data.GetDataStart()),
1526                                                     byte_size,
1527                                                     m_data.GetByteOrder());
1528                    }
1529                    m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
1530
1531                }
1532                break;
1533                case Value::eValueTypeFileAddress:
1534                case Value::eValueTypeScalar:
1535                break;
1536            }
1537        }
1538        else
1539        {
1540            return false;
1541        }
1542    }
1543    else
1544    {
1545        // We don't support setting things bigger than a scalar at present.
1546        return false;
1547    }
1548
1549    // If we have reached this point, then we have successfully changed the value.
1550    SetNeedsUpdate();
1551    return true;
1552}
1553
1554bool
1555ValueObject::GetDeclaration (Declaration &decl)
1556{
1557    decl.Clear();
1558    return false;
1559}
1560
1561LanguageType
1562ValueObject::GetObjectRuntimeLanguage ()
1563{
1564    return ClangASTType::GetMinimumLanguage (GetClangAST(),
1565                                             GetClangType());
1566}
1567
1568void
1569ValueObject::AddSyntheticChild (const ConstString &key, ValueObject *valobj)
1570{
1571    m_synthetic_children[key] = valobj;
1572}
1573
1574ValueObjectSP
1575ValueObject::GetSyntheticChild (const ConstString &key) const
1576{
1577    ValueObjectSP synthetic_child_sp;
1578    std::map<ConstString, ValueObject *>::const_iterator pos = m_synthetic_children.find (key);
1579    if (pos != m_synthetic_children.end())
1580        synthetic_child_sp = pos->second->GetSP();
1581    return synthetic_child_sp;
1582}
1583
1584bool
1585ValueObject::IsPointerType ()
1586{
1587    return ClangASTContext::IsPointerType (GetClangType());
1588}
1589
1590bool
1591ValueObject::IsArrayType ()
1592{
1593    return ClangASTContext::IsArrayType (GetClangType());
1594}
1595
1596bool
1597ValueObject::IsScalarType ()
1598{
1599    return ClangASTContext::IsScalarType (GetClangType());
1600}
1601
1602bool
1603ValueObject::IsIntegerType (bool &is_signed)
1604{
1605    return ClangASTContext::IsIntegerType (GetClangType(), is_signed);
1606}
1607
1608bool
1609ValueObject::IsPointerOrReferenceType ()
1610{
1611    return ClangASTContext::IsPointerOrReferenceType (GetClangType());
1612}
1613
1614bool
1615ValueObject::IsPossibleCPlusPlusDynamicType ()
1616{
1617    return ClangASTContext::IsPossibleCPlusPlusDynamicType (GetClangAST (), GetClangType());
1618}
1619
1620bool
1621ValueObject::IsPossibleDynamicType ()
1622{
1623    return ClangASTContext::IsPossibleDynamicType (GetClangAST (), GetClangType());
1624}
1625
1626ValueObjectSP
1627ValueObject::GetSyntheticArrayMember (int32_t index, bool can_create)
1628{
1629    if (IsArrayType())
1630        return GetSyntheticArrayMemberFromArray(index, can_create);
1631
1632    if (IsPointerType())
1633        return GetSyntheticArrayMemberFromPointer(index, can_create);
1634
1635    return ValueObjectSP();
1636
1637}
1638
1639ValueObjectSP
1640ValueObject::GetSyntheticArrayMemberFromPointer (int32_t index, bool can_create)
1641{
1642    ValueObjectSP synthetic_child_sp;
1643    if (IsPointerType ())
1644    {
1645        char index_str[64];
1646        snprintf(index_str, sizeof(index_str), "[%i]", index);
1647        ConstString index_const_str(index_str);
1648        // Check if we have already created a synthetic array member in this
1649        // valid object. If we have we will re-use it.
1650        synthetic_child_sp = GetSyntheticChild (index_const_str);
1651        if (!synthetic_child_sp)
1652        {
1653            ValueObject *synthetic_child;
1654            // We haven't made a synthetic array member for INDEX yet, so
1655            // lets make one and cache it for any future reference.
1656            synthetic_child = CreateChildAtIndex(0, true, index);
1657
1658            // Cache the value if we got one back...
1659            if (synthetic_child)
1660            {
1661                AddSyntheticChild(index_const_str, synthetic_child);
1662                synthetic_child_sp = synthetic_child->GetSP();
1663                synthetic_child_sp->SetName(ConstString(index_str));
1664                synthetic_child_sp->m_is_array_item_for_pointer = true;
1665            }
1666        }
1667    }
1668    return synthetic_child_sp;
1669}
1670
1671// This allows you to create an array member using and index
1672// that doesn't not fall in the normal bounds of the array.
1673// Many times structure can be defined as:
1674// struct Collection
1675// {
1676//     uint32_t item_count;
1677//     Item item_array[0];
1678// };
1679// The size of the "item_array" is 1, but many times in practice
1680// there are more items in "item_array".
1681
1682ValueObjectSP
1683ValueObject::GetSyntheticArrayMemberFromArray (int32_t index, bool can_create)
1684{
1685    ValueObjectSP synthetic_child_sp;
1686    if (IsArrayType ())
1687    {
1688        char index_str[64];
1689        snprintf(index_str, sizeof(index_str), "[%i]", index);
1690        ConstString index_const_str(index_str);
1691        // Check if we have already created a synthetic array member in this
1692        // valid object. If we have we will re-use it.
1693        synthetic_child_sp = GetSyntheticChild (index_const_str);
1694        if (!synthetic_child_sp)
1695        {
1696            ValueObject *synthetic_child;
1697            // We haven't made a synthetic array member for INDEX yet, so
1698            // lets make one and cache it for any future reference.
1699            synthetic_child = CreateChildAtIndex(0, true, index);
1700
1701            // Cache the value if we got one back...
1702            if (synthetic_child)
1703            {
1704                AddSyntheticChild(index_const_str, synthetic_child);
1705                synthetic_child_sp = synthetic_child->GetSP();
1706                synthetic_child_sp->SetName(ConstString(index_str));
1707                synthetic_child_sp->m_is_array_item_for_pointer = true;
1708            }
1709        }
1710    }
1711    return synthetic_child_sp;
1712}
1713
1714ValueObjectSP
1715ValueObject::GetSyntheticBitFieldChild (uint32_t from, uint32_t to, bool can_create)
1716{
1717    ValueObjectSP synthetic_child_sp;
1718    if (IsScalarType ())
1719    {
1720        char index_str[64];
1721        snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to);
1722        ConstString index_const_str(index_str);
1723        // Check if we have already created a synthetic array member in this
1724        // valid object. If we have we will re-use it.
1725        synthetic_child_sp = GetSyntheticChild (index_const_str);
1726        if (!synthetic_child_sp)
1727        {
1728            ValueObjectChild *synthetic_child;
1729            // We haven't made a synthetic array member for INDEX yet, so
1730            // lets make one and cache it for any future reference.
1731            synthetic_child = new ValueObjectChild(*this,
1732                                                      GetClangAST(),
1733                                                      GetClangType(),
1734                                                      index_const_str,
1735                                                      GetByteSize(),
1736                                                      0,
1737                                                      to-from+1,
1738                                                      from,
1739                                                      false,
1740                                                      false,
1741                                                      eAddressTypeInvalid);
1742
1743            // Cache the value if we got one back...
1744            if (synthetic_child)
1745            {
1746                AddSyntheticChild(index_const_str, synthetic_child);
1747                synthetic_child_sp = synthetic_child->GetSP();
1748                synthetic_child_sp->SetName(ConstString(index_str));
1749                synthetic_child_sp->m_is_bitfield_for_scalar = true;
1750            }
1751        }
1752    }
1753    return synthetic_child_sp;
1754}
1755
1756ValueObjectSP
1757ValueObject::GetSyntheticArrayRangeChild (uint32_t from, uint32_t to, bool can_create)
1758{
1759    ValueObjectSP synthetic_child_sp;
1760    if (IsArrayType () || IsPointerType ())
1761    {
1762        char index_str[64];
1763        snprintf(index_str, sizeof(index_str), "[%i-%i]", from, to);
1764        ConstString index_const_str(index_str);
1765        // Check if we have already created a synthetic array member in this
1766        // valid object. If we have we will re-use it.
1767        synthetic_child_sp = GetSyntheticChild (index_const_str);
1768        if (!synthetic_child_sp)
1769        {
1770            ValueObjectSynthetic *synthetic_child;
1771
1772            // We haven't made a synthetic array member for INDEX yet, so
1773            // lets make one and cache it for any future reference.
1774            SyntheticArrayView *view = new SyntheticArrayView();
1775            view->AddRange(from,to);
1776            SyntheticChildrenSP view_sp(view);
1777            synthetic_child = new ValueObjectSynthetic(*this, view_sp);
1778
1779            // Cache the value if we got one back...
1780            if (synthetic_child)
1781            {
1782                AddSyntheticChild(index_const_str, synthetic_child);
1783                synthetic_child_sp = synthetic_child->GetSP();
1784                synthetic_child_sp->SetName(ConstString(index_str));
1785                synthetic_child_sp->m_is_bitfield_for_scalar = true;
1786            }
1787        }
1788    }
1789    return synthetic_child_sp;
1790}
1791
1792ValueObjectSP
1793ValueObject::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
1794{
1795
1796    ValueObjectSP synthetic_child_sp;
1797
1798    char name_str[64];
1799    snprintf(name_str, sizeof(name_str), "@%i", offset);
1800    ConstString name_const_str(name_str);
1801
1802    // Check if we have already created a synthetic array member in this
1803    // valid object. If we have we will re-use it.
1804    synthetic_child_sp = GetSyntheticChild (name_const_str);
1805
1806    if (synthetic_child_sp.get())
1807        return synthetic_child_sp;
1808
1809    if (!can_create)
1810        return ValueObjectSP();
1811
1812    ValueObjectChild *synthetic_child = new ValueObjectChild(*this,
1813                                                             type.GetASTContext(),
1814                                                             type.GetOpaqueQualType(),
1815                                                             name_const_str,
1816                                                             type.GetTypeByteSize(),
1817                                                             offset,
1818                                                             0,
1819                                                             0,
1820                                                             false,
1821                                                             false,
1822                                                             eAddressTypeInvalid);
1823    if (synthetic_child)
1824    {
1825        AddSyntheticChild(name_const_str, synthetic_child);
1826        synthetic_child_sp = synthetic_child->GetSP();
1827        synthetic_child_sp->SetName(name_const_str);
1828        synthetic_child_sp->m_is_child_at_offset = true;
1829    }
1830    return synthetic_child_sp;
1831}
1832
1833// your expression path needs to have a leading . or ->
1834// (unless it somehow "looks like" an array, in which case it has
1835// a leading [ symbol). while the [ is meaningful and should be shown
1836// to the user, . and -> are just parser design, but by no means
1837// added information for the user.. strip them off
1838static const char*
1839SkipLeadingExpressionPathSeparators(const char* expression)
1840{
1841    if (!expression || !expression[0])
1842        return expression;
1843    if (expression[0] == '.')
1844        return expression+1;
1845    if (expression[0] == '-' && expression[1] == '>')
1846        return expression+2;
1847    return expression;
1848}
1849
1850ValueObjectSP
1851ValueObject::GetSyntheticExpressionPathChild(const char* expression, bool can_create)
1852{
1853    ValueObjectSP synthetic_child_sp;
1854    ConstString name_const_string(expression);
1855    // Check if we have already created a synthetic array member in this
1856    // valid object. If we have we will re-use it.
1857    synthetic_child_sp = GetSyntheticChild (name_const_string);
1858    if (!synthetic_child_sp)
1859    {
1860        // We haven't made a synthetic array member for expression yet, so
1861        // lets make one and cache it for any future reference.
1862        synthetic_child_sp = GetValueForExpressionPath(expression);
1863
1864        // Cache the value if we got one back...
1865        if (synthetic_child_sp.get())
1866        {
1867            AddSyntheticChild(name_const_string, synthetic_child_sp.get());
1868            synthetic_child_sp->SetName(ConstString(SkipLeadingExpressionPathSeparators(expression)));
1869            synthetic_child_sp->m_is_expression_path_child = true;
1870        }
1871    }
1872    return synthetic_child_sp;
1873}
1874
1875void
1876ValueObject::CalculateSyntheticValue (SyntheticValueType use_synthetic)
1877{
1878    if (use_synthetic == eNoSyntheticFilter)
1879        return;
1880
1881    UpdateFormatsIfNeeded(m_last_format_mgr_dynamic);
1882
1883    if (m_last_synthetic_filter.get() == NULL)
1884        return;
1885
1886    if (m_synthetic_value == NULL)
1887        m_synthetic_value = new ValueObjectSynthetic(*this, m_last_synthetic_filter);
1888
1889}
1890
1891void
1892ValueObject::CalculateDynamicValue (DynamicValueType use_dynamic)
1893{
1894    if (use_dynamic == eNoDynamicValues)
1895        return;
1896
1897    if (!m_dynamic_value && !IsDynamic())
1898    {
1899        Process *process = m_update_point.GetProcessSP().get();
1900        bool worth_having_dynamic_value = false;
1901
1902
1903        // FIXME: Process should have some kind of "map over Runtimes" so we don't have to
1904        // hard code this everywhere.
1905        LanguageType known_type = GetObjectRuntimeLanguage();
1906        if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
1907        {
1908            LanguageRuntime *runtime = process->GetLanguageRuntime (known_type);
1909            if (runtime)
1910                worth_having_dynamic_value = runtime->CouldHaveDynamicValue(*this);
1911        }
1912        else
1913        {
1914            LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (eLanguageTypeC_plus_plus);
1915            if (cpp_runtime)
1916                worth_having_dynamic_value = cpp_runtime->CouldHaveDynamicValue(*this);
1917
1918            if (!worth_having_dynamic_value)
1919            {
1920                LanguageRuntime *objc_runtime = process->GetLanguageRuntime (eLanguageTypeObjC);
1921                if (objc_runtime)
1922                    worth_having_dynamic_value = objc_runtime->CouldHaveDynamicValue(*this);
1923            }
1924        }
1925
1926        if (worth_having_dynamic_value)
1927            m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
1928
1929//        if (worth_having_dynamic_value)
1930//            printf ("Adding dynamic value %s (%p) to (%p) - manager %p.\n", m_name.GetCString(), m_dynamic_value, this, m_manager);
1931
1932    }
1933}
1934
1935ValueObjectSP
1936ValueObject::GetDynamicValue (DynamicValueType use_dynamic)
1937{
1938    if (use_dynamic == eNoDynamicValues)
1939        return ValueObjectSP();
1940
1941    if (!IsDynamic() && m_dynamic_value == NULL)
1942    {
1943        CalculateDynamicValue(use_dynamic);
1944    }
1945    if (m_dynamic_value)
1946        return m_dynamic_value->GetSP();
1947    else
1948        return ValueObjectSP();
1949}
1950
1951ValueObjectSP
1952ValueObject::GetStaticValue()
1953{
1954    return GetSP();
1955}
1956
1957// GetDynamicValue() returns a NULL SharedPointer if the object is not dynamic
1958// or we do not really want a dynamic VO. this method instead returns this object
1959// itself when making it synthetic has no meaning. this makes it much simpler
1960// to replace the SyntheticValue for the ValueObject
1961ValueObjectSP
1962ValueObject::GetSyntheticValue (SyntheticValueType use_synthetic)
1963{
1964    if (use_synthetic == eNoSyntheticFilter)
1965        return GetSP();
1966
1967    UpdateFormatsIfNeeded(m_last_format_mgr_dynamic);
1968
1969    if (m_last_synthetic_filter.get() == NULL)
1970        return GetSP();
1971
1972    CalculateSyntheticValue(use_synthetic);
1973
1974    if (m_synthetic_value)
1975        return m_synthetic_value->GetSP();
1976    else
1977        return GetSP();
1978}
1979
1980bool
1981ValueObject::HasSyntheticValue()
1982{
1983    UpdateFormatsIfNeeded(m_last_format_mgr_dynamic);
1984
1985    if (m_last_synthetic_filter.get() == NULL)
1986        return false;
1987
1988    CalculateSyntheticValue(eUseSyntheticFilter);
1989
1990    if (m_synthetic_value)
1991        return true;
1992    else
1993        return false;
1994}
1995
1996bool
1997ValueObject::GetBaseClassPath (Stream &s)
1998{
1999    if (IsBaseClass())
2000    {
2001        bool parent_had_base_class = GetParent() && GetParent()->GetBaseClassPath (s);
2002        clang_type_t clang_type = GetClangType();
2003        std::string cxx_class_name;
2004        bool this_had_base_class = ClangASTContext::GetCXXClassName (clang_type, cxx_class_name);
2005        if (this_had_base_class)
2006        {
2007            if (parent_had_base_class)
2008                s.PutCString("::");
2009            s.PutCString(cxx_class_name.c_str());
2010        }
2011        return parent_had_base_class || this_had_base_class;
2012    }
2013    return false;
2014}
2015
2016
2017ValueObject *
2018ValueObject::GetNonBaseClassParent()
2019{
2020    if (GetParent())
2021    {
2022        if (GetParent()->IsBaseClass())
2023            return GetParent()->GetNonBaseClassParent();
2024        else
2025            return GetParent();
2026    }
2027    return NULL;
2028}
2029
2030void
2031ValueObject::GetExpressionPath (Stream &s, bool qualify_cxx_base_classes, GetExpressionPathFormat epformat)
2032{
2033    const bool is_deref_of_parent = IsDereferenceOfParent ();
2034
2035    if (is_deref_of_parent && epformat == eDereferencePointers)
2036    {
2037        // this is the original format of GetExpressionPath() producing code like *(a_ptr).memberName, which is entirely
2038        // fine, until you put this into StackFrame::GetValueForVariableExpressionPath() which prefers to see a_ptr->memberName.
2039        // the eHonorPointers mode is meant to produce strings in this latter format
2040        s.PutCString("*(");
2041    }
2042
2043    ValueObject* parent = GetParent();
2044
2045    if (parent)
2046        parent->GetExpressionPath (s, qualify_cxx_base_classes, epformat);
2047
2048    // if we are a deref_of_parent just because we are synthetic array
2049    // members made up to allow ptr[%d] syntax to work in variable
2050    // printing, then add our name ([%d]) to the expression path
2051    if (m_is_array_item_for_pointer && epformat == eHonorPointers)
2052        s.PutCString(m_name.AsCString());
2053
2054    if (!IsBaseClass())
2055    {
2056        if (!is_deref_of_parent)
2057        {
2058            ValueObject *non_base_class_parent = GetNonBaseClassParent();
2059            if (non_base_class_parent)
2060            {
2061                clang_type_t non_base_class_parent_clang_type = non_base_class_parent->GetClangType();
2062                if (non_base_class_parent_clang_type)
2063                {
2064                    const uint32_t non_base_class_parent_type_info = ClangASTContext::GetTypeInfo (non_base_class_parent_clang_type, NULL, NULL);
2065
2066                    if (parent && parent->IsDereferenceOfParent() && epformat == eHonorPointers)
2067                    {
2068                        s.PutCString("->");
2069                    }
2070                    else
2071                    {
2072                        if (non_base_class_parent_type_info & ClangASTContext::eTypeIsPointer)
2073                        {
2074                            s.PutCString("->");
2075                        }
2076                        else if ((non_base_class_parent_type_info & ClangASTContext::eTypeHasChildren) &&
2077                                 !(non_base_class_parent_type_info & ClangASTContext::eTypeIsArray))
2078                        {
2079                            s.PutChar('.');
2080                        }
2081                    }
2082                }
2083            }
2084
2085            const char *name = GetName().GetCString();
2086            if (name)
2087            {
2088                if (qualify_cxx_base_classes)
2089                {
2090                    if (GetBaseClassPath (s))
2091                        s.PutCString("::");
2092                }
2093                s.PutCString(name);
2094            }
2095        }
2096    }
2097
2098    if (is_deref_of_parent && epformat == eDereferencePointers)
2099    {
2100        s.PutChar(')');
2101    }
2102}
2103
2104ValueObjectSP
2105ValueObject::GetValueForExpressionPath(const char* expression,
2106                                       const char** first_unparsed,
2107                                       ExpressionPathScanEndReason* reason_to_stop,
2108                                       ExpressionPathEndResultType* final_value_type,
2109                                       const GetValueForExpressionPathOptions& options,
2110                                       ExpressionPathAftermath* final_task_on_target)
2111{
2112
2113    const char* dummy_first_unparsed;
2114    ExpressionPathScanEndReason dummy_reason_to_stop;
2115    ExpressionPathEndResultType dummy_final_value_type;
2116    ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eNothing;
2117
2118    ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2119                                                           first_unparsed ? first_unparsed : &dummy_first_unparsed,
2120                                                           reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2121                                                           final_value_type ? final_value_type : &dummy_final_value_type,
2122                                                           options,
2123                                                           final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2124
2125    if (!final_task_on_target || *final_task_on_target == ValueObject::eNothing)
2126    {
2127        return ret_val;
2128    }
2129    if (ret_val.get() && *final_value_type == ePlain) // I can only deref and takeaddress of plain objects
2130    {
2131        if (*final_task_on_target == ValueObject::eDereference)
2132        {
2133            Error error;
2134            ValueObjectSP final_value = ret_val->Dereference(error);
2135            if (error.Fail() || !final_value.get())
2136            {
2137                *reason_to_stop = ValueObject::eDereferencingFailed;
2138                *final_value_type = ValueObject::eInvalid;
2139                return ValueObjectSP();
2140            }
2141            else
2142            {
2143                *final_task_on_target = ValueObject::eNothing;
2144                return final_value;
2145            }
2146        }
2147        if (*final_task_on_target == ValueObject::eTakeAddress)
2148        {
2149            Error error;
2150            ValueObjectSP final_value = ret_val->AddressOf(error);
2151            if (error.Fail() || !final_value.get())
2152            {
2153                *reason_to_stop = ValueObject::eTakingAddressFailed;
2154                *final_value_type = ValueObject::eInvalid;
2155                return ValueObjectSP();
2156            }
2157            else
2158            {
2159                *final_task_on_target = ValueObject::eNothing;
2160                return final_value;
2161            }
2162        }
2163    }
2164    return ret_val; // final_task_on_target will still have its original value, so you know I did not do it
2165}
2166
2167int
2168ValueObject::GetValuesForExpressionPath(const char* expression,
2169                                        ValueObjectListSP& list,
2170                                        const char** first_unparsed,
2171                                        ExpressionPathScanEndReason* reason_to_stop,
2172                                        ExpressionPathEndResultType* final_value_type,
2173                                        const GetValueForExpressionPathOptions& options,
2174                                        ExpressionPathAftermath* final_task_on_target)
2175{
2176    const char* dummy_first_unparsed;
2177    ExpressionPathScanEndReason dummy_reason_to_stop;
2178    ExpressionPathEndResultType dummy_final_value_type;
2179    ExpressionPathAftermath dummy_final_task_on_target = ValueObject::eNothing;
2180
2181    ValueObjectSP ret_val = GetValueForExpressionPath_Impl(expression,
2182                                                           first_unparsed ? first_unparsed : &dummy_first_unparsed,
2183                                                           reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2184                                                           final_value_type ? final_value_type : &dummy_final_value_type,
2185                                                           options,
2186                                                           final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2187
2188    if (!ret_val.get()) // if there are errors, I add nothing to the list
2189        return 0;
2190
2191    if (*reason_to_stop != eArrayRangeOperatorMet)
2192    {
2193        // I need not expand a range, just post-process the final value and return
2194        if (!final_task_on_target || *final_task_on_target == ValueObject::eNothing)
2195        {
2196            list->Append(ret_val);
2197            return 1;
2198        }
2199        if (ret_val.get() && *final_value_type == ePlain) // I can only deref and takeaddress of plain objects
2200        {
2201            if (*final_task_on_target == ValueObject::eDereference)
2202            {
2203                Error error;
2204                ValueObjectSP final_value = ret_val->Dereference(error);
2205                if (error.Fail() || !final_value.get())
2206                {
2207                    *reason_to_stop = ValueObject::eDereferencingFailed;
2208                    *final_value_type = ValueObject::eInvalid;
2209                    return 0;
2210                }
2211                else
2212                {
2213                    *final_task_on_target = ValueObject::eNothing;
2214                    list->Append(final_value);
2215                    return 1;
2216                }
2217            }
2218            if (*final_task_on_target == ValueObject::eTakeAddress)
2219            {
2220                Error error;
2221                ValueObjectSP final_value = ret_val->AddressOf(error);
2222                if (error.Fail() || !final_value.get())
2223                {
2224                    *reason_to_stop = ValueObject::eTakingAddressFailed;
2225                    *final_value_type = ValueObject::eInvalid;
2226                    return 0;
2227                }
2228                else
2229                {
2230                    *final_task_on_target = ValueObject::eNothing;
2231                    list->Append(final_value);
2232                    return 1;
2233                }
2234            }
2235        }
2236    }
2237    else
2238    {
2239        return ExpandArraySliceExpression(first_unparsed ? *first_unparsed : dummy_first_unparsed,
2240                                          first_unparsed ? first_unparsed : &dummy_first_unparsed,
2241                                          ret_val,
2242                                          list,
2243                                          reason_to_stop ? reason_to_stop : &dummy_reason_to_stop,
2244                                          final_value_type ? final_value_type : &dummy_final_value_type,
2245                                          options,
2246                                          final_task_on_target ? final_task_on_target : &dummy_final_task_on_target);
2247    }
2248    // in any non-covered case, just do the obviously right thing
2249    list->Append(ret_val);
2250    return 1;
2251}
2252
2253ValueObjectSP
2254ValueObject::GetValueForExpressionPath_Impl(const char* expression_cstr,
2255                                            const char** first_unparsed,
2256                                            ExpressionPathScanEndReason* reason_to_stop,
2257                                            ExpressionPathEndResultType* final_result,
2258                                            const GetValueForExpressionPathOptions& options,
2259                                            ExpressionPathAftermath* what_next)
2260{
2261    ValueObjectSP root = GetSP();
2262
2263    if (!root.get())
2264        return ValueObjectSP();
2265
2266    *first_unparsed = expression_cstr;
2267
2268    while (true)
2269    {
2270
2271        const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
2272
2273        clang_type_t root_clang_type = root->GetClangType();
2274        clang_type_t pointee_clang_type;
2275        Flags root_clang_type_info,pointee_clang_type_info;
2276
2277        root_clang_type_info = Flags(ClangASTContext::GetTypeInfo(root_clang_type, GetClangAST(), &pointee_clang_type));
2278        if (pointee_clang_type)
2279            pointee_clang_type_info = Flags(ClangASTContext::GetTypeInfo(pointee_clang_type, GetClangAST(), NULL));
2280
2281        if (!expression_cstr || *expression_cstr == '\0')
2282        {
2283            *reason_to_stop = ValueObject::eEndOfString;
2284            return root;
2285        }
2286
2287        switch (*expression_cstr)
2288        {
2289            case '-':
2290            {
2291                if (options.m_check_dot_vs_arrow_syntax &&
2292                    root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) ) // if you are trying to use -> on a non-pointer and I must catch the error
2293                {
2294                    *first_unparsed = expression_cstr;
2295                    *reason_to_stop = ValueObject::eArrowInsteadOfDot;
2296                    *final_result = ValueObject::eInvalid;
2297                    return ValueObjectSP();
2298                }
2299                if (root_clang_type_info.Test(ClangASTContext::eTypeIsObjC) &&  // if yo are trying to extract an ObjC IVar when this is forbidden
2300                    root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) &&
2301                    options.m_no_fragile_ivar)
2302                {
2303                    *first_unparsed = expression_cstr;
2304                    *reason_to_stop = ValueObject::eFragileIVarNotAllowed;
2305                    *final_result = ValueObject::eInvalid;
2306                    return ValueObjectSP();
2307                }
2308                if (expression_cstr[1] != '>')
2309                {
2310                    *first_unparsed = expression_cstr;
2311                    *reason_to_stop = ValueObject::eUnexpectedSymbol;
2312                    *final_result = ValueObject::eInvalid;
2313                    return ValueObjectSP();
2314                }
2315                expression_cstr++; // skip the -
2316            }
2317            case '.': // or fallthrough from ->
2318            {
2319                if (options.m_check_dot_vs_arrow_syntax && *expression_cstr == '.' &&
2320                    root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if you are trying to use . on a pointer and I must catch the error
2321                {
2322                    *first_unparsed = expression_cstr;
2323                    *reason_to_stop = ValueObject::eDotInsteadOfArrow;
2324                    *final_result = ValueObject::eInvalid;
2325                    return ValueObjectSP();
2326                }
2327                expression_cstr++; // skip .
2328                const char *next_separator = strpbrk(expression_cstr+1,"-.[");
2329                ConstString child_name;
2330                if (!next_separator) // if no other separator just expand this last layer
2331                {
2332                    child_name.SetCString (expression_cstr);
2333                    ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2334
2335                    if (child_valobj_sp.get()) // we know we are done, so just return
2336                    {
2337                        *first_unparsed = '\0';
2338                        *reason_to_stop = ValueObject::eEndOfString;
2339                        *final_result = ValueObject::ePlain;
2340                        return child_valobj_sp;
2341                    }
2342                    else if (options.m_no_synthetic_children == false) // let's try with synthetic children
2343                    {
2344                        child_valobj_sp = root->GetSyntheticValue(eNoSyntheticFilter)->GetChildMemberWithName(child_name, true);
2345                    }
2346
2347                    // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2348                    // so we hit the "else" branch, and return an error
2349                    if(child_valobj_sp.get()) // if it worked, just return
2350                    {
2351                        *first_unparsed = '\0';
2352                        *reason_to_stop = ValueObject::eEndOfString;
2353                        *final_result = ValueObject::ePlain;
2354                        return child_valobj_sp;
2355                    }
2356                    else
2357                    {
2358                        *first_unparsed = expression_cstr;
2359                        *reason_to_stop = ValueObject::eNoSuchChild;
2360                        *final_result = ValueObject::eInvalid;
2361                        return ValueObjectSP();
2362                    }
2363                }
2364                else // other layers do expand
2365                {
2366                    child_name.SetCStringWithLength(expression_cstr, next_separator - expression_cstr);
2367                    ValueObjectSP child_valobj_sp = root->GetChildMemberWithName(child_name, true);
2368                    if (child_valobj_sp.get()) // store the new root and move on
2369                    {
2370                        root = child_valobj_sp;
2371                        *first_unparsed = next_separator;
2372                        *final_result = ValueObject::ePlain;
2373                        continue;
2374                    }
2375                    else if (options.m_no_synthetic_children == false) // let's try with synthetic children
2376                    {
2377                        child_valobj_sp = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildMemberWithName(child_name, true);
2378                    }
2379
2380                    // if we are here and options.m_no_synthetic_children is true, child_valobj_sp is going to be a NULL SP,
2381                    // so we hit the "else" branch, and return an error
2382                    if(child_valobj_sp.get()) // if it worked, move on
2383                    {
2384                        root = child_valobj_sp;
2385                        *first_unparsed = next_separator;
2386                        *final_result = ValueObject::ePlain;
2387                        continue;
2388                    }
2389                    else
2390                    {
2391                        *first_unparsed = expression_cstr;
2392                        *reason_to_stop = ValueObject::eNoSuchChild;
2393                        *final_result = ValueObject::eInvalid;
2394                        return ValueObjectSP();
2395                    }
2396                }
2397                break;
2398            }
2399            case '[':
2400            {
2401                if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray) && !root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if this is not a T[] nor a T*
2402                {
2403                    if (!root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // if this is not even a scalar...
2404                    {
2405                        if (options.m_no_synthetic_children) // ...only chance left is synthetic
2406                        {
2407                            *first_unparsed = expression_cstr;
2408                            *reason_to_stop = ValueObject::eRangeOperatorInvalid;
2409                            *final_result = ValueObject::eInvalid;
2410                            return ValueObjectSP();
2411                        }
2412                    }
2413                    else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
2414                    {
2415                        *first_unparsed = expression_cstr;
2416                        *reason_to_stop = ValueObject::eRangeOperatorNotAllowed;
2417                        *final_result = ValueObject::eInvalid;
2418                        return ValueObjectSP();
2419                    }
2420                }
2421                if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
2422                {
2423                    if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2424                    {
2425                        *first_unparsed = expression_cstr;
2426                        *reason_to_stop = ValueObject::eEmptyRangeNotAllowed;
2427                        *final_result = ValueObject::eInvalid;
2428                        return ValueObjectSP();
2429                    }
2430                    else // even if something follows, we cannot expand unbounded ranges, just let the caller do it
2431                    {
2432                        *first_unparsed = expression_cstr+2;
2433                        *reason_to_stop = ValueObject::eArrayRangeOperatorMet;
2434                        *final_result = ValueObject::eUnboundedRange;
2435                        return root;
2436                    }
2437                }
2438                const char *separator_position = ::strchr(expression_cstr+1,'-');
2439                const char *close_bracket_position = ::strchr(expression_cstr+1,']');
2440                if (!close_bracket_position) // if there is no ], this is a syntax error
2441                {
2442                    *first_unparsed = expression_cstr;
2443                    *reason_to_stop = ValueObject::eUnexpectedSymbol;
2444                    *final_result = ValueObject::eInvalid;
2445                    return ValueObjectSP();
2446                }
2447                if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
2448                {
2449                    char *end = NULL;
2450                    unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
2451                    if (!end || end != close_bracket_position) // if something weird is in our way return an error
2452                    {
2453                        *first_unparsed = expression_cstr;
2454                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2455                        *final_result = ValueObject::eInvalid;
2456                        return ValueObjectSP();
2457                    }
2458                    if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
2459                    {
2460                        if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2461                        {
2462                            *first_unparsed = expression_cstr+2;
2463                            *reason_to_stop = ValueObject::eArrayRangeOperatorMet;
2464                            *final_result = ValueObject::eUnboundedRange;
2465                            return root;
2466                        }
2467                        else
2468                        {
2469                            *first_unparsed = expression_cstr;
2470                            *reason_to_stop = ValueObject::eEmptyRangeNotAllowed;
2471                            *final_result = ValueObject::eInvalid;
2472                            return ValueObjectSP();
2473                        }
2474                    }
2475                    // from here on we do have a valid index
2476                    if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2477                    {
2478                        ValueObjectSP child_valobj_sp = root->GetChildAtIndex(index, true);
2479                        if (!child_valobj_sp)
2480                            child_valobj_sp = root->GetSyntheticArrayMemberFromArray(index, true);
2481                        if (!child_valobj_sp)
2482                            if (root->HasSyntheticValue() && root->GetSyntheticValue(eUseSyntheticFilter)->GetNumChildren() > index)
2483                                child_valobj_sp = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true);
2484                        if (child_valobj_sp)
2485                        {
2486                            root = child_valobj_sp;
2487                            *first_unparsed = end+1; // skip ]
2488                            *final_result = ValueObject::ePlain;
2489                            continue;
2490                        }
2491                        else
2492                        {
2493                            *first_unparsed = expression_cstr;
2494                            *reason_to_stop = ValueObject::eNoSuchChild;
2495                            *final_result = ValueObject::eInvalid;
2496                            return ValueObjectSP();
2497                        }
2498                    }
2499                    else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer))
2500                    {
2501                        if (*what_next == ValueObject::eDereference &&  // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
2502                            pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar))
2503                        {
2504                            Error error;
2505                            root = root->Dereference(error);
2506                            if (error.Fail() || !root.get())
2507                            {
2508                                *first_unparsed = expression_cstr;
2509                                *reason_to_stop = ValueObject::eDereferencingFailed;
2510                                *final_result = ValueObject::eInvalid;
2511                                return ValueObjectSP();
2512                            }
2513                            else
2514                            {
2515                                *what_next = eNothing;
2516                                continue;
2517                            }
2518                        }
2519                        else
2520                        {
2521                            if (ClangASTType::GetMinimumLanguage(root->GetClangAST(),
2522                                                                    root->GetClangType()) == eLanguageTypeObjC
2523                                &&
2524                                ClangASTContext::IsPointerType(ClangASTType::GetPointeeType(root->GetClangType())) == false
2525                                &&
2526                                root->HasSyntheticValue()
2527                                &&
2528                                options.m_no_synthetic_children == false)
2529                            {
2530                                root = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true);
2531                            }
2532                            else
2533                                root = root->GetSyntheticArrayMemberFromPointer(index, true);
2534                            if (!root.get())
2535                            {
2536                                *first_unparsed = expression_cstr;
2537                                *reason_to_stop = ValueObject::eNoSuchChild;
2538                                *final_result = ValueObject::eInvalid;
2539                                return ValueObjectSP();
2540                            }
2541                            else
2542                            {
2543                                *first_unparsed = end+1; // skip ]
2544                                *final_result = ValueObject::ePlain;
2545                                continue;
2546                            }
2547                        }
2548                    }
2549                    else if (ClangASTContext::IsScalarType(root_clang_type))
2550                    {
2551                        root = root->GetSyntheticBitFieldChild(index, index, true);
2552                        if (!root.get())
2553                        {
2554                            *first_unparsed = expression_cstr;
2555                            *reason_to_stop = ValueObject::eNoSuchChild;
2556                            *final_result = ValueObject::eInvalid;
2557                            return ValueObjectSP();
2558                        }
2559                        else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
2560                        {
2561                            *first_unparsed = end+1; // skip ]
2562                            *reason_to_stop = ValueObject::eBitfieldRangeOperatorMet;
2563                            *final_result = ValueObject::eBitfield;
2564                            return root;
2565                        }
2566                    }
2567                    else if (root->HasSyntheticValue() && options.m_no_synthetic_children == false)
2568                    {
2569                        root = root->GetSyntheticValue(eUseSyntheticFilter)->GetChildAtIndex(index, true);
2570                        if (!root.get())
2571                        {
2572                            *first_unparsed = expression_cstr;
2573                            *reason_to_stop = ValueObject::eNoSuchChild;
2574                            *final_result = ValueObject::eInvalid;
2575                            return ValueObjectSP();
2576                        }
2577                        else
2578                        {
2579                            *first_unparsed = end+1; // skip ]
2580                            *final_result = ValueObject::ePlain;
2581                            continue;
2582                        }
2583                    }
2584                    else
2585                    {
2586                        *first_unparsed = expression_cstr;
2587                        *reason_to_stop = ValueObject::eNoSuchChild;
2588                        *final_result = ValueObject::eInvalid;
2589                        return ValueObjectSP();
2590                    }
2591                }
2592                else // we have a low and a high index
2593                {
2594                    char *end = NULL;
2595                    unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
2596                    if (!end || end != separator_position) // if something weird is in our way return an error
2597                    {
2598                        *first_unparsed = expression_cstr;
2599                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2600                        *final_result = ValueObject::eInvalid;
2601                        return ValueObjectSP();
2602                    }
2603                    unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
2604                    if (!end || end != close_bracket_position) // if something weird is in our way return an error
2605                    {
2606                        *first_unparsed = expression_cstr;
2607                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2608                        *final_result = ValueObject::eInvalid;
2609                        return ValueObjectSP();
2610                    }
2611                    if (index_lower > index_higher) // swap indices if required
2612                    {
2613                        unsigned long temp = index_lower;
2614                        index_lower = index_higher;
2615                        index_higher = temp;
2616                    }
2617                    if (root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // expansion only works for scalars
2618                    {
2619                        root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
2620                        if (!root.get())
2621                        {
2622                            *first_unparsed = expression_cstr;
2623                            *reason_to_stop = ValueObject::eNoSuchChild;
2624                            *final_result = ValueObject::eInvalid;
2625                            return ValueObjectSP();
2626                        }
2627                        else
2628                        {
2629                            *first_unparsed = end+1; // skip ]
2630                            *reason_to_stop = ValueObject::eBitfieldRangeOperatorMet;
2631                            *final_result = ValueObject::eBitfield;
2632                            return root;
2633                        }
2634                    }
2635                    else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
2636                             *what_next == ValueObject::eDereference &&
2637                             pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar))
2638                    {
2639                        Error error;
2640                        root = root->Dereference(error);
2641                        if (error.Fail() || !root.get())
2642                        {
2643                            *first_unparsed = expression_cstr;
2644                            *reason_to_stop = ValueObject::eDereferencingFailed;
2645                            *final_result = ValueObject::eInvalid;
2646                            return ValueObjectSP();
2647                        }
2648                        else
2649                        {
2650                            *what_next = ValueObject::eNothing;
2651                            continue;
2652                        }
2653                    }
2654                    else
2655                    {
2656                        *first_unparsed = expression_cstr;
2657                        *reason_to_stop = ValueObject::eArrayRangeOperatorMet;
2658                        *final_result = ValueObject::eBoundedRange;
2659                        return root;
2660                    }
2661                }
2662                break;
2663            }
2664            default: // some non-separator is in the way
2665            {
2666                *first_unparsed = expression_cstr;
2667                *reason_to_stop = ValueObject::eUnexpectedSymbol;
2668                *final_result = ValueObject::eInvalid;
2669                return ValueObjectSP();
2670                break;
2671            }
2672        }
2673    }
2674}
2675
2676int
2677ValueObject::ExpandArraySliceExpression(const char* expression_cstr,
2678                                        const char** first_unparsed,
2679                                        ValueObjectSP root,
2680                                        ValueObjectListSP& list,
2681                                        ExpressionPathScanEndReason* reason_to_stop,
2682                                        ExpressionPathEndResultType* final_result,
2683                                        const GetValueForExpressionPathOptions& options,
2684                                        ExpressionPathAftermath* what_next)
2685{
2686    if (!root.get())
2687        return 0;
2688
2689    *first_unparsed = expression_cstr;
2690
2691    while (true)
2692    {
2693
2694        const char* expression_cstr = *first_unparsed; // hide the top level expression_cstr
2695
2696        clang_type_t root_clang_type = root->GetClangType();
2697        clang_type_t pointee_clang_type;
2698        Flags root_clang_type_info,pointee_clang_type_info;
2699
2700        root_clang_type_info = Flags(ClangASTContext::GetTypeInfo(root_clang_type, GetClangAST(), &pointee_clang_type));
2701        if (pointee_clang_type)
2702            pointee_clang_type_info = Flags(ClangASTContext::GetTypeInfo(pointee_clang_type, GetClangAST(), NULL));
2703
2704        if (!expression_cstr || *expression_cstr == '\0')
2705        {
2706            *reason_to_stop = ValueObject::eEndOfString;
2707            list->Append(root);
2708            return 1;
2709        }
2710
2711        switch (*expression_cstr)
2712        {
2713            case '[':
2714            {
2715                if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray) && !root_clang_type_info.Test(ClangASTContext::eTypeIsPointer)) // if this is not a T[] nor a T*
2716                {
2717                    if (!root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // if this is not even a scalar, this syntax is just plain wrong!
2718                    {
2719                        *first_unparsed = expression_cstr;
2720                        *reason_to_stop = ValueObject::eRangeOperatorInvalid;
2721                        *final_result = ValueObject::eInvalid;
2722                        return 0;
2723                    }
2724                    else if (!options.m_allow_bitfields_syntax) // if this is a scalar, check that we can expand bitfields
2725                    {
2726                        *first_unparsed = expression_cstr;
2727                        *reason_to_stop = ValueObject::eRangeOperatorNotAllowed;
2728                        *final_result = ValueObject::eInvalid;
2729                        return 0;
2730                    }
2731                }
2732                if (*(expression_cstr+1) == ']') // if this is an unbounded range it only works for arrays
2733                {
2734                    if (!root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2735                    {
2736                        *first_unparsed = expression_cstr;
2737                        *reason_to_stop = ValueObject::eEmptyRangeNotAllowed;
2738                        *final_result = ValueObject::eInvalid;
2739                        return 0;
2740                    }
2741                    else // expand this into list
2742                    {
2743                        int max_index = root->GetNumChildren() - 1;
2744                        for (int index = 0; index < max_index; index++)
2745                        {
2746                            ValueObjectSP child =
2747                                root->GetChildAtIndex(index, true);
2748                            list->Append(child);
2749                        }
2750                        *first_unparsed = expression_cstr+2;
2751                        *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2752                        *final_result = ValueObject::eValueObjectList;
2753                        return max_index; // tell me number of items I added to the VOList
2754                    }
2755                }
2756                const char *separator_position = ::strchr(expression_cstr+1,'-');
2757                const char *close_bracket_position = ::strchr(expression_cstr+1,']');
2758                if (!close_bracket_position) // if there is no ], this is a syntax error
2759                {
2760                    *first_unparsed = expression_cstr;
2761                    *reason_to_stop = ValueObject::eUnexpectedSymbol;
2762                    *final_result = ValueObject::eInvalid;
2763                    return 0;
2764                }
2765                if (!separator_position || separator_position > close_bracket_position) // if no separator, this is either [] or [N]
2766                {
2767                    char *end = NULL;
2768                    unsigned long index = ::strtoul (expression_cstr+1, &end, 0);
2769                    if (!end || end != close_bracket_position) // if something weird is in our way return an error
2770                    {
2771                        *first_unparsed = expression_cstr;
2772                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2773                        *final_result = ValueObject::eInvalid;
2774                        return 0;
2775                    }
2776                    if (end - expression_cstr == 1) // if this is [], only return a valid value for arrays
2777                    {
2778                        if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2779                        {
2780                            int max_index = root->GetNumChildren() - 1;
2781                            for (int index = 0; index < max_index; index++)
2782                            {
2783                                ValueObjectSP child =
2784                                root->GetChildAtIndex(index, true);
2785                                list->Append(child);
2786                            }
2787                            *first_unparsed = expression_cstr+2;
2788                            *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2789                            *final_result = ValueObject::eValueObjectList;
2790                            return max_index; // tell me number of items I added to the VOList
2791                        }
2792                        else
2793                        {
2794                            *first_unparsed = expression_cstr;
2795                            *reason_to_stop = ValueObject::eEmptyRangeNotAllowed;
2796                            *final_result = ValueObject::eInvalid;
2797                            return 0;
2798                        }
2799                    }
2800                    // from here on we do have a valid index
2801                    if (root_clang_type_info.Test(ClangASTContext::eTypeIsArray))
2802                    {
2803                        root = root->GetChildAtIndex(index, true);
2804                        if (!root.get())
2805                        {
2806                            *first_unparsed = expression_cstr;
2807                            *reason_to_stop = ValueObject::eNoSuchChild;
2808                            *final_result = ValueObject::eInvalid;
2809                            return 0;
2810                        }
2811                        else
2812                        {
2813                            list->Append(root);
2814                            *first_unparsed = end+1; // skip ]
2815                            *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2816                            *final_result = ValueObject::eValueObjectList;
2817                            return 1;
2818                        }
2819                    }
2820                    else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer))
2821                    {
2822                        if (*what_next == ValueObject::eDereference &&  // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
2823                            pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar))
2824                        {
2825                            Error error;
2826                            root = root->Dereference(error);
2827                            if (error.Fail() || !root.get())
2828                            {
2829                                *first_unparsed = expression_cstr;
2830                                *reason_to_stop = ValueObject::eDereferencingFailed;
2831                                *final_result = ValueObject::eInvalid;
2832                                return 0;
2833                            }
2834                            else
2835                            {
2836                                *what_next = eNothing;
2837                                continue;
2838                            }
2839                        }
2840                        else
2841                        {
2842                            root = root->GetSyntheticArrayMemberFromPointer(index, true);
2843                            if (!root.get())
2844                            {
2845                                *first_unparsed = expression_cstr;
2846                                *reason_to_stop = ValueObject::eNoSuchChild;
2847                                *final_result = ValueObject::eInvalid;
2848                                return 0;
2849                            }
2850                            else
2851                            {
2852                                list->Append(root);
2853                                *first_unparsed = end+1; // skip ]
2854                                *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2855                                *final_result = ValueObject::eValueObjectList;
2856                                return 1;
2857                            }
2858                        }
2859                    }
2860                    else /*if (ClangASTContext::IsScalarType(root_clang_type))*/
2861                    {
2862                        root = root->GetSyntheticBitFieldChild(index, index, true);
2863                        if (!root.get())
2864                        {
2865                            *first_unparsed = expression_cstr;
2866                            *reason_to_stop = ValueObject::eNoSuchChild;
2867                            *final_result = ValueObject::eInvalid;
2868                            return 0;
2869                        }
2870                        else // we do not know how to expand members of bitfields, so we just return and let the caller do any further processing
2871                        {
2872                            list->Append(root);
2873                            *first_unparsed = end+1; // skip ]
2874                            *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2875                            *final_result = ValueObject::eValueObjectList;
2876                            return 1;
2877                        }
2878                    }
2879                }
2880                else // we have a low and a high index
2881                {
2882                    char *end = NULL;
2883                    unsigned long index_lower = ::strtoul (expression_cstr+1, &end, 0);
2884                    if (!end || end != separator_position) // if something weird is in our way return an error
2885                    {
2886                        *first_unparsed = expression_cstr;
2887                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2888                        *final_result = ValueObject::eInvalid;
2889                        return 0;
2890                    }
2891                    unsigned long index_higher = ::strtoul (separator_position+1, &end, 0);
2892                    if (!end || end != close_bracket_position) // if something weird is in our way return an error
2893                    {
2894                        *first_unparsed = expression_cstr;
2895                        *reason_to_stop = ValueObject::eUnexpectedSymbol;
2896                        *final_result = ValueObject::eInvalid;
2897                        return 0;
2898                    }
2899                    if (index_lower > index_higher) // swap indices if required
2900                    {
2901                        unsigned long temp = index_lower;
2902                        index_lower = index_higher;
2903                        index_higher = temp;
2904                    }
2905                    if (root_clang_type_info.Test(ClangASTContext::eTypeIsScalar)) // expansion only works for scalars
2906                    {
2907                        root = root->GetSyntheticBitFieldChild(index_lower, index_higher, true);
2908                        if (!root.get())
2909                        {
2910                            *first_unparsed = expression_cstr;
2911                            *reason_to_stop = ValueObject::eNoSuchChild;
2912                            *final_result = ValueObject::eInvalid;
2913                            return 0;
2914                        }
2915                        else
2916                        {
2917                            list->Append(root);
2918                            *first_unparsed = end+1; // skip ]
2919                            *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2920                            *final_result = ValueObject::eValueObjectList;
2921                            return 1;
2922                        }
2923                    }
2924                    else if (root_clang_type_info.Test(ClangASTContext::eTypeIsPointer) && // if this is a ptr-to-scalar, I am accessing it by index and I would have deref'ed anyway, then do it now and use this as a bitfield
2925                             *what_next == ValueObject::eDereference &&
2926                             pointee_clang_type_info.Test(ClangASTContext::eTypeIsScalar))
2927                    {
2928                        Error error;
2929                        root = root->Dereference(error);
2930                        if (error.Fail() || !root.get())
2931                        {
2932                            *first_unparsed = expression_cstr;
2933                            *reason_to_stop = ValueObject::eDereferencingFailed;
2934                            *final_result = ValueObject::eInvalid;
2935                            return 0;
2936                        }
2937                        else
2938                        {
2939                            *what_next = ValueObject::eNothing;
2940                            continue;
2941                        }
2942                    }
2943                    else
2944                    {
2945                        for (unsigned long index = index_lower;
2946                             index <= index_higher; index++)
2947                        {
2948                            ValueObjectSP child =
2949                                root->GetChildAtIndex(index, true);
2950                            list->Append(child);
2951                        }
2952                        *first_unparsed = end+1;
2953                        *reason_to_stop = ValueObject::eRangeOperatorExpanded;
2954                        *final_result = ValueObject::eValueObjectList;
2955                        return index_higher-index_lower+1; // tell me number of items I added to the VOList
2956                    }
2957                }
2958                break;
2959            }
2960            default: // some non-[ separator, or something entirely wrong, is in the way
2961            {
2962                *first_unparsed = expression_cstr;
2963                *reason_to_stop = ValueObject::eUnexpectedSymbol;
2964                *final_result = ValueObject::eInvalid;
2965                return 0;
2966                break;
2967            }
2968        }
2969    }
2970}
2971
2972void
2973ValueObject::DumpValueObject
2974(
2975    Stream &s,
2976    ValueObject *valobj,
2977    const char *root_valobj_name,
2978    uint32_t ptr_depth,
2979    uint32_t curr_depth,
2980    uint32_t max_depth,
2981    bool show_types,
2982    bool show_location,
2983    bool use_objc,
2984    DynamicValueType use_dynamic,
2985    bool use_synth,
2986    bool scope_already_checked,
2987    bool flat_output,
2988    uint32_t omit_summary_depth,
2989    bool ignore_cap,
2990    Format format_override       // Normally the format is in the valobj, but we might want to override this
2991)
2992{
2993    if (valobj)
2994    {
2995        bool update_success = valobj->UpdateValueIfNeeded (use_dynamic, true);
2996
2997        if (update_success && use_dynamic != eNoDynamicValues)
2998        {
2999            ValueObject *dynamic_value = valobj->GetDynamicValue(use_dynamic).get();
3000            if (dynamic_value)
3001                valobj = dynamic_value;
3002        }
3003
3004        clang_type_t clang_type = valobj->GetClangType();
3005
3006        const Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, NULL));
3007        const char *err_cstr = NULL;
3008        const bool has_children = type_flags.Test (ClangASTContext::eTypeHasChildren);
3009        const bool has_value = type_flags.Test (ClangASTContext::eTypeHasValue);
3010
3011        const bool print_valobj = flat_output == false || has_value;
3012
3013        if (print_valobj)
3014        {
3015            if (show_location)
3016            {
3017                s.Printf("%s: ", valobj->GetLocationAsCString());
3018            }
3019
3020            s.Indent();
3021
3022            // Always show the type for the top level items.
3023            if (show_types || (curr_depth == 0 && !flat_output))
3024            {
3025                const char* typeName = valobj->GetTypeName().AsCString("<invalid type>");
3026                s.Printf("(%s", typeName);
3027                // only show dynamic types if the user really wants to see types
3028                if (show_types && use_dynamic != eNoDynamicValues &&
3029                    (/*strstr(typeName, "id") == typeName ||*/
3030                     ClangASTType::GetMinimumLanguage(valobj->GetClangAST(), valobj->GetClangType()) == eLanguageTypeObjC))
3031                {
3032                    Process* process = valobj->GetUpdatePoint().GetProcessSP().get();
3033                    if (process == NULL)
3034                        s.Printf(", dynamic type: unknown) ");
3035                    else
3036                    {
3037                        ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
3038                        if (runtime == NULL)
3039                            s.Printf(", dynamic type: unknown) ");
3040                        else
3041                        {
3042                            ObjCLanguageRuntime::ObjCISA isa = runtime->GetISA(*valobj);
3043                            if (!runtime->IsValidISA(isa))
3044                                s.Printf(", dynamic type: unknown) ");
3045                            else
3046                                s.Printf(", dynamic type: %s) ",
3047                                         runtime->GetActualTypeName(isa).GetCString());
3048                        }
3049                    }
3050                }
3051                else
3052                    s.Printf(") ");
3053            }
3054
3055
3056            if (flat_output)
3057            {
3058                // If we are showing types, also qualify the C++ base classes
3059                const bool qualify_cxx_base_classes = show_types;
3060                valobj->GetExpressionPath(s, qualify_cxx_base_classes);
3061                s.PutCString(" =");
3062            }
3063            else
3064            {
3065                const char *name_cstr = root_valobj_name ? root_valobj_name : valobj->GetName().AsCString("");
3066                s.Printf ("%s =", name_cstr);
3067            }
3068
3069            if (!scope_already_checked && !valobj->IsInScope())
3070            {
3071                err_cstr = "out of scope";
3072            }
3073        }
3074
3075        std::string value_str;
3076        const char *val_cstr = NULL;
3077        const char *sum_cstr = NULL;
3078        SummaryFormat* entry = valobj->GetSummaryFormat().get();
3079
3080        if (omit_summary_depth > 0)
3081            entry = NULL;
3082
3083        Format orig_format = kNumFormats;
3084        if (err_cstr == NULL)
3085        {
3086            if (format_override != eFormatDefault)
3087            {
3088                orig_format = valobj->GetFormat();
3089                valobj->SetFormat (format_override);
3090            }
3091            val_cstr = valobj->GetValueAsCString();
3092            if (val_cstr)
3093            {
3094                // Cache the value in our own storage as running summaries might
3095                // change our value from underneath us
3096                value_str = val_cstr;
3097            }
3098            if (orig_format != kNumFormats && orig_format != format_override)
3099            {
3100                valobj->SetFormat (orig_format);
3101                orig_format = kNumFormats;
3102            }
3103            err_cstr = valobj->GetError().AsCString();
3104        }
3105
3106        if (err_cstr)
3107        {
3108            s.Printf (" <%s>\n", err_cstr);
3109        }
3110        else
3111        {
3112            const bool is_ref = type_flags.Test (ClangASTContext::eTypeIsReference);
3113            if (print_valobj)
3114            {
3115                if (omit_summary_depth == 0)
3116                    sum_cstr = valobj->GetSummaryAsCString();
3117
3118                // Make sure we have a value and make sure the summary didn't
3119                // specify that the value should not be printed
3120                if (!value_str.empty() && (entry == NULL || entry->DoesPrintValue() || sum_cstr == NULL))
3121                    s.Printf(" %s", value_str.c_str());
3122
3123                if (sum_cstr)
3124                {
3125                    // for some reason, using %@ (ObjC description) in a summary string, makes
3126                    // us believe we need to reset ourselves, thus invalidating the content of
3127                    // sum_cstr. Thus, IF we had a valid sum_cstr before, but it is now empty
3128                    // let us recalculate it!
3129                    if (sum_cstr[0] == '\0')
3130                        s.Printf(" %s", valobj->GetSummaryAsCString());
3131                    else
3132                        s.Printf(" %s", sum_cstr);
3133                }
3134
3135                if (use_objc)
3136                {
3137                    const char *object_desc = valobj->GetObjectDescription();
3138                    if (object_desc)
3139                        s.Printf(" %s\n", object_desc);
3140                    else
3141                        s.Printf (" [no Objective-C description available]\n");
3142                    return;
3143                }
3144            }
3145
3146            if (curr_depth < max_depth)
3147            {
3148                // We will show children for all concrete types. We won't show
3149                // pointer contents unless a pointer depth has been specified.
3150                // We won't reference contents unless the reference is the
3151                // root object (depth of zero).
3152                bool print_children = true;
3153
3154                // Use a new temporary pointer depth in case we override the
3155                // current pointer depth below...
3156                uint32_t curr_ptr_depth = ptr_depth;
3157
3158                const bool is_ptr = type_flags.Test (ClangASTContext::eTypeIsPointer);
3159                if (is_ptr || is_ref)
3160                {
3161                    // We have a pointer or reference whose value is an address.
3162                    // Make sure that address is not NULL
3163                    AddressType ptr_address_type;
3164                    if (valobj->GetPointerValue (&ptr_address_type) == 0)
3165                        print_children = false;
3166
3167                    else if (is_ref && curr_depth == 0)
3168                    {
3169                        // If this is the root object (depth is zero) that we are showing
3170                        // and it is a reference, and no pointer depth has been supplied
3171                        // print out what it references. Don't do this at deeper depths
3172                        // otherwise we can end up with infinite recursion...
3173                        curr_ptr_depth = 1;
3174                    }
3175
3176                    if (curr_ptr_depth == 0)
3177                        print_children = false;
3178                }
3179
3180                if (print_children && (!entry || entry->DoesPrintChildren() || !sum_cstr))
3181                {
3182                    ValueObjectSP synth_valobj = valobj->GetSyntheticValue(use_synth ?
3183                                                                         eUseSyntheticFilter :
3184                                                                         eNoSyntheticFilter);
3185                    uint32_t num_children = synth_valobj->GetNumChildren();
3186                    bool print_dotdotdot = false;
3187                    if (num_children)
3188                    {
3189                        if (flat_output)
3190                        {
3191                            if (print_valobj)
3192                                s.EOL();
3193                        }
3194                        else
3195                        {
3196                            if (print_valobj)
3197                                s.PutCString(is_ref ? ": {\n" : " {\n");
3198                            s.IndentMore();
3199                        }
3200
3201                        uint32_t max_num_children = valobj->GetUpdatePoint().GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
3202
3203                        if (num_children > max_num_children && !ignore_cap)
3204                        {
3205                            num_children = max_num_children;
3206                            print_dotdotdot = true;
3207                        }
3208
3209                        for (uint32_t idx=0; idx<num_children; ++idx)
3210                        {
3211                            ValueObjectSP child_sp(synth_valobj->GetChildAtIndex(idx, true));
3212                            if (child_sp.get())
3213                            {
3214                                DumpValueObject (s,
3215                                                 child_sp.get(),
3216                                                 NULL,
3217                                                 (is_ptr || is_ref) ? curr_ptr_depth - 1 : curr_ptr_depth,
3218                                                 curr_depth + 1,
3219                                                 max_depth,
3220                                                 show_types,
3221                                                 show_location,
3222                                                 false,
3223                                                 use_dynamic,
3224                                                 use_synth,
3225                                                 true,
3226                                                 flat_output,
3227                                                 omit_summary_depth > 1 ? omit_summary_depth - 1 : 0,
3228                                                 ignore_cap,
3229                                                 format_override);
3230                            }
3231                        }
3232
3233                        if (!flat_output)
3234                        {
3235                            if (print_dotdotdot)
3236                            {
3237                                valobj->GetUpdatePoint().GetTargetSP()->GetDebugger().GetCommandInterpreter().ChildrenTruncated();
3238                                s.Indent("...\n");
3239                            }
3240                            s.IndentLess();
3241                            s.Indent("}\n");
3242                        }
3243                    }
3244                    else if (has_children)
3245                    {
3246                        // Aggregate, no children...
3247                        if (print_valobj)
3248                            s.PutCString(" {}\n");
3249                    }
3250                    else
3251                    {
3252                        if (print_valobj)
3253                            s.EOL();
3254                    }
3255
3256                }
3257                else
3258                {
3259                    s.EOL();
3260                }
3261            }
3262            else
3263            {
3264                if (has_children && print_valobj)
3265                {
3266                    s.PutCString("{...}\n");
3267                }
3268            }
3269        }
3270    }
3271}
3272
3273
3274ValueObjectSP
3275ValueObject::CreateConstantValue (const ConstString &name)
3276{
3277    ValueObjectSP valobj_sp;
3278
3279    if (UpdateValueIfNeeded(false) && m_error.Success())
3280    {
3281        ExecutionContextScope *exe_scope = GetExecutionContextScope();
3282        if (exe_scope)
3283        {
3284            ExecutionContext exe_ctx;
3285            exe_scope->CalculateExecutionContext(exe_ctx);
3286
3287            clang::ASTContext *ast = GetClangAST ();
3288
3289            DataExtractor data;
3290            data.SetByteOrder (m_data.GetByteOrder());
3291            data.SetAddressByteSize(m_data.GetAddressByteSize());
3292
3293            m_error = m_value.GetValueAsData (&exe_ctx, ast, data, 0, GetModule());
3294
3295            valobj_sp = ValueObjectConstResult::Create (exe_scope,
3296                                                        ast,
3297                                                        GetClangType(),
3298                                                        name,
3299                                                        data,
3300													    GetAddressOf());
3301        }
3302    }
3303
3304    if (!valobj_sp)
3305    {
3306        valobj_sp = ValueObjectConstResult::Create (NULL, m_error);
3307    }
3308    return valobj_sp;
3309}
3310
3311ValueObjectSP
3312ValueObject::Dereference (Error &error)
3313{
3314    if (m_deref_valobj)
3315        return m_deref_valobj->GetSP();
3316
3317    const bool is_pointer_type = IsPointerType();
3318    if (is_pointer_type)
3319    {
3320        bool omit_empty_base_classes = true;
3321        bool ignore_array_bounds = false;
3322
3323        std::string child_name_str;
3324        uint32_t child_byte_size = 0;
3325        int32_t child_byte_offset = 0;
3326        uint32_t child_bitfield_bit_size = 0;
3327        uint32_t child_bitfield_bit_offset = 0;
3328        bool child_is_base_class = false;
3329        bool child_is_deref_of_parent = false;
3330        const bool transparent_pointers = false;
3331        clang::ASTContext *clang_ast = GetClangAST();
3332        clang_type_t clang_type = GetClangType();
3333        clang_type_t child_clang_type;
3334
3335        ExecutionContext exe_ctx;
3336        GetExecutionContextScope()->CalculateExecutionContext (exe_ctx);
3337
3338        child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx,
3339                                                                      clang_ast,
3340                                                                      GetName().GetCString(),
3341                                                                      clang_type,
3342                                                                      0,
3343                                                                      transparent_pointers,
3344                                                                      omit_empty_base_classes,
3345                                                                      ignore_array_bounds,
3346                                                                      child_name_str,
3347                                                                      child_byte_size,
3348                                                                      child_byte_offset,
3349                                                                      child_bitfield_bit_size,
3350                                                                      child_bitfield_bit_offset,
3351                                                                      child_is_base_class,
3352                                                                      child_is_deref_of_parent);
3353        if (child_clang_type && child_byte_size)
3354        {
3355            ConstString child_name;
3356            if (!child_name_str.empty())
3357                child_name.SetCString (child_name_str.c_str());
3358
3359            m_deref_valobj = new ValueObjectChild (*this,
3360                                                   clang_ast,
3361                                                   child_clang_type,
3362                                                   child_name,
3363                                                   child_byte_size,
3364                                                   child_byte_offset,
3365                                                   child_bitfield_bit_size,
3366                                                   child_bitfield_bit_offset,
3367                                                   child_is_base_class,
3368                                                   child_is_deref_of_parent,
3369                                                   eAddressTypeInvalid);
3370        }
3371    }
3372
3373    if (m_deref_valobj)
3374    {
3375        error.Clear();
3376        return m_deref_valobj->GetSP();
3377    }
3378    else
3379    {
3380        StreamString strm;
3381        GetExpressionPath(strm, true);
3382
3383        if (is_pointer_type)
3384            error.SetErrorStringWithFormat("dereference failed: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3385        else
3386            error.SetErrorStringWithFormat("not a pointer type: (%s) %s", GetTypeName().AsCString("<invalid type>"), strm.GetString().c_str());
3387        return ValueObjectSP();
3388    }
3389}
3390
3391ValueObjectSP
3392ValueObject::AddressOf (Error &error)
3393{
3394    if (m_addr_of_valobj_sp)
3395        return m_addr_of_valobj_sp;
3396
3397    AddressType address_type = eAddressTypeInvalid;
3398    const bool scalar_is_load_address = false;
3399    addr_t addr = GetAddressOf (scalar_is_load_address, &address_type);
3400    error.Clear();
3401    if (addr != LLDB_INVALID_ADDRESS)
3402    {
3403        switch (address_type)
3404        {
3405        default:
3406        case eAddressTypeInvalid:
3407            {
3408                StreamString expr_path_strm;
3409                GetExpressionPath(expr_path_strm, true);
3410                error.SetErrorStringWithFormat("'%s' is not in memory", expr_path_strm.GetString().c_str());
3411            }
3412            break;
3413
3414        case eAddressTypeFile:
3415        case eAddressTypeLoad:
3416        case eAddressTypeHost:
3417            {
3418                clang::ASTContext *ast = GetClangAST();
3419                clang_type_t clang_type = GetClangType();
3420                if (ast && clang_type)
3421                {
3422                    std::string name (1, '&');
3423                    name.append (m_name.AsCString(""));
3424                    m_addr_of_valobj_sp = ValueObjectConstResult::Create (GetExecutionContextScope(),
3425                                                                          ast,
3426                                                                          ClangASTContext::CreatePointerType (ast, clang_type),
3427                                                                          ConstString (name.c_str()),
3428                                                                          addr,
3429                                                                          eAddressTypeInvalid,
3430                                                                          m_data.GetAddressByteSize());
3431                }
3432            }
3433            break;
3434        }
3435    }
3436    return m_addr_of_valobj_sp;
3437}
3438
3439ValueObjectSP
3440ValueObject::Cast (const ClangASTType &clang_ast_type)
3441{
3442    return ValueObjectCast::Create (*this, GetName(), clang_ast_type);
3443}
3444
3445ValueObjectSP
3446ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type)
3447{
3448    ValueObjectSP valobj_sp;
3449    AddressType address_type;
3450    addr_t ptr_value = GetPointerValue (&address_type);
3451
3452    if (ptr_value != LLDB_INVALID_ADDRESS)
3453    {
3454        Address ptr_addr (NULL, ptr_value);
3455
3456        valobj_sp = ValueObjectMemory::Create (GetExecutionContextScope(),
3457                                               name,
3458                                               ptr_addr,
3459                                               clang_ast_type);
3460    }
3461    return valobj_sp;
3462}
3463
3464ValueObjectSP
3465ValueObject::CastPointerType (const char *name, TypeSP &type_sp)
3466{
3467    ValueObjectSP valobj_sp;
3468    AddressType address_type;
3469    addr_t ptr_value = GetPointerValue (&address_type);
3470
3471    if (ptr_value != LLDB_INVALID_ADDRESS)
3472    {
3473        Address ptr_addr (NULL, ptr_value);
3474
3475        valobj_sp = ValueObjectMemory::Create (GetExecutionContextScope(),
3476                                               name,
3477                                               ptr_addr,
3478                                               type_sp);
3479    }
3480    return valobj_sp;
3481}
3482
3483ValueObject::EvaluationPoint::EvaluationPoint () :
3484    ExecutionContextScope(),
3485    m_thread_id (LLDB_INVALID_UID),
3486    m_mod_id ()
3487{
3488}
3489
3490ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected):
3491    ExecutionContextScope (),
3492    m_needs_update (true),
3493    m_first_update (true),
3494    m_thread_id (LLDB_INVALID_THREAD_ID),
3495    m_mod_id ()
3496
3497{
3498    ExecutionContext exe_ctx;
3499
3500    if (exe_scope)
3501        exe_scope->CalculateExecutionContext(exe_ctx);
3502    Target *target = exe_ctx.GetTargetPtr();
3503    if (target != NULL)
3504    {
3505        m_target_sp = target->shared_from_this();
3506        m_process_sp = exe_ctx.GetProcessSP();
3507        if (!m_process_sp)
3508            m_process_sp = target->GetProcessSP();
3509
3510        if (m_process_sp)
3511        {
3512            m_mod_id = m_process_sp->GetModID();
3513
3514            Thread *thread = exe_ctx.GetThreadPtr();
3515
3516            if (thread == NULL)
3517            {
3518                if (use_selected)
3519                    thread = m_process_sp->GetThreadList().GetSelectedThread().get();
3520            }
3521
3522            if (thread != NULL)
3523            {
3524                m_thread_id = thread->GetIndexID();
3525
3526                StackFrame *frame = exe_ctx.GetFramePtr();
3527                if (frame == NULL)
3528                {
3529                    if (use_selected)
3530                    {
3531                        frame = thread->GetSelectedFrame().get();
3532                        if (frame)
3533                            m_stack_id = frame->GetStackID();
3534                    }
3535                }
3536                else
3537                    m_stack_id = frame->GetStackID();
3538            }
3539        }
3540    }
3541}
3542
3543ValueObject::EvaluationPoint::EvaluationPoint (const ValueObject::EvaluationPoint &rhs) :
3544    m_needs_update(true),
3545    m_first_update(true),
3546    m_target_sp (rhs.m_target_sp),
3547    m_process_sp (rhs.m_process_sp),
3548    m_thread_id (rhs.m_thread_id),
3549    m_stack_id (rhs.m_stack_id),
3550    m_mod_id ()
3551{
3552}
3553
3554ValueObject::EvaluationPoint::~EvaluationPoint ()
3555{
3556}
3557
3558Target *
3559ValueObject::EvaluationPoint::CalculateTarget ()
3560{
3561    return m_target_sp.get();
3562}
3563
3564Process *
3565ValueObject::EvaluationPoint::CalculateProcess ()
3566{
3567    return m_process_sp.get();
3568}
3569
3570Thread *
3571ValueObject::EvaluationPoint::CalculateThread ()
3572{
3573    ExecutionContextScope *exe_scope;
3574    SyncWithProcessState(exe_scope);
3575    if (exe_scope)
3576        return exe_scope->CalculateThread();
3577    else
3578        return NULL;
3579}
3580
3581StackFrame *
3582ValueObject::EvaluationPoint::CalculateStackFrame ()
3583{
3584    ExecutionContextScope *exe_scope;
3585    SyncWithProcessState(exe_scope);
3586    if (exe_scope)
3587        return exe_scope->CalculateStackFrame();
3588    else
3589        return NULL;
3590}
3591
3592void
3593ValueObject::EvaluationPoint::CalculateExecutionContext (ExecutionContext &exe_ctx)
3594{
3595    ExecutionContextScope *exe_scope;
3596    SyncWithProcessState(exe_scope);
3597    if (exe_scope)
3598        return exe_scope->CalculateExecutionContext (exe_ctx);
3599}
3600
3601// This function checks the EvaluationPoint against the current process state.  If the current
3602// state matches the evaluation point, or the evaluation point is already invalid, then we return
3603// false, meaning "no change".  If the current state is different, we update our state, and return
3604// true meaning "yes, change".  If we did see a change, we also set m_needs_update to true, so
3605// future calls to NeedsUpdate will return true.
3606// exe_scope will be set to the current execution context scope.
3607
3608bool
3609ValueObject::EvaluationPoint::SyncWithProcessState(ExecutionContextScope *&exe_scope)
3610{
3611
3612    // Start with the target, if it is NULL, then we're obviously not going to get any further:
3613    exe_scope = m_target_sp.get();
3614
3615    if (exe_scope == NULL)
3616        return false;
3617
3618    // If we don't have a process nothing can change.
3619    if (!m_process_sp)
3620        return false;
3621
3622    exe_scope = m_process_sp.get();
3623
3624    // If our stop id is the current stop ID, nothing has changed:
3625    ProcessModID current_mod_id = m_process_sp->GetModID();
3626
3627    // If the current stop id is 0, either we haven't run yet, or the process state has been cleared.
3628    // In either case, we aren't going to be able to sync with the process state.
3629    if (current_mod_id.GetStopID() == 0)
3630        return false;
3631
3632    bool changed;
3633
3634    if (m_mod_id.IsValid())
3635    {
3636        if (m_mod_id == current_mod_id)
3637        {
3638            // Everything is already up to date in this object, no need to
3639            // update the execution context scope.
3640            changed = false;
3641        }
3642        else
3643        {
3644            m_mod_id = current_mod_id;
3645            m_needs_update = true;
3646            changed = true;
3647        }
3648    }
3649
3650    // Now re-look up the thread and frame in case the underlying objects have gone away & been recreated.
3651    // That way we'll be sure to return a valid exe_scope.
3652    // If we used to have a thread or a frame but can't find it anymore, then mark ourselves as invalid.
3653
3654    if (m_thread_id != LLDB_INVALID_THREAD_ID)
3655    {
3656        Thread *our_thread = m_process_sp->GetThreadList().FindThreadByIndexID (m_thread_id).get();
3657        if (our_thread == NULL)
3658        {
3659            SetInvalid();
3660        }
3661        else
3662        {
3663            exe_scope = our_thread;
3664
3665            if (m_stack_id.IsValid())
3666            {
3667                StackFrame *our_frame = our_thread->GetFrameWithStackID (m_stack_id).get();
3668                if (our_frame == NULL)
3669                    SetInvalid();
3670                else
3671                    exe_scope = our_frame;
3672            }
3673        }
3674    }
3675    return changed;
3676}
3677
3678void
3679ValueObject::EvaluationPoint::SetUpdated ()
3680{
3681    if (m_process_sp)
3682        m_mod_id = m_process_sp->GetModID();
3683    m_first_update = false;
3684    m_needs_update = false;
3685}
3686
3687
3688bool
3689ValueObject::EvaluationPoint::SetContext (ExecutionContextScope *exe_scope)
3690{
3691    if (!IsValid())
3692        return false;
3693
3694    bool needs_update = false;
3695
3696    // The target has to be non-null, and the
3697    Target *target = exe_scope->CalculateTarget();
3698    if (target != NULL)
3699    {
3700        Target *old_target = m_target_sp.get();
3701        assert (target == old_target);
3702        Process *process = exe_scope->CalculateProcess();
3703        if (process != NULL)
3704        {
3705            // FOR NOW - assume you can't update variable objects across process boundaries.
3706            Process *old_process = m_process_sp.get();
3707            assert (process == old_process);
3708            ProcessModID current_mod_id = process->GetModID();
3709            if (m_mod_id != current_mod_id)
3710            {
3711                needs_update = true;
3712                m_mod_id = current_mod_id;
3713            }
3714            // See if we're switching the thread or stack context.  If no thread is given, this is
3715            // being evaluated in a global context.
3716            Thread *thread = exe_scope->CalculateThread();
3717            if (thread != NULL)
3718            {
3719                user_id_t new_thread_index = thread->GetIndexID();
3720                if (new_thread_index != m_thread_id)
3721                {
3722                    needs_update = true;
3723                    m_thread_id = new_thread_index;
3724                    m_stack_id.Clear();
3725                }
3726
3727                StackFrame *new_frame = exe_scope->CalculateStackFrame();
3728                if (new_frame != NULL)
3729                {
3730                    if (new_frame->GetStackID() != m_stack_id)
3731                    {
3732                        needs_update = true;
3733                        m_stack_id = new_frame->GetStackID();
3734                    }
3735                }
3736                else
3737                {
3738                    m_stack_id.Clear();
3739                    needs_update = true;
3740                }
3741            }
3742            else
3743            {
3744                // If this had been given a thread, and now there is none, we should update.
3745                // Otherwise we don't have to do anything.
3746                if (m_thread_id != LLDB_INVALID_UID)
3747                {
3748                    m_thread_id = LLDB_INVALID_UID;
3749                    m_stack_id.Clear();
3750                    needs_update = true;
3751                }
3752            }
3753        }
3754        else
3755        {
3756            // If there is no process, then we don't need to update anything.
3757            // But if we're switching from having a process to not, we should try to update.
3758            if (m_process_sp.get() != NULL)
3759            {
3760                needs_update = true;
3761                m_process_sp.reset();
3762                m_thread_id = LLDB_INVALID_UID;
3763                m_stack_id.Clear();
3764            }
3765        }
3766    }
3767    else
3768    {
3769        // If there's no target, nothing can change so we don't need to update anything.
3770        // But if we're switching from having a target to not, we should try to update.
3771        if (m_target_sp.get() != NULL)
3772        {
3773            needs_update = true;
3774            m_target_sp.reset();
3775            m_process_sp.reset();
3776            m_thread_id = LLDB_INVALID_UID;
3777            m_stack_id.Clear();
3778        }
3779    }
3780    if (!m_needs_update)
3781        m_needs_update = needs_update;
3782
3783    return needs_update;
3784}
3785
3786void
3787ValueObject::ClearUserVisibleData()
3788{
3789    m_location_str.clear();
3790    m_value_str.clear();
3791    m_summary_str.clear();
3792    m_object_desc_str.clear();
3793    m_is_getting_summary = false;
3794}
3795
3796SymbolContextScope *
3797ValueObject::GetSymbolContextScope()
3798{
3799    if (m_parent)
3800    {
3801        if (!m_parent->IsPointerOrReferenceType())
3802            return m_parent->GetSymbolContextScope();
3803    }
3804    return NULL;
3805}
3806