Import LLDB as of upstream SVN r225923 (git 2b588ecd)

This corresponds with the branchpoint for the 3.6 release.
A number of files not required for the FreeBSD build have been removed.

Sponsored by:	DARPA, AFRL

1 files changed, 179 insertions, 401 deletions

diff --git a/source/DataFormatters/CXXFormatterFunctions.cpp b/source/DataFormatters/CXXFormatterFunctions.cpp
index ae5b35f..04cdadf 100644
--- a/source/DataFormatters/CXXFormatterFunctions.cpp
+++ b/source/DataFormatters/CXXFormatterFunctions.cpp
@@ -10,6 +10,8 @@
 #include "lldb/lldb-python.h"
 
 #include "lldb/DataFormatters/CXXFormatterFunctions.h"
+#include "lldb/DataFormatters/StringPrinter.h"
+#include "lldb/DataFormatters/TypeSummary.h"
 
 #include "llvm/Support/ConvertUTF.h"
 
@@ -20,10 +22,16 @@
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include "lldb/Utility/ProcessStructReader.h"
+
 #include <algorithm>
+#if __ANDROID_NDK__
+#include <sys/types.h>
+#endif
 
 using namespace lldb;
 using namespace lldb_private;
@@ -187,283 +195,53 @@ lldb_private::formatters::CallSelectorOnObject (ValueObject &valobj,
     return valobj_sp;
 }
 
-// use this call if you already have an LLDB-side buffer for the data
-template<typename SourceDataType>
-static bool
-DumpUTFBufferToStream (ConversionResult (*ConvertFunction) (const SourceDataType**,
-                                                            const SourceDataType*,
-                                                            UTF8**,
-                                                            UTF8*,
-                                                            ConversionFlags),
-                       DataExtractor& data,
-                       Stream& stream,
-                       char prefix_token = '@',
-                       char quote = '"',
-                       uint32_t sourceSize = 0)
+bool
+lldb_private::formatters::FunctionPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
-    if (prefix_token != 0)
-        stream.Printf("%c",prefix_token);
-    if (quote != 0)
-        stream.Printf("%c",quote);
-    if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd())
+    std::string destination;
+    StreamString sstr;
+    AddressType func_ptr_address_type = eAddressTypeInvalid;
+    addr_t func_ptr_address = valobj.GetPointerValue (&func_ptr_address_type);
+    if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS)
     {
-        const int bufferSPSize = data.GetByteSize();
-        if (sourceSize == 0)
-        {
-            const int origin_encoding = 8*sizeof(SourceDataType);
-            sourceSize = bufferSPSize/(origin_encoding / 4);
-        }
-        
-        SourceDataType *data_ptr = (SourceDataType*)data.GetDataStart();
-        SourceDataType *data_end_ptr = data_ptr + sourceSize;
-        
-        while (data_ptr < data_end_ptr)
+        switch (func_ptr_address_type)
         {
-            if (!*data_ptr)
-            {
-                data_end_ptr = data_ptr;
+            case eAddressTypeInvalid:
+            case eAddressTypeFile:
+            case eAddressTypeHost:
                 break;
+                
+            case eAddressTypeLoad:
+            {
+                ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+                
+                Address so_addr;
+                Target *target = exe_ctx.GetTargetPtr();
+                if (target && target->GetSectionLoadList().IsEmpty() == false)
+                {
+                    if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr))
+                    {
+                        so_addr.Dump (&sstr,
+                                      exe_ctx.GetBestExecutionContextScope(),
+                                      Address::DumpStyleResolvedDescription,
+                                      Address::DumpStyleSectionNameOffset);
+                    }
+                }
             }
-            data_ptr++;
-        }
-        
-        data_ptr = (SourceDataType*)data.GetDataStart();
-        
-        lldb::DataBufferSP utf8_data_buffer_sp;
-        UTF8* utf8_data_ptr = nullptr;
-        UTF8* utf8_data_end_ptr = nullptr;
-        
-        if (ConvertFunction)
-        {
-            utf8_data_buffer_sp.reset(new DataBufferHeap(4*bufferSPSize,0));
-            utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes();
-            utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
-            ConvertFunction ( (const SourceDataType**)&data_ptr, data_end_ptr, &utf8_data_ptr, utf8_data_end_ptr, lenientConversion );
-            utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes(); // needed because the ConvertFunction will change the value of the data_ptr
-        }
-        else
-        {
-            // just copy the pointers - the cast is necessary to make the compiler happy
-            // but this should only happen if we are reading UTF8 data
-            utf8_data_ptr = (UTF8*)data_ptr;
-            utf8_data_end_ptr = (UTF8*)data_end_ptr;
-        }
-        
-        // since we tend to accept partial data (and even partially malformed data)
-        // we might end up with no NULL terminator before the end_ptr
-        // hence we need to take a slower route and ensure we stay within boundaries
-        for (;utf8_data_ptr != utf8_data_end_ptr; utf8_data_ptr++)
-        {
-            if (!*utf8_data_ptr)
                 break;
-            stream.Printf("%c",*utf8_data_ptr);
         }
     }
-    if (quote != 0)
-        stream.Printf("%c",quote);
-    return true;
-}
-
-template<typename SourceDataType>
-class ReadUTFBufferAndDumpToStreamOptions
-{
-public:
-    typedef ConversionResult (*ConvertFunctionType) (const SourceDataType**,
-                                                     const SourceDataType*,
-                                                     UTF8**,
-                                                     UTF8*,
-                                                     ConversionFlags);
-    
-    ReadUTFBufferAndDumpToStreamOptions () :
-    m_conversion_function(NULL),
-    m_location(0),
-    m_process_sp(),
-    m_stream(NULL),
-    m_prefix_token('@'),
-    m_quote('"'),
-    m_source_size(0),
-    m_needs_zero_termination(true)
-    {
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetConversionFunction (ConvertFunctionType f)
-    {
-        m_conversion_function = f;
-        return *this;
-    }
-    
-    ConvertFunctionType
-    GetConversionFunction () const
-    {
-        return m_conversion_function;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetLocation (uint64_t l)
-    {
-        m_location = l;
-        return *this;
-    }
-    
-    uint64_t
-    GetLocation () const
-    {
-        return m_location;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetProcessSP (ProcessSP p)
-    {
-        m_process_sp = p;
-        return *this;
-    }
-    
-    ProcessSP
-    GetProcessSP () const
-    {
-        return m_process_sp;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetStream (Stream* s)
-    {
-        m_stream = s;
-        return *this;
-    }
-    
-    Stream*
-    GetStream () const
-    {
-        return m_stream;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetPrefixToken (char p)
-    {
-        m_prefix_token = p;
-        return *this;
-    }
-    
-    char
-    GetPrefixToken () const
-    {
-        return m_prefix_token;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetQuote (char q)
-    {
-        m_quote = q;
-        return *this;
-    }
-    
-    char
-    GetQuote () const
-    {
-        return m_quote;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetSourceSize (uint32_t s)
-    {
-        m_source_size = s;
-        return *this;
-    }
-    
-    uint32_t
-    GetSourceSize () const
-    {
-        return m_source_size;
-    }
-    
-    ReadUTFBufferAndDumpToStreamOptions&
-    SetNeedsZeroTermination (bool z)
+    if (sstr.GetSize() > 0)
     {
-        m_needs_zero_termination = z;
-        return *this;
-    }
-    
-    bool
-    GetNeedsZeroTermination () const
-    {
-        return m_needs_zero_termination;
-    }
-    
-private:
-    ConvertFunctionType m_conversion_function;
-    uint64_t m_location;
-    ProcessSP m_process_sp;
-    Stream* m_stream;
-    char m_prefix_token;
-    char m_quote;
-    uint32_t m_source_size;
-    bool m_needs_zero_termination;
-};
-
-template<typename SourceDataType>
-static bool
-ReadUTFBufferAndDumpToStream (const ReadUTFBufferAndDumpToStreamOptions<SourceDataType>& options)
-{
-    if (options.GetLocation() == 0 || options.GetLocation() == LLDB_INVALID_ADDRESS)
-        return false;
-    
-    ProcessSP process_sp(options.GetProcessSP());
-    
-    if (!process_sp)
-        return false;
-
-    const int type_width = sizeof(SourceDataType);
-    const int origin_encoding = 8 * type_width ;
-    if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
-        return false;
-    // if not UTF8, I need a conversion function to return proper UTF8
-    if (origin_encoding != 8 && !options.GetConversionFunction())
-        return false;
-    
-    if (!options.GetStream())
-        return false;
-
-    uint32_t sourceSize = options.GetSourceSize();
-    bool needs_zero_terminator = options.GetNeedsZeroTermination();
-    
-    if (!sourceSize)
-    {
-        sourceSize = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
-        needs_zero_terminator = true;
+        stream.Printf("(%s)", sstr.GetData());
+        return true;
     }
     else
-        sourceSize = std::min(sourceSize,process_sp->GetTarget().GetMaximumSizeOfStringSummary());
-    
-    const int bufferSPSize = sourceSize * type_width;
-
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize,0));
-    
-    if (!buffer_sp->GetBytes())
         return false;
-    
-    Error error;
-    char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes()); 
-
-    size_t data_read = 0;
-    if (needs_zero_terminator)
-        data_read = process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
-    else
-        data_read = process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
-
-    if (error.Fail() || data_read == 0)
-    {
-        options.GetStream()->Printf("unable to read data");
-        return true;
-    }
-    
-    DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
-    
-    return DumpUTFBufferToStream(options.GetConversionFunction(), data, *options.GetStream(), options.GetPrefixToken(), options.GetQuote(), sourceSize);
 }
 
 bool
-lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -474,14 +252,13 @@ lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stre
     if (!valobj_addr)
         return false;
     
-    ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
+    ReadStringAndDumpToStreamOptions options(valobj);
     options.SetLocation(valobj_addr);
-    options.SetConversionFunction(ConvertUTF16toUTF8);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetPrefixToken('u');
     
-    if (!ReadUTFBufferAndDumpToStream(options))
+    if (!ReadStringAndDumpToStream<StringElementType::UTF16>(options))
     {
         stream.Printf("Summary Unavailable");
         return true;
@@ -491,7 +268,7 @@ lldb_private::formatters::Char16StringSummaryProvider (ValueObject& valobj, Stre
 }
 
 bool
-lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -502,14 +279,13 @@ lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stre
     if (!valobj_addr)
         return false;
     
-    ReadUTFBufferAndDumpToStreamOptions<UTF32> options;
+    ReadStringAndDumpToStreamOptions options(valobj);
     options.SetLocation(valobj_addr);
-    options.SetConversionFunction(ConvertUTF32toUTF8);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetPrefixToken('U');
     
-    if (!ReadUTFBufferAndDumpToStream(options))
+    if (!ReadStringAndDumpToStream<StringElementType::UTF32>(options))
     {
         stream.Printf("Summary Unavailable");
         return true;
@@ -519,7 +295,7 @@ lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stre
 }
 
 bool
-lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -543,45 +319,20 @@ lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Strea
     ClangASTType wchar_clang_type = ClangASTContext::GetBasicType(ast, lldb::eBasicTypeWChar);
     const uint32_t wchar_size = wchar_clang_type.GetBitSize();
 
+    ReadStringAndDumpToStreamOptions options(valobj);
+    options.SetLocation(data_addr);
+    options.SetProcessSP(process_sp);
+    options.SetStream(&stream);
+    options.SetPrefixToken('L');
+    
     switch (wchar_size)
     {
         case 8:
-        {
-            // utf 8
-            
-            ReadUTFBufferAndDumpToStreamOptions<UTF8> options;
-            options.SetLocation(data_addr);
-            options.SetConversionFunction(nullptr);
-            options.SetProcessSP(process_sp);
-            options.SetStream(&stream);
-            options.SetPrefixToken('L');
-
-            return ReadUTFBufferAndDumpToStream(options);
-        }
+            return ReadStringAndDumpToStream<StringElementType::UTF8>(options);
         case 16:
-        {
-            // utf 16
-            ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
-            options.SetLocation(data_addr);
-            options.SetConversionFunction(ConvertUTF16toUTF8);
-            options.SetProcessSP(process_sp);
-            options.SetStream(&stream);
-            options.SetPrefixToken('L');
-            
-            return ReadUTFBufferAndDumpToStream(options);
-        }
+            return ReadStringAndDumpToStream<StringElementType::UTF16>(options);
         case 32:
-        {
-            // utf 32
-            ReadUTFBufferAndDumpToStreamOptions<UTF32> options;
-            options.SetLocation(data_addr);
-            options.SetConversionFunction(ConvertUTF32toUTF8);
-            options.SetProcessSP(process_sp);
-            options.SetStream(&stream);
-            options.SetPrefixToken('L');
-            
-            return ReadUTFBufferAndDumpToStream(options);
-        }
+            return ReadStringAndDumpToStream<StringElementType::UTF32>(options);
         default:
             stream.Printf("size for wchar_t is not valid");
             return true;
@@ -590,7 +341,7 @@ lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Strea
 }
 
 bool
-lldb_private::formatters::Char16SummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::Char16SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     DataExtractor data;
     Error error;
@@ -604,11 +355,18 @@ lldb_private::formatters::Char16SummaryProvider (ValueObject& valobj, Stream& st
     if (!value.empty())
         stream.Printf("%s ", value.c_str());
 
-    return DumpUTFBufferToStream<UTF16>(ConvertUTF16toUTF8,data,stream, 'u','\'',1);
+    ReadBufferAndDumpToStreamOptions options(valobj);
+    options.SetData(data);
+    options.SetStream(&stream);
+    options.SetPrefixToken('u');
+    options.SetQuote('\'');
+    options.SetSourceSize(1);
+    
+    return ReadBufferAndDumpToStream<StringElementType::UTF16>(options);
 }
 
 bool
-lldb_private::formatters::Char32SummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::Char32SummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     DataExtractor data;
     Error error;
@@ -622,11 +380,18 @@ lldb_private::formatters::Char32SummaryProvider (ValueObject& valobj, Stream& st
     if (!value.empty())
         stream.Printf("%s ", value.c_str());
     
-    return DumpUTFBufferToStream<UTF32>(ConvertUTF32toUTF8,data,stream, 'U','\'',1);
+    ReadBufferAndDumpToStreamOptions options(valobj);
+    options.SetData(data);
+    options.SetStream(&stream);
+    options.SetPrefixToken('U');
+    options.SetQuote('\'');
+    options.SetSourceSize(1);
+    
+    return ReadBufferAndDumpToStream<StringElementType::UTF32>(options);
 }
 
 bool
-lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions&)
 {
     DataExtractor data;
     Error error;
@@ -635,55 +400,14 @@ lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& str
     if (error.Fail())
         return false;
     
-    clang::ASTContext* ast = valobj.GetClangType().GetASTContext();
-    
-    if (!ast)
-        return false;
-    
-    ClangASTType wchar_clang_type = ClangASTContext::GetBasicType(ast, lldb::eBasicTypeWChar);
-    const uint32_t wchar_size = wchar_clang_type.GetBitSize();
-    std::string value;
+    ReadBufferAndDumpToStreamOptions options(valobj);
+    options.SetData(data);
+    options.SetStream(&stream);
+    options.SetPrefixToken('L');
+    options.SetQuote('\'');
+    options.SetSourceSize(1);
     
-    switch (wchar_size)
-    {
-        case 8:
-            // utf 8
-            valobj.GetValueAsCString(lldb::eFormatChar, value);
-            if (!value.empty())
-                stream.Printf("%s ", value.c_str());
-            return DumpUTFBufferToStream<UTF8>(nullptr,
-                                               data,
-                                               stream,
-                                               'L',
-                                               '\'',
-                                               1);
-        case 16:
-            // utf 16
-            valobj.GetValueAsCString(lldb::eFormatUnicode16, value);
-            if (!value.empty())
-                stream.Printf("%s ", value.c_str());
-            return DumpUTFBufferToStream<UTF16>(ConvertUTF16toUTF8,
-                                                data,
-                                                stream,
-                                                'L',
-                                                '\'',
-                                                1);
-        case 32:
-            // utf 32
-            valobj.GetValueAsCString(lldb::eFormatUnicode32, value);
-            if (!value.empty())
-                stream.Printf("%s ", value.c_str());
-            return DumpUTFBufferToStream<UTF32>(ConvertUTF32toUTF8,
-                                                data,
-                                                stream,
-                                                'L',
-                                                '\'',
-                                                1);
-        default:
-            stream.Printf("size for wchar_t is not valid");
-            return true;
-    }
-    return true;
+    return ReadBufferAndDumpToStream<StringElementType::UTF16>(options);
 }
 
 // the field layout in a libc++ string (cap, side, data or data, size, cap)
@@ -769,7 +493,7 @@ ExtractLibcxxStringInfo (ValueObject& valobj,
 }
 
 bool
-lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     uint64_t size = 0;
     ValueObjectSP location_sp((ValueObject*)nullptr);
@@ -782,34 +506,45 @@ lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Str
     }   
     if (!location_sp)
         return false;
-    return WCharStringSummaryProvider(*location_sp.get(), stream);
+    return WCharStringSummaryProvider(*location_sp.get(), stream, options);
 }
 
 bool
-lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
 {
     uint64_t size = 0;
     ValueObjectSP location_sp((ValueObject*)nullptr);
+    
     if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
         return false;
+    
     if (size == 0)
     {
         stream.Printf("\"\"");
         return true;
     }
+    
     if (!location_sp)
         return false;
-    Error error;
-    if (location_sp->ReadPointedString(stream,
-                                       error,
-                                       0, // max length is decided by the settings
-                                       false) == 0) // do not honor array (terminates on first 0 byte even for a char[])
-        stream.Printf("\"\""); // if nothing was read, print an empty string
-    return error.Success();
+    
+    DataExtractor extractor;
+    if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped)
+        size = std::min<decltype(size)>(size, valobj.GetTargetSP()->GetMaximumSizeOfStringSummary());
+    location_sp->GetPointeeData(extractor, 0, size);
+    
+    ReadBufferAndDumpToStreamOptions options(valobj);
+    options.SetData(extractor); // none of this matters for a string - pass some defaults
+    options.SetStream(&stream);
+    options.SetPrefixToken(0);
+    options.SetQuote('"');
+    options.SetSourceSize(size);
+    lldb_private::formatters::ReadBufferAndDumpToStream<lldb_private::formatters::StringElementType::ASCII>(options);
+    
+    return true;
 }
 
 bool
-lldb_private::formatters::ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -886,7 +621,7 @@ lldb_private::formatters::ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildre
 
 template<bool needs_at>
 bool
-lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -1037,8 +772,28 @@ lldb_private::formatters::NSTaggedString_SummaryProvider (ObjCLanguageRuntime::C
     return true;
 }
 
+static ClangASTType
+GetNSPathStore2Type (Target &target)
+{
+    static ConstString g_type_name("__lldb_autogen_nspathstore2");
+
+    ClangASTContext *ast_ctx = target.GetScratchClangASTContext();
+    
+    if (!ast_ctx)
+        return ClangASTType();
+    
+    ClangASTType voidstar = ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType();
+    ClangASTType uint32 = ast_ctx->GetIntTypeFromBitSize(32, false);
+    
+    return ast_ctx->GetOrCreateStructForIdentifier(g_type_name, {
+        {"isa",voidstar},
+        {"lengthAndRef",uint32},
+        {"buffer",voidstar}
+    });
+}
+
 bool
-lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& summary_options)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
@@ -1131,8 +886,7 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
             return false;
         if (has_explicit_length && is_unicode)
         {
-            ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
-            options.SetConversionFunction(ConvertUTF16toUTF8);
+            ReadStringAndDumpToStreamOptions options(valobj);
             options.SetLocation(location);
             options.SetProcessSP(process_sp);
             options.SetStream(&stream);
@@ -1140,10 +894,21 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
             options.SetQuote('"');
             options.SetSourceSize(explicit_length);
             options.SetNeedsZeroTermination(false);
-            return ReadUTFBufferAndDumpToStream (options);
+            options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+            return ReadStringAndDumpToStream<StringElementType::UTF16>(options);
         }
         else
-            return ReadAsciiBufferAndDumpToStream(location+1,process_sp,stream, explicit_length);
+        {
+            ReadStringAndDumpToStreamOptions options(valobj);
+            options.SetLocation(location+1);
+            options.SetProcessSP(process_sp);
+            options.SetStream(&stream);
+            options.SetPrefixToken('@');
+            options.SetSourceSize(explicit_length);
+            options.SetNeedsZeroTermination(false);
+            options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+            return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
+        }
     }
     else if (is_inline && has_explicit_length && !is_unicode && !is_special && !is_mutable)
     {
@@ -1169,8 +934,7 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
             if (error.Fail())
                 return false;
         }
-        ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
-        options.SetConversionFunction(ConvertUTF16toUTF8);
+        ReadStringAndDumpToStreamOptions options(valobj);
         options.SetLocation(location);
         options.SetProcessSP(process_sp);
         options.SetStream(&stream);
@@ -1178,13 +942,16 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
         options.SetQuote('"');
         options.SetSourceSize(explicit_length);
         options.SetNeedsZeroTermination(has_explicit_length == false);
-        return ReadUTFBufferAndDumpToStream (options);
+        options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+        return ReadStringAndDumpToStream<StringElementType::UTF16> (options);
     }
     else if (is_special)
     {
-        uint64_t location = valobj_addr + (ptr_size == 8 ? 12 : 8);
-        ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
-        options.SetConversionFunction(ConvertUTF16toUTF8);
+        ProcessStructReader reader(valobj.GetProcessSP().get(), valobj.GetValueAsUnsigned(0), GetNSPathStore2Type(*valobj.GetTargetSP()));
+        explicit_length = reader.GetField<uint32_t>(ConstString("lengthAndRef")) >> 20;
+        lldb::addr_t location = valobj.GetValueAsUnsigned(0) + ptr_size + 4;
+        
+        ReadStringAndDumpToStreamOptions options(valobj);
         options.SetLocation(location);
         options.SetProcessSP(process_sp);
         options.SetStream(&stream);
@@ -1192,14 +959,22 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
         options.SetQuote('"');
         options.SetSourceSize(explicit_length);
         options.SetNeedsZeroTermination(has_explicit_length == false);
-        return ReadUTFBufferAndDumpToStream (options);
+        options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+        return ReadStringAndDumpToStream<StringElementType::UTF16> (options);
     }
     else if (is_inline)
     {
         uint64_t location = valobj_addr + 2*ptr_size;
         if (!has_explicit_length)
             location++;
-        return ReadAsciiBufferAndDumpToStream(location,process_sp,stream,explicit_length);
+        ReadStringAndDumpToStreamOptions options(valobj);
+        options.SetLocation(location);
+        options.SetProcessSP(process_sp);
+        options.SetStream(&stream);
+        options.SetPrefixToken('@');
+        options.SetSourceSize(explicit_length);
+        options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+        return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
     }
     else
     {
@@ -1209,16 +984,19 @@ lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream&
             return false;
         if (has_explicit_length && !has_null)
             explicit_length++; // account for the fact that there is no NULL and we need to have one added
-        return ReadAsciiBufferAndDumpToStream(location,process_sp,stream,explicit_length);
+        ReadStringAndDumpToStreamOptions options(valobj);
+        options.SetLocation(location);
+        options.SetProcessSP(process_sp);
+        options.SetPrefixToken('@');
+        options.SetStream(&stream);
+        options.SetSourceSize(explicit_length);
+        options.SetIgnoreMaxLength(summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryUncapped);
+        return ReadStringAndDumpToStream<StringElementType::ASCII>(options);
     }
-    
-    stream.Printf("class name = %s",class_name);
-    return true;
-    
 }
 
 bool
-lldb_private::formatters::NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     TargetSP target_sp(valobj.GetTargetSP());
     if (!target_sp)
@@ -1241,38 +1019,38 @@ lldb_private::formatters::NSAttributedStringSummaryProvider (ValueObject& valobj
     ValueObjectSP child_sp(child_ptr_sp->CreateValueObjectFromData("string_data", data, exe_ctx, type));
     child_sp->GetValueAsUnsigned(0);
     if (child_sp)
-        return NSStringSummaryProvider(*child_sp, stream);
+        return NSStringSummaryProvider(*child_sp, stream, options);
     return false;
 }
 
 bool
-lldb_private::formatters::NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
-    return NSAttributedStringSummaryProvider(valobj, stream);
+    return NSAttributedStringSummaryProvider(valobj, stream, options);
 }
 
 bool
-lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     stream.Printf("%s",valobj.GetObjectDescription());
     return true;
 }
 
 bool
-lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     const uint32_t type_info = valobj.GetClangType().GetTypeInfo();
     
     ValueObjectSP real_guy_sp = valobj.GetSP();
     
-    if (type_info & ClangASTType::eTypeIsPointer)
+    if (type_info & eTypeIsPointer)
     {
         Error err;
         real_guy_sp = valobj.Dereference(err);
         if (err.Fail() || !real_guy_sp)
             return false;
     }
-    else if (type_info & ClangASTType::eTypeIsReference)
+    else if (type_info & eTypeIsReference)
     {
         real_guy_sp =  valobj.GetChildAtIndex(0, true);
         if (!real_guy_sp)
@@ -1290,7 +1068,7 @@ lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream&
 
 template <bool is_sel_ptr>
 bool
-lldb_private::formatters::ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream)
+lldb_private::formatters::ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
 {
     lldb::ValueObjectSP valobj_sp;
 
@@ -1398,7 +1176,7 @@ lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update()
         return false;
     Error err;
     m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
-    m_item_sp = ValueObject::CreateValueObjectFromAddress("item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref, item_ptr->GetClangType().GetPointeeType());
+    m_item_sp = CreateValueObjectFromAddress("item", item_ptr->GetValueAsUnsigned(0), m_exe_ctx_ref, item_ptr->GetClangType().GetPointeeType());
     if (err.Fail())
         m_item_sp.reset();
     return false;
@@ -1437,13 +1215,13 @@ lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSynthe
 }
 
 template bool
-lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&) ;
+lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
 
 template bool
-lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&) ;
+lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
 
 template bool
-lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&) ;
+lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&, const TypeSummaryOptions&) ;
 
 template bool
-lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&) ;
+lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&, const TypeSummaryOptions&) ;