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, 77 insertions, 78 deletions

diff --git a/lldb/source/Core/DataExtractor.cpp b/lldb/source/Core/DataExtractor.cpp
index d869aaef669..2cfced03800 100644
--- a/lldb/source/Core/DataExtractor.cpp
+++ b/lldb/source/Core/DataExtractor.cpp
@@ -17,6 +17,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/MathExtras.h"
 
+#include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/Log.h"
@@ -178,15 +179,6 @@ DataExtractor::Clear ()
 }
 
 //------------------------------------------------------------------
-// Returns the total number of bytes that this object refers to
-//------------------------------------------------------------------
-size_t
-DataExtractor::GetByteSize () const
-{
-    return m_end - m_start;
-}
-
-//------------------------------------------------------------------
 // If this object contains shared data, this function returns the
 // offset into that shared data. Else zero is returned.
 //------------------------------------------------------------------
@@ -210,16 +202,6 @@ DataExtractor::GetSharedDataOffset () const
 }
 
 //------------------------------------------------------------------
-// Returns true if OFFSET is a valid offset into the data in this
-// object.
-//------------------------------------------------------------------
-bool
-DataExtractor::ValidOffset (uint32_t offset) const
-{
-    return offset < GetByteSize();
-}
-
-//------------------------------------------------------------------
 // Returns true if there are LENGTH bytes availabe starting OFFSET
 // into the data that is in this object.
 //------------------------------------------------------------------
@@ -245,65 +227,6 @@ DataExtractor::ValidOffsetForDataOfSize (uint32_t offset, uint32_t length) const
     return ((offset + length) <= size);
 }
 
-//------------------------------------------------------------------
-// Returns a pointer to the first byte contained in this object's
-// data, or NULL of there is no data in this object.
-//------------------------------------------------------------------
-const uint8_t *
-DataExtractor::GetDataStart () const
-{
-    return m_start;
-}
-//------------------------------------------------------------------
-// Returns a pointer to the byte past the last byte contained in
-// this object's data, or NULL of there is no data in this object.
-//------------------------------------------------------------------
-const uint8_t *
-DataExtractor::GetDataEnd () const
-{
-    return m_end;
-}
-
-//------------------------------------------------------------------
-// Returns true if this object will endian swap values as it
-// extracts data.
-//------------------------------------------------------------------
-ByteOrder
-DataExtractor::GetByteOrder () const
-{
-    return m_byte_order;
-}
-//------------------------------------------------------------------
-// Set whether this object will endian swap values as it extracts
-// data.
-//------------------------------------------------------------------
-void
-DataExtractor::SetByteOrder (ByteOrder endian)
-{
-    m_byte_order = endian;
-}
-
-
-//------------------------------------------------------------------
-// Return the size in bytes of any address values this object will
-// extract
-//------------------------------------------------------------------
-uint8_t
-DataExtractor::GetAddressByteSize () const
-{
-    return m_addr_size;
-}
-
-//------------------------------------------------------------------
-// Set the size in bytes that will be used when extracting any
-// address values from data contained in this object.
-//------------------------------------------------------------------
-void
-DataExtractor::SetAddressByteSize (uint8_t addr_size)
-{
-    m_addr_size = addr_size;
-}
-
 //----------------------------------------------------------------------
 // Set the data with which this object will extract from to data
 // starting at BYTES and set the length of the data to LENGTH bytes
@@ -1901,3 +1824,79 @@ DataExtractor::DumpHexBytes (Stream *s,
                base_addr,       // Base address
                0, 0);           // Bitfield info
 }
+
+size_t
+DataExtractor::Copy (DataExtractor &dest_data) const
+{
+    if (m_data_sp.get())
+    {
+        // we can pass along the SP to the data
+        dest_data.SetData(m_data_sp);
+    }
+    else
+    {
+        const uint8_t *base_ptr = m_start;
+        size_t data_size = GetByteSize();
+        dest_data.SetData(DataBufferSP(new DataBufferHeap(base_ptr, data_size)));
+    }
+    return GetByteSize();
+}
+
+bool
+DataExtractor::Append(DataExtractor& rhs)
+{
+    if (rhs.GetByteOrder() != GetByteOrder())
+        return false;
+    
+    if (rhs.GetByteSize() == 0)
+        return true;
+    
+    if (GetByteSize() == 0)
+        return (rhs.Copy(*this) > 0);
+    
+    size_t bytes = GetByteSize() + rhs.GetByteSize();
+
+    DataBufferHeap *buffer_heap_ptr = NULL;
+    DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
+    
+    if (buffer_sp.get() == NULL || buffer_heap_ptr == NULL)
+        return false;
+    
+    uint8_t* bytes_ptr = buffer_heap_ptr->GetBytes();
+    
+    memcpy(bytes_ptr, GetDataStart(), GetByteSize());
+    memcpy(bytes_ptr + GetByteSize(), rhs.GetDataStart(), rhs.GetByteSize());
+    
+    SetData(buffer_sp);
+    
+    return true;
+}
+
+bool
+DataExtractor::Append(void* buf, uint32_t length)
+{
+    if (buf == NULL)
+        return false;
+    
+    if (length == 0)
+        return true;
+    
+    size_t bytes = GetByteSize() + length;
+    
+    DataBufferHeap *buffer_heap_ptr = NULL;
+    DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
+    
+    if (buffer_sp.get() == NULL || buffer_heap_ptr == NULL)
+        return false;
+    
+    uint8_t* bytes_ptr = buffer_heap_ptr->GetBytes();
+    
+    if (GetByteSize() > 0)
+        memcpy(bytes_ptr, GetDataStart(), GetByteSize());
+
+    memcpy(bytes_ptr + GetByteSize(), buf, length);
+    
+    SetData(buffer_sp);
+    
+    return true;
+}
\ No newline at end of file