Redesign of the interaction between Python and frozen objects:

 - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from
   a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored
   in frozen objects ; now such reads transparently move from host to target as required
 - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also
   removed code that enabled to recognize an expression result VO as such
 - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO
   representing a T* or T[], and doing dereferences transparently
   in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData
 - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it
   en lieu of doing the raw read itself
 - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers,
   this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory)
   in public layer this returns an SBData, just like GetPointeeData()
 - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData
   the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any
   of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values
 - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing
Solved a bug where global pointers to global variables were not dereferenced correctly for display
New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128
Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command
Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type
 of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file
 addresses that generate file address children UNLESS we have a live process)
Updated help text for summary-string
Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers
Edited the syntax and help for some commands to have proper argument types

llvm-svn: 139160

1 files changed, 221 insertions, 0 deletions

diff --git a/lldb/source/Core/ValueObjectConstResultImpl.cpp b/lldb/source/Core/ValueObjectConstResultImpl.cpp
new file mode 100644
index 00000000000..119ba015590
--- /dev/null
+++ b/lldb/source/Core/ValueObjectConstResultImpl.cpp
@@ -0,0 +1,221 @@
+//===-- ValueObjectConstResultImpl.cpp ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/ValueObjectConstResultImpl.h"
+
+#include "lldb/Core/ValueObjectChild.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Core/ValueObjectConstResultChild.h"
+#include "lldb/Core/ValueObjectMemory.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ValueObjectList.h"
+
+#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/Variable.h"
+
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+// this macro enables a simpler implementation for some method calls in this object that relies only upon
+// ValueObject knowning how to set the address type of its children correctly. the alternative implementation
+// relies on being able to create a target copy of the frozen object, which makes it less bug-prone but less
+// efficient as well. once we are confident the faster implementation is bug-free, this macro (and the slower
+// implementations) can go
+#define TRIVIAL_IMPL 1
+
+ValueObjectConstResultImpl::ValueObjectConstResultImpl (ValueObject* valobj,
+                                                        lldb::addr_t live_address) :
+    m_impl_backend(valobj),
+    m_live_address(live_address), 
+    m_load_addr_backend(),
+    m_address_of_backend()
+{
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultImpl::DerefOnTarget()
+{
+    if (m_load_addr_backend.get() == NULL)
+    {
+        lldb::addr_t tgt_address = m_impl_backend->GetPointerValue();
+        m_load_addr_backend = ValueObjectConstResult::Create (m_impl_backend->GetExecutionContextScope(),
+                                                              m_impl_backend->GetClangAST(),
+                                                              m_impl_backend->GetClangType(),
+                                                              m_impl_backend->GetName(),
+                                                              tgt_address,
+                                                              eAddressTypeLoad,
+                                                              m_impl_backend->GetUpdatePoint().GetProcessSP()->GetAddressByteSize());
+    }
+    return m_load_addr_backend;
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultImpl::Dereference (Error &error)
+{
+    if (m_impl_backend == NULL)
+        return lldb::ValueObjectSP();
+    
+#if defined (TRIVIAL_IMPL) && TRIVIAL_IMPL == 1
+    return m_impl_backend->ValueObject::Dereference(error);
+#else
+    m_impl_backend->UpdateValueIfNeeded(false);
+        
+    if (NeedsDerefOnTarget())
+        return DerefOnTarget()->Dereference(error);
+    else
+        return m_impl_backend->ValueObject::Dereference(error);
+#endif
+}
+
+ValueObject *
+ValueObjectConstResultImpl::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int32_t synthetic_index)
+{
+    if (m_impl_backend == NULL)
+        return NULL;
+
+    m_impl_backend->UpdateValueIfNeeded(false);
+    
+    ValueObjectConstResultChild *valobj = NULL;
+    
+    bool omit_empty_base_classes = true;
+    bool ignore_array_bounds = synthetic_array_member;
+    std::string child_name_str;
+    uint32_t child_byte_size = 0;
+    int32_t child_byte_offset = 0;
+    uint32_t child_bitfield_bit_size = 0;
+    uint32_t child_bitfield_bit_offset = 0;
+    bool child_is_base_class = false;
+    bool child_is_deref_of_parent = false;
+    
+    const bool transparent_pointers = synthetic_array_member == false;
+    clang::ASTContext *clang_ast = m_impl_backend->GetClangAST();
+    lldb::clang_type_t clang_type = m_impl_backend->GetClangType();
+    lldb::clang_type_t child_clang_type;
+    
+    ExecutionContext exe_ctx;
+    m_impl_backend->GetExecutionContextScope()->CalculateExecutionContext (exe_ctx);
+    
+    child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx,
+                                                                  clang_ast,
+                                                                  m_impl_backend->GetName().GetCString(),
+                                                                  clang_type,
+                                                                  idx,
+                                                                  transparent_pointers,
+                                                                  omit_empty_base_classes,
+                                                                  ignore_array_bounds,
+                                                                  child_name_str,
+                                                                  child_byte_size,
+                                                                  child_byte_offset,
+                                                                  child_bitfield_bit_size,
+                                                                  child_bitfield_bit_offset,
+                                                                  child_is_base_class,
+                                                                  child_is_deref_of_parent);
+    if (child_clang_type && child_byte_size)
+    {
+        if (synthetic_index)
+            child_byte_offset += child_byte_size * synthetic_index;
+        
+        ConstString child_name;
+        if (!child_name_str.empty())
+            child_name.SetCString (child_name_str.c_str());
+        
+        valobj = new ValueObjectConstResultChild (*m_impl_backend,
+                                                  clang_ast,
+                                                  child_clang_type,
+                                                  child_name,
+                                                  child_byte_size,
+                                                  child_byte_offset,
+                                                  child_bitfield_bit_size,
+                                                  child_bitfield_bit_offset,
+                                                  child_is_base_class,
+                                                  child_is_deref_of_parent);
+        valobj->m_impl.SetLiveAddress(m_live_address+child_byte_offset);
+    }
+    
+    return valobj;
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultImpl::GetSyntheticChildAtOffset (uint32_t offset, const ClangASTType& type, bool can_create)
+{
+    if (m_impl_backend == NULL)
+        return lldb::ValueObjectSP();
+
+#if defined (TRIVIAL_IMPL) && TRIVIAL_IMPL == 1
+    return m_impl_backend->ValueObject::GetSyntheticChildAtOffset(offset, type, can_create);
+#else
+    m_impl_backend->UpdateValueIfNeeded(false);
+    
+    if (NeedsDerefOnTarget())
+        return DerefOnTarget()->GetSyntheticChildAtOffset(offset, type, can_create);
+    else
+        return m_impl_backend->ValueObject::GetSyntheticChildAtOffset(offset, type, can_create);
+#endif
+}
+
+lldb::ValueObjectSP
+ValueObjectConstResultImpl::AddressOf (Error &error)
+{
+    if (m_address_of_backend.get() != NULL)
+        return m_address_of_backend;
+    
+    if (m_impl_backend == NULL)
+        return lldb::ValueObjectSP();
+    if (m_live_address != LLDB_INVALID_ADDRESS)
+    {
+        ClangASTType type(m_impl_backend->GetClangAST(), m_impl_backend->GetClangType());
+        
+        lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&m_live_address,sizeof(lldb::addr_t)));
+        
+        std::string new_name("&");
+        new_name.append(m_impl_backend->GetName().AsCString(""));
+        
+        m_address_of_backend = ValueObjectConstResult::Create(m_impl_backend->GetUpdatePoint().GetExecutionContextScope(),
+                                                              type.GetASTContext(),
+                                                              type.GetPointerType(),
+                                                              ConstString(new_name.c_str()),
+                                                              buffer,
+                                                              lldb::endian::InlHostByteOrder(), 
+                                                              m_impl_backend->GetExecutionContextScope()->CalculateProcess()->GetAddressByteSize());
+        
+        m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar);
+        m_address_of_backend->GetValue().GetScalar() = m_live_address;
+        
+        return m_address_of_backend;
+    }
+    else
+        return lldb::ValueObjectSP();
+}
+
+size_t
+ValueObjectConstResultImpl::GetPointeeData (DataExtractor& data,
+                                            uint32_t item_idx,
+                                            uint32_t item_count)
+{
+    if (m_impl_backend == NULL)
+        return 0;
+#if defined (TRIVIAL_IMPL) && TRIVIAL_IMPL == 1
+    return m_impl_backend->ValueObject::GetPointeeData(data, item_idx, item_count);
+#else
+    m_impl_backend->UpdateValueIfNeeded(false);
+    
+    if (NeedsDerefOnTarget() && m_impl_backend->IsPointerType())
+        return DerefOnTarget()->GetPointeeData(data, item_idx, item_count);
+    else
+        return m_impl_backend->ValueObject::GetPointeeData(data, item_idx, item_count);
+#endif
+}