Import lldb as of SVN r188801

(A number of files not required for the FreeBSD build have been removed.)

Sponsored by:	DARPA, AFRL

19 files changed, 7894 insertions, 0 deletions

diff --git a/source/DataFormatters/CF.cpp b/source/DataFormatters/CF.cpp
new file mode 100644
index 0000000..a4b7a12
--- /dev/null
+++ b/source/DataFormatters/CF.cpp
@@ -0,0 +1,299 @@
+//===-- CF.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+bool
+lldb_private::formatters::CFAbsoluteTimeSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    time_t epoch = GetOSXEpoch();
+    epoch = epoch + (time_t)valobj.GetValueAsUnsigned(0);
+    tm *tm_date = localtime(&epoch);
+    if (!tm_date)
+        return false;
+    std::string buffer(1024,0);
+    if (strftime (&buffer[0], 1023, "%Z", tm_date) == 0)
+        return false;
+    stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year+1900, tm_date->tm_mon+1, tm_date->tm_mday, tm_date->tm_hour, tm_date->tm_min, tm_date->tm_sec, buffer.c_str());
+    return true;
+}
+
+bool
+lldb_private::formatters::CFBagSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint32_t count = 0;
+    
+    bool is_type_ok = false; // check to see if this is a CFBag we know about
+    if (descriptor->IsCFType())
+    {
+        ConstString type_name(valobj.GetTypeName());
+        if (type_name == ConstString("__CFBag") || type_name == ConstString("const struct __CFBag"))
+        {
+            if (valobj.IsPointerType())
+                is_type_ok = true;
+        }
+    }
+    
+    if (is_type_ok == false)
+    {
+        StackFrameSP frame_sp(valobj.GetFrameSP());
+        if (!frame_sp)
+            return false;
+        ValueObjectSP count_sp;
+        StreamString expr;
+        expr.Printf("(int)CFBagGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue());
+        if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp) != eExecutionCompleted)
+            return false;
+        if (!count_sp)
+            return false;
+        count = count_sp->GetValueAsUnsigned(0);
+    }
+    else
+    {
+        uint32_t offset = 2*ptr_size+4 + valobj_addr;
+        Error error;
+        count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    stream.Printf("@\"%u value%s\"",
+                  count,(count == 1 ? "" : "s"));
+    return true;
+}
+
+bool
+lldb_private::formatters::CFBitVectorSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint32_t count = 0;
+    
+    bool is_type_ok = false; // check to see if this is a CFBag we know about
+    if (descriptor->IsCFType())
+    {
+        ConstString type_name(valobj.GetTypeName());
+        if (type_name == ConstString("__CFMutableBitVector") || type_name == ConstString("__CFBitVector") || type_name == ConstString("CFMutableBitVectorRef") || type_name == ConstString("CFBitVectorRef"))
+        {
+            if (valobj.IsPointerType())
+                is_type_ok = true;
+        }
+    }
+    
+    if (is_type_ok == false)
+        return false;
+    
+    Error error;
+    count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, ptr_size, 0, error);
+    if (error.Fail())
+        return false;
+    uint64_t num_bytes = count / 8 + ((count & 7) ? 1 : 0);
+    addr_t data_ptr = process_sp->ReadPointerFromMemory(valobj_addr+2*ptr_size+2*ptr_size, error);
+    if (error.Fail())
+        return false;
+    // make sure we do not try to read huge amounts of data
+    if (num_bytes > 1024)
+        num_bytes = 1024;
+    DataBufferSP buffer_sp(new DataBufferHeap(num_bytes,0));
+    num_bytes = process_sp->ReadMemory(data_ptr, buffer_sp->GetBytes(), num_bytes, error);
+    if (error.Fail() || num_bytes == 0)
+        return false;
+    uint8_t *bytes = buffer_sp->GetBytes();
+    for (int byte_idx = 0; byte_idx < num_bytes-1; byte_idx++)
+    {
+        uint8_t byte = bytes[byte_idx];
+        bool bit0 = (byte & 1) == 1;
+        bool bit1 = (byte & 2) == 2;
+        bool bit2 = (byte & 4) == 4;
+        bool bit3 = (byte & 8) == 8;
+        bool bit4 = (byte & 16) == 16;
+        bool bit5 = (byte & 32) == 32;
+        bool bit6 = (byte & 64) == 64;
+        bool bit7 = (byte & 128) == 128;
+        stream.Printf("%c%c%c%c %c%c%c%c ",
+                      (bit7 ? '1' : '0'),
+                      (bit6 ? '1' : '0'),
+                      (bit5 ? '1' : '0'),
+                      (bit4 ? '1' : '0'),
+                      (bit3 ? '1' : '0'),
+                      (bit2 ? '1' : '0'),
+                      (bit1 ? '1' : '0'),
+                      (bit0 ? '1' : '0'));
+        count -= 8;
+    }
+    {
+        // print the last byte ensuring we do not print spurious bits
+        uint8_t byte = bytes[num_bytes-1];
+        bool bit0 = (byte & 1) == 1;
+        bool bit1 = (byte & 2) == 2;
+        bool bit2 = (byte & 4) == 4;
+        bool bit3 = (byte & 8) == 8;
+        bool bit4 = (byte & 16) == 16;
+        bool bit5 = (byte & 32) == 32;
+        bool bit6 = (byte & 64) == 64;
+        bool bit7 = (byte & 128) == 128;
+        if (count)
+        {
+            stream.Printf("%c",bit7 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit6 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit5 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit4 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit3 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit2 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+        {
+            stream.Printf("%c",bit1 ? '1' : '0');
+            count -= 1;
+        }
+        if (count)
+            stream.Printf("%c",bit0 ? '1' : '0');
+    }
+    return true;
+}
+
+bool
+lldb_private::formatters::CFBinaryHeapSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint32_t count = 0;
+    
+    bool is_type_ok = false; // check to see if this is a CFBinaryHeap we know about
+    if (descriptor->IsCFType())
+    {
+        ConstString type_name(valobj.GetTypeName());
+        if (type_name == ConstString("__CFBinaryHeap") || type_name == ConstString("const struct __CFBinaryHeap"))
+        {
+            if (valobj.IsPointerType())
+                is_type_ok = true;
+        }
+    }
+    
+    if (is_type_ok == false)
+    {
+        StackFrameSP frame_sp(valobj.GetFrameSP());
+        if (!frame_sp)
+            return false;
+        ValueObjectSP count_sp;
+        StreamString expr;
+        expr.Printf("(int)CFBinaryHeapGetCount((void*)0x%" PRIx64 ")",valobj.GetPointerValue());
+        if (process_sp->GetTarget().EvaluateExpression(expr.GetData(), frame_sp.get(), count_sp) != eExecutionCompleted)
+            return false;
+        if (!count_sp)
+            return false;
+        count = count_sp->GetValueAsUnsigned(0);
+    }
+    else
+    {
+        uint32_t offset = 2*ptr_size;
+        Error error;
+        count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    stream.Printf("@\"%u item%s\"",
+                  count,(count == 1 ? "" : "s"));
+    return true;
+}
diff --git a/source/DataFormatters/CXXFormatterFunctions.cpp b/source/DataFormatters/CXXFormatterFunctions.cpp
new file mode 100644
index 0000000..fba9217
--- /dev/null
+++ b/source/DataFormatters/CXXFormatterFunctions.cpp
@@ -0,0 +1,1351 @@
+//===-- CXXFormatterFunctions.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "llvm/Support/ConvertUTF.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+#include <algorithm>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+bool
+lldb_private::formatters::ExtractValueFromObjCExpression (ValueObject &valobj,
+                                                          const char* target_type,
+                                                          const char* selector,
+                                                          uint64_t &value)
+{
+    if (!target_type || !*target_type)
+        return false;
+    if (!selector || !*selector)
+        return false;
+    StreamString expr;
+    expr.Printf("(%s)[(id)0x%" PRIx64 " %s]",target_type,valobj.GetPointerValue(),selector);
+    ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+    lldb::ValueObjectSP result_sp;
+    Target* target = exe_ctx.GetTargetPtr();
+    StackFrame* stack_frame = exe_ctx.GetFramePtr();
+    if (!target || !stack_frame)
+        return false;
+    
+    EvaluateExpressionOptions options;
+    options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true);
+    
+    target->EvaluateExpression(expr.GetData(),
+                               stack_frame,
+                               result_sp,
+                               options);
+    if (!result_sp)
+        return false;
+    value = result_sp->GetValueAsUnsigned(0);
+    return true;
+}
+
+bool
+lldb_private::formatters::ExtractSummaryFromObjCExpression (ValueObject &valobj,
+                                                            const char* target_type,
+                                                            const char* selector,
+                                                            Stream &stream)
+{
+    if (!target_type || !*target_type)
+        return false;
+    if (!selector || !*selector)
+        return false;
+    StreamString expr;
+    expr.Printf("(%s)[(id)0x%" PRIx64 " %s]",target_type,valobj.GetPointerValue(),selector);
+    ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+    lldb::ValueObjectSP result_sp;
+    Target* target = exe_ctx.GetTargetPtr();
+    StackFrame* stack_frame = exe_ctx.GetFramePtr();
+    if (!target || !stack_frame)
+        return false;
+    
+    EvaluateExpressionOptions options;
+    options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+    
+    target->EvaluateExpression(expr.GetData(),
+                               stack_frame,
+                               result_sp,
+                               options);
+    if (!result_sp)
+        return false;
+    stream.Printf("%s",result_sp->GetSummaryAsCString());
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::CallSelectorOnObject (ValueObject &valobj,
+                                                const char* return_type,
+                                                const char* selector,
+                                                uint64_t index)
+{
+    lldb::ValueObjectSP valobj_sp;
+    if (!return_type || !*return_type)
+        return valobj_sp;
+    if (!selector || !*selector)
+        return valobj_sp;
+    StreamString expr_path_stream;
+    valobj.GetExpressionPath(expr_path_stream, false);
+    StreamString expr;
+    expr.Printf("(%s)[%s %s:%" PRId64 "]",return_type,expr_path_stream.GetData(),selector,index);
+    ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+    lldb::ValueObjectSP result_sp;
+    Target* target = exe_ctx.GetTargetPtr();
+    StackFrame* stack_frame = exe_ctx.GetFramePtr();
+    if (!target || !stack_frame)
+        return valobj_sp;
+    
+    EvaluateExpressionOptions options;
+    options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+    
+    target->EvaluateExpression(expr.GetData(),
+                               stack_frame,
+                               valobj_sp,
+                               options);
+    return valobj_sp;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::CallSelectorOnObject (ValueObject &valobj,
+                                                const char* return_type,
+                                                const char* selector,
+                                                const char* key)
+{
+    lldb::ValueObjectSP valobj_sp;
+    if (!return_type || !*return_type)
+        return valobj_sp;
+    if (!selector || !*selector)
+        return valobj_sp;
+    if (!key || !*key)
+        return valobj_sp;
+    StreamString expr_path_stream;
+    valobj.GetExpressionPath(expr_path_stream, false);
+    StreamString expr;
+    expr.Printf("(%s)[%s %s:%s]",return_type,expr_path_stream.GetData(),selector,key);
+    ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+    lldb::ValueObjectSP result_sp;
+    Target* target = exe_ctx.GetTargetPtr();
+    StackFrame* stack_frame = exe_ctx.GetFramePtr();
+    if (!target || !stack_frame)
+        return valobj_sp;
+    
+    EvaluateExpressionOptions options;
+    options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+    
+    target->EvaluateExpression(expr.GetData(),
+                               stack_frame,
+                               valobj_sp,
+                               options);
+    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)
+{
+    if (prefix_token != 0)
+        stream.Printf("%c",prefix_token);
+    if (quote != 0)
+        stream.Printf("%c",quote);
+    if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd())
+    {
+        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)
+        {
+            if (!*data_ptr)
+            {
+                data_end_ptr = data_ptr;
+                break;
+            }
+            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)
+    {
+        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;
+    }
+    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)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
+    options.SetLocation(valobj_addr);
+    options.SetConversionFunction(ConvertUTF16toUTF8);
+    options.SetProcessSP(process_sp);
+    options.SetStream(&stream);
+    options.SetPrefixToken('u');
+    
+    if (!ReadUTFBufferAndDumpToStream(options))
+    {
+        stream.Printf("Summary Unavailable");
+        return true;
+    }
+
+    return true;
+}
+
+bool
+lldb_private::formatters::Char32StringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    ReadUTFBufferAndDumpToStreamOptions<UTF32> options;
+    options.SetLocation(valobj_addr);
+    options.SetConversionFunction(ConvertUTF32toUTF8);
+    options.SetProcessSP(process_sp);
+    options.SetStream(&stream);
+    options.SetPrefixToken('U');
+    
+    if (!ReadUTFBufferAndDumpToStream(options))
+    {
+        stream.Printf("Summary Unavailable");
+        return true;
+    }
+    
+    return true;
+}
+
+bool
+lldb_private::formatters::WCharStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+
+    lldb::addr_t data_addr = 0;
+    
+    if (valobj.IsPointerType())
+        data_addr = valobj.GetValueAsUnsigned(0);
+    else if (valobj.IsArrayType())
+        data_addr = valobj.GetAddressOf();
+
+    if (data_addr == 0 || data_addr == LLDB_INVALID_ADDRESS)
+        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();
+
+    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);
+        }
+        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);
+        }
+        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);
+        }
+        default:
+            stream.Printf("size for wchar_t is not valid");
+            return true;
+    }
+    return true;
+}
+
+bool
+lldb_private::formatters::Char16SummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    DataExtractor data;
+    valobj.GetData(data);
+    
+    std::string value;
+    valobj.GetValueAsCString(lldb::eFormatUnicode16, value);
+    if (!value.empty())
+        stream.Printf("%s ", value.c_str());
+
+    return DumpUTFBufferToStream<UTF16>(ConvertUTF16toUTF8,data,stream, 'u','\'',1);
+}
+
+bool
+lldb_private::formatters::Char32SummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    DataExtractor data;
+    valobj.GetData(data);
+    
+    std::string value;
+    valobj.GetValueAsCString(lldb::eFormatUnicode32, value);
+    if (!value.empty())
+        stream.Printf("%s ", value.c_str());
+    
+    return DumpUTFBufferToStream<UTF32>(ConvertUTF32toUTF8,data,stream, 'U','\'',1);
+}
+
+bool
+lldb_private::formatters::WCharSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    DataExtractor data;
+    valobj.GetData(data);
+    
+    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;
+    
+    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;
+}
+
+// the field layout in a libc++ string (cap, side, data or data, size, cap)
+enum LibcxxStringLayoutMode
+{
+    eLibcxxStringLayoutModeCSD = 0,
+    eLibcxxStringLayoutModeDSC = 1,
+    eLibcxxStringLayoutModeInvalid = 0xffff
+};
+
+// this function abstracts away the layout and mode details of a libc++ string
+// and returns the address of the data and the size ready for callers to consume
+static bool
+ExtractLibcxxStringInfo (ValueObject& valobj,
+                         ValueObjectSP &location_sp,
+                         uint64_t& size)
+{
+    ValueObjectSP D(valobj.GetChildAtIndexPath({0,0,0,0}));
+    if (!D)
+        return false;
+    
+    ValueObjectSP layout_decider(D->GetChildAtIndexPath({0,0}));
+    
+    // this child should exist
+    if (!layout_decider)
+        return false;
+    
+    ConstString g_data_name("__data_");
+    ConstString g_size_name("__size_");
+    bool short_mode = false; // this means the string is in short-mode and the data is stored inline
+    LibcxxStringLayoutMode layout = (layout_decider->GetName() == g_data_name) ? eLibcxxStringLayoutModeDSC : eLibcxxStringLayoutModeCSD;
+    uint64_t size_mode_value = 0;
+    
+    if (layout == eLibcxxStringLayoutModeDSC)
+    {
+        ValueObjectSP size_mode(D->GetChildAtIndexPath({1,1,0}));
+        if (!size_mode)
+            return false;
+        
+        if (size_mode->GetName() != g_size_name)
+        {
+            // we are hitting the padding structure, move along
+            size_mode = D->GetChildAtIndexPath({1,1,1});
+            if (!size_mode)
+                return false;
+        }
+        
+        size_mode_value = (size_mode->GetValueAsUnsigned(0));
+        short_mode = ((size_mode_value & 0x80) == 0);
+    }
+    else
+    {
+        ValueObjectSP size_mode(D->GetChildAtIndexPath({1,0,0}));
+        if (!size_mode)
+            return false;
+        
+        size_mode_value = (size_mode->GetValueAsUnsigned(0));
+        short_mode = ((size_mode_value & 1) == 0);
+    }
+    
+    if (short_mode)
+    {
+        ValueObjectSP s(D->GetChildAtIndex(1, true));
+        if (!s)
+            return false;
+        location_sp = s->GetChildAtIndex((layout == eLibcxxStringLayoutModeDSC) ? 0 : 1, true);
+        size = (layout == eLibcxxStringLayoutModeDSC) ? size_mode_value : ((size_mode_value >> 1) % 256);
+        return (location_sp.get() != nullptr);
+    }
+    else
+    {
+        ValueObjectSP l(D->GetChildAtIndex(0, true));
+        if (!l)
+            return false;
+        // we can use the layout_decider object as the data pointer
+        location_sp = (layout == eLibcxxStringLayoutModeDSC) ? layout_decider : l->GetChildAtIndex(2, true);
+        ValueObjectSP size_vo(l->GetChildAtIndex(1, true));
+        if (!size_vo || !location_sp)
+            return false;
+        size = size_vo->GetValueAsUnsigned(0);
+        return true;
+    }
+}
+
+bool
+lldb_private::formatters::LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    uint64_t size = 0;
+    ValueObjectSP location_sp((ValueObject*)nullptr);
+    if (!ExtractLibcxxStringInfo(valobj, location_sp, size))
+        return false;
+    if (size == 0)
+    {
+        stream.Printf("L\"\"");
+        return true;
+    }   
+    if (!location_sp)
+        return false;
+    return WCharStringSummaryProvider(*location_sp.get(), stream);
+}
+
+bool
+lldb_private::formatters::LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    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();
+}
+
+bool
+lldb_private::formatters::ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0)));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    stream.Printf("%s",class_name);
+    return true;
+}
+
+class ObjCClassSyntheticChildrenFrontEnd : public SyntheticChildrenFrontEnd
+{
+public:
+    ObjCClassSyntheticChildrenFrontEnd (lldb::ValueObjectSP valobj_sp) :
+    SyntheticChildrenFrontEnd(*valobj_sp.get())
+    {
+    }
+    
+    virtual size_t
+    CalculateNumChildren ()
+    {
+        return 0;
+    }
+    
+    virtual lldb::ValueObjectSP
+    GetChildAtIndex (size_t idx)
+    {
+        return lldb::ValueObjectSP();
+    }
+    
+    virtual bool
+    Update()
+    {
+        return false;
+    }
+    
+    virtual bool
+    MightHaveChildren ()
+    {
+        return false;
+    }
+    
+    virtual size_t
+    GetIndexOfChildWithName (const ConstString &name)
+    {
+        return UINT32_MAX;
+    }
+    
+    virtual
+    ~ObjCClassSyntheticChildrenFrontEnd ()
+    {
+    }
+};
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp);
+}
+
+template<bool needs_at>
+bool
+lldb_private::formatters::NSDataSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    bool is_64bit = (process_sp->GetAddressByteSize() == 8);
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint64_t value = 0;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"NSConcreteData") ||
+        !strcmp(class_name,"NSConcreteMutableData") ||
+        !strcmp(class_name,"__NSCFData"))
+    {
+        uint32_t offset = (is_64bit ? 16 : 8);
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + offset, is_64bit ? 8 : 4, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    else
+    {
+        if (!ExtractValueFromObjCExpression(valobj, "int", "length", value))
+            return false;
+    }
+    
+    stream.Printf("%s%" PRIu64 " byte%s%s",
+                  (needs_at ? "@\"" : ""),
+                  value,
+                  (value != 1 ? "s" : ""),
+                  (needs_at ? "\"" : ""));
+    
+    return true;
+}
+
+static bool
+ReadAsciiBufferAndDumpToStream (lldb::addr_t location,
+                                lldb::ProcessSP& process_sp,
+                                Stream& dest,
+                                uint32_t size = 0,
+                                Error* error = NULL,
+                                size_t *data_read = NULL,
+                                char prefix_token = '@',
+                                char quote = '"')
+{
+    Error my_error;
+    size_t my_data_read;
+    if (!process_sp || location == 0)
+        return false;
+    
+    if (!size)
+        size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
+    else
+        size = std::min(size,process_sp->GetTarget().GetMaximumSizeOfStringSummary());
+    
+    lldb::DataBufferSP buffer_sp(new DataBufferHeap(size,0));
+    
+    my_data_read = process_sp->ReadCStringFromMemory(location, (char*)buffer_sp->GetBytes(), size, my_error);
+
+    if (error)
+        *error = my_error;
+    if (data_read)
+        *data_read = my_data_read;
+    
+    if (my_error.Fail())
+        return false;
+    
+    dest.Printf("%c%c",prefix_token,quote);
+    
+    if (my_data_read)
+        dest.Printf("%s",(char*)buffer_sp->GetBytes());
+    
+    dest.Printf("%c",quote);
+    
+    return true;
+}
+
+bool
+lldb_private::formatters::NSStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    uint64_t info_bits_location = valobj_addr + ptr_size;
+    if (process_sp->GetByteOrder() != lldb::eByteOrderLittle)
+        info_bits_location += 3;
+        
+    Error error;
+    
+    uint8_t info_bits = process_sp->ReadUnsignedIntegerFromMemory(info_bits_location, 1, 0, error);
+    if (error.Fail())
+        return false;
+    
+    bool is_mutable = (info_bits & 1) == 1;
+    bool is_inline = (info_bits & 0x60) == 0;
+    bool has_explicit_length = (info_bits & (1 | 4)) != 4;
+    bool is_unicode = (info_bits & 0x10) == 0x10;
+    bool is_special = strcmp(class_name,"NSPathStore2") == 0;
+    bool has_null = (info_bits & 8) == 8;
+    
+    size_t explicit_length = 0;
+    if (!has_null && has_explicit_length && !is_special)
+    {
+        lldb::addr_t explicit_length_offset = 2*ptr_size;
+        if (is_mutable and not is_inline)
+            explicit_length_offset = explicit_length_offset + ptr_size; //  notInlineMutable.length;
+        else if (is_inline)
+            explicit_length = explicit_length + 0; // inline1.length;
+        else if (not is_inline and not is_mutable)
+            explicit_length_offset = explicit_length_offset + ptr_size; // notInlineImmutable1.length;
+        else
+            explicit_length_offset = 0;
+
+        if (explicit_length_offset)
+        {
+            explicit_length_offset = valobj_addr + explicit_length_offset;
+            explicit_length = process_sp->ReadUnsignedIntegerFromMemory(explicit_length_offset, 4, 0, error);
+        }
+    }
+    
+    if (strcmp(class_name,"NSString") &&
+        strcmp(class_name,"CFStringRef") &&
+        strcmp(class_name,"CFMutableStringRef") &&
+        strcmp(class_name,"__NSCFConstantString") &&
+        strcmp(class_name,"__NSCFString") &&
+        strcmp(class_name,"NSCFConstantString") &&
+        strcmp(class_name,"NSCFString") &&
+        strcmp(class_name,"NSPathStore2"))
+    {
+        // not one of us - but tell me class name
+        stream.Printf("class name = %s",class_name);
+        return true;
+    }
+    
+    if (is_mutable)
+    {
+        uint64_t location = 2 * ptr_size + valobj_addr;
+        location = process_sp->ReadPointerFromMemory(location, error);
+        if (error.Fail())
+            return false;
+        if (has_explicit_length and is_unicode)
+        {
+            ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
+            options.SetConversionFunction(ConvertUTF16toUTF8);
+            options.SetLocation(location);
+            options.SetProcessSP(process_sp);
+            options.SetStream(&stream);
+            options.SetPrefixToken('@');
+            options.SetQuote('"');
+            options.SetSourceSize(explicit_length);
+            options.SetNeedsZeroTermination(false);
+            return ReadUTFBufferAndDumpToStream (options);
+        }
+        else
+            return ReadAsciiBufferAndDumpToStream(location+1,process_sp,stream, explicit_length);
+    }
+    else if (is_inline && has_explicit_length && !is_unicode && !is_special && !is_mutable)
+    {
+        uint64_t location = 3 * ptr_size + valobj_addr;
+        return ReadAsciiBufferAndDumpToStream(location,process_sp,stream,explicit_length);
+    }
+    else if (is_unicode)
+    {
+        uint64_t location = valobj_addr + 2*ptr_size;
+        if (is_inline)
+        {
+            if (!has_explicit_length)
+            {
+                stream.Printf("found new combo");
+                return true;
+            }
+            else
+                location += ptr_size;
+        }
+        else
+        {
+            location = process_sp->ReadPointerFromMemory(location, error);
+            if (error.Fail())
+                return false;
+        }
+        ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
+        options.SetConversionFunction(ConvertUTF16toUTF8);
+        options.SetLocation(location);
+        options.SetProcessSP(process_sp);
+        options.SetStream(&stream);
+        options.SetPrefixToken('@');
+        options.SetQuote('"');
+        options.SetSourceSize(explicit_length);
+        options.SetNeedsZeroTermination(has_explicit_length == false);
+        return ReadUTFBufferAndDumpToStream (options);
+    }
+    else if (is_special)
+    {
+        uint64_t location = valobj_addr + (ptr_size == 8 ? 12 : 8);
+        ReadUTFBufferAndDumpToStreamOptions<UTF16> options;
+        options.SetConversionFunction(ConvertUTF16toUTF8);
+        options.SetLocation(location);
+        options.SetProcessSP(process_sp);
+        options.SetStream(&stream);
+        options.SetPrefixToken('@');
+        options.SetQuote('"');
+        options.SetSourceSize(explicit_length);
+        options.SetNeedsZeroTermination(has_explicit_length == false);
+        return ReadUTFBufferAndDumpToStream (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);
+    }
+    else
+    {
+        uint64_t location = valobj_addr + 2*ptr_size;
+        location = process_sp->ReadPointerFromMemory(location, error);
+        if (error.Fail())
+            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);
+    }
+    
+    stream.Printf("class name = %s",class_name);
+    return true;
+    
+}
+
+bool
+lldb_private::formatters::NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    TargetSP target_sp(valobj.GetTargetSP());
+    if (!target_sp)
+        return false;
+    uint32_t addr_size = target_sp->GetArchitecture().GetAddressByteSize();
+    uint64_t pointer_value = valobj.GetValueAsUnsigned(0);
+    if (!pointer_value)
+        return false;
+    pointer_value += addr_size;
+    ClangASTType type(valobj.GetClangType());
+    ExecutionContext exe_ctx(target_sp,false);
+    ValueObjectSP child_ptr_sp(valobj.CreateValueObjectFromAddress("string_ptr", pointer_value, exe_ctx, type));
+    if (!child_ptr_sp)
+        return false;
+    DataExtractor data;
+    child_ptr_sp->GetData(data);
+    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 false;
+}
+
+bool
+lldb_private::formatters::NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    return NSAttributedStringSummaryProvider(valobj, stream);
+}
+
+bool
+lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    stream.Printf("%s",valobj.GetObjectDescription());
+    return true;
+}
+
+bool
+lldb_private::formatters::ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    const uint32_t type_info = valobj.GetClangType().GetTypeInfo();
+    
+    ValueObjectSP real_guy_sp = valobj.GetSP();
+    
+    if (type_info & ClangASTType::eTypeIsPointer)
+    {
+        Error err;
+        real_guy_sp = valobj.Dereference(err);
+        if (err.Fail() || !real_guy_sp)
+            return false;
+    }
+    else if (type_info & ClangASTType::eTypeIsReference)
+    {
+        real_guy_sp =  valobj.GetChildAtIndex(0, true);
+        if (!real_guy_sp)
+            return false;
+    }
+    uint64_t value = real_guy_sp->GetValueAsUnsigned(0);
+    if (value == 0)
+    {
+        stream.Printf("NO");
+        return true;
+    }
+    stream.Printf("YES");
+    return true;
+}
+
+template <bool is_sel_ptr>
+bool
+lldb_private::formatters::ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    lldb::ValueObjectSP valobj_sp;
+
+    ClangASTType charstar (valobj.GetClangType().GetBasicTypeFromAST(eBasicTypeChar).GetPointerType());
+    
+    if (!charstar)
+        return false;
+
+    ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
+    
+    if (is_sel_ptr)
+    {
+        lldb::addr_t data_address = valobj.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+        if (data_address == LLDB_INVALID_ADDRESS)
+            return false;
+        valobj_sp = ValueObject::CreateValueObjectFromAddress("text", data_address, exe_ctx, charstar);
+    }
+    else
+    {
+        DataExtractor data;
+        valobj.GetData(data);
+        valobj_sp = ValueObject::CreateValueObjectFromData("text", data, exe_ctx, charstar);
+    }
+    
+    if (!valobj_sp)
+        return false;
+    
+    stream.Printf("%s",valobj_sp->GetSummaryAsCString());
+    return true;
+}
+
+// POSIX has an epoch on Jan-1-1970, but Cocoa prefers Jan-1-2001
+// this call gives the POSIX equivalent of the Cocoa epoch
+time_t
+lldb_private::formatters::GetOSXEpoch ()
+{
+    static time_t epoch = 0;
+    if (!epoch)
+    {
+        tzset();
+        tm tm_epoch;
+        tm_epoch.tm_sec = 0;
+        tm_epoch.tm_hour = 0;
+        tm_epoch.tm_min = 0;
+        tm_epoch.tm_mon = 0;
+        tm_epoch.tm_mday = 1;
+        tm_epoch.tm_year = 2001-1900; // for some reason, we need to subtract 1900 from this field. not sure why.
+        tm_epoch.tm_isdst = -1;
+        tm_epoch.tm_gmtoff = 0;
+        tm_epoch.tm_zone = NULL;
+        epoch = timegm(&tm_epoch);
+    }
+    return epoch;
+}
+
+size_t
+lldb_private::formatters::ExtractIndexFromString (const char* item_name)
+{
+    if (!item_name || !*item_name)
+        return UINT32_MAX;
+    if (*item_name != '[')
+        return UINT32_MAX;
+    item_name++;
+    char* endptr = NULL;
+    unsigned long int idx = ::strtoul(item_name, &endptr, 0);
+    if (idx == 0 && endptr == item_name)
+        return UINT32_MAX;
+    if (idx == ULONG_MAX)
+        return UINT32_MAX;
+    return idx;
+}
+
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
+                                                                                            ConstString item_name) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_item_name(item_name),
+m_item_sp()
+{
+    if (valobj_sp)
+        Update();
+}
+
+bool
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::Update()
+{
+    m_item_sp.reset();
+
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    
+    if (!valobj_sp)
+        return false;
+    
+    ValueObjectSP item_ptr(valobj_sp->GetChildMemberWithName(m_item_name,true));
+    if (!item_ptr)
+        return false;
+    if (item_ptr->GetValueAsUnsigned(0) == 0)
+        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());
+    if (err.Fail())
+        m_item_sp.reset();
+    return false;
+}
+
+size_t
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return 1;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx == 0)
+        return m_item_sp;
+    return lldb::ValueObjectSP();
+}
+
+bool
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (name == ConstString("item"))
+        return 0;
+    return UINT32_MAX;
+}
+
+lldb_private::formatters::VectorIteratorSyntheticFrontEnd::~VectorIteratorSyntheticFrontEnd ()
+{
+}
+
+template bool
+lldb_private::formatters::NSDataSummaryProvider<true> (ValueObject&, Stream&) ;
+
+template bool
+lldb_private::formatters::NSDataSummaryProvider<false> (ValueObject&, Stream&) ;
+
+template bool
+lldb_private::formatters::ObjCSELSummaryProvider<true> (ValueObject&, Stream&) ;
+
+template bool
+lldb_private::formatters::ObjCSELSummaryProvider<false> (ValueObject&, Stream&) ;
diff --git a/source/DataFormatters/Cocoa.cpp b/source/DataFormatters/Cocoa.cpp
new file mode 100644
index 0000000..555954d
--- /dev/null
+++ b/source/DataFormatters/Cocoa.cpp
@@ -0,0 +1,565 @@
+//===-- Cocoa.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+bool
+lldb_private::formatters::NSBundleSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"NSBundle"))
+    {
+        uint64_t offset = 5 * ptr_size;
+        ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetClangType().GetBasicTypeFromAST(lldb::eBasicTypeObjCID), true));
+
+        StreamString summary_stream;
+        bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream);
+        if (was_nsstring_ok && summary_stream.GetSize() > 0)
+        {
+            stream.Printf("%s",summary_stream.GetData());
+            return true;
+        }
+    }
+    // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle]
+    // which is encoded differently and needs to be handled by running code
+    return ExtractSummaryFromObjCExpression(valobj, "NSString*", "bundlePath", stream);
+}
+
+bool
+lldb_private::formatters::NSTimeZoneSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"__NSTimeZone"))
+    {
+        uint64_t offset = ptr_size;
+        ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetClangType(), true));
+        StreamString summary_stream;
+        bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream);
+        if (was_nsstring_ok && summary_stream.GetSize() > 0)
+        {
+            stream.Printf("%s",summary_stream.GetData());
+            return true;
+        }
+    }
+    return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream);
+}
+
+bool
+lldb_private::formatters::NSNotificationSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"NSConcreteNotification"))
+    {
+        uint64_t offset = ptr_size;
+        ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset, valobj.GetClangType(), true));
+        StreamString summary_stream;
+        bool was_nsstring_ok = NSStringSummaryProvider(*text.get(), summary_stream);
+        if (was_nsstring_ok && summary_stream.GetSize() > 0)
+        {
+            stream.Printf("%s",summary_stream.GetData());
+            return true;
+        }
+    }
+    // this is either an unknown subclass or an NSBundle that comes from [NSBundle mainBundle]
+    // which is encoded differently and needs to be handled by running code
+    return ExtractSummaryFromObjCExpression(valobj, "NSString*", "name", stream);
+}
+
+bool
+lldb_private::formatters::NSMachPortSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    uint64_t port_number = 0;
+    
+    do
+    {
+        if (!strcmp(class_name,"NSMachPort"))
+        {
+            uint64_t offset = (ptr_size == 4 ? 12 : 20);
+            Error error;
+            port_number = process_sp->ReadUnsignedIntegerFromMemory(offset+valobj_addr, 4, 0, error);
+            if (error.Success())
+                break;
+        }
+        if (!ExtractValueFromObjCExpression(valobj, "int", "machPort", port_number))
+            return false;
+    } while (false);
+    
+    stream.Printf("mach port: %u",(uint32_t)(port_number & 0x00000000FFFFFFFF));
+    return true;
+}
+
+bool
+lldb_private::formatters::NSIndexSetSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    uint64_t count = 0;
+    
+    do {
+        if (!strcmp(class_name,"NSIndexSet") || !strcmp(class_name,"NSMutableIndexSet"))
+        {
+            Error error;
+            uint32_t mode = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+ptr_size, 4, 0, error);
+            if (error.Fail())
+                return false;
+            // this means the set is empty - count = 0
+            if ((mode & 1) == 1)
+            {
+                count = 0;
+                break;
+            }
+            if ((mode & 2) == 2)
+                mode = 1; // this means the set only has one range
+            else
+                mode = 2; // this means the set has multiple ranges
+            if (mode == 1)
+            {
+                count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+3*ptr_size, ptr_size, 0, error);
+                if (error.Fail())
+                    return false;
+            }
+            else
+            {
+                // read a pointer to the data at 2*ptr_size
+                count = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, ptr_size, 0, error);
+                if (error.Fail())
+                    return false;
+                // read the data at 2*ptr_size from the first location
+                count = process_sp->ReadUnsignedIntegerFromMemory(count+2*ptr_size, ptr_size, 0, error);
+                if (error.Fail())
+                    return false;
+            }
+        }
+        else
+        {
+            if (!ExtractValueFromObjCExpression(valobj, "unsigned long long int", "count", count))
+                return false;
+        }
+    }  while (false);
+    stream.Printf("%" PRIu64 " index%s",
+                  count,
+                  (count == 1 ? "" : "es"));
+    return true;
+}
+
+bool
+lldb_private::formatters::NSNumberSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"NSNumber") || !strcmp(class_name,"__NSCFNumber"))
+    {
+        uint64_t value = 0;
+        uint64_t i_bits = 0;
+        if (descriptor->GetTaggedPointerInfo(&i_bits,&value))
+        {
+            switch (i_bits)
+            {
+                case 0:
+                    stream.Printf("(char)%hhd",(char)value);
+                    break;
+                case 1:
+                case 4:
+                    stream.Printf("(short)%hd",(short)value);
+                    break;
+                case 2:
+                case 8:
+                    stream.Printf("(int)%d",(int)value);
+                    break;
+                case 3:
+                case 12:
+                    stream.Printf("(long)%" PRId64,value);
+                    break;
+                default:
+                    stream.Printf("unexpected value:(info=%" PRIu64 ", value=%" PRIu64,i_bits,value);
+                    break;
+            }
+            return true;
+        }
+        else
+        {
+            Error error;
+            uint8_t data_type = (process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, 1, 0, error) & 0x1F);
+            uint64_t data_location = valobj_addr + 2*ptr_size;
+            uint64_t value = 0;
+            if (error.Fail())
+                return false;
+            switch (data_type)
+            {
+                case 1: // 0B00001
+                    value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 1, 0, error);
+                    if (error.Fail())
+                        return false;
+                    stream.Printf("(char)%hhd",(char)value);
+                    break;
+                case 2: // 0B0010
+                    value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 2, 0, error);
+                    if (error.Fail())
+                        return false;
+                    stream.Printf("(short)%hd",(short)value);
+                    break;
+                case 3: // 0B0011
+                    value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, error);
+                    if (error.Fail())
+                        return false;
+                    stream.Printf("(int)%d",(int)value);
+                    break;
+                case 17: // 0B10001
+                    data_location += 8;
+                case 4: // 0B0100
+                    value = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error);
+                    if (error.Fail())
+                        return false;
+                    stream.Printf("(long)%" PRId64,value);
+                    break;
+                case 5: // 0B0101
+                {
+                    uint32_t flt_as_int = process_sp->ReadUnsignedIntegerFromMemory(data_location, 4, 0, error);
+                    if (error.Fail())
+                        return false;
+                    float flt_value = *((float*)&flt_as_int);
+                    stream.Printf("(float)%f",flt_value);
+                    break;
+                }
+                case 6: // 0B0110
+                {
+                    uint64_t dbl_as_lng = process_sp->ReadUnsignedIntegerFromMemory(data_location, 8, 0, error);
+                    if (error.Fail())
+                        return false;
+                    double dbl_value = *((double*)&dbl_as_lng);
+                    stream.Printf("(double)%g",dbl_value);
+                    break;
+                }
+                default:
+                    stream.Printf("unexpected value: dt=%d",data_type);
+                    break;
+            }
+            return true;
+        }
+    }
+    else
+    {
+        return ExtractSummaryFromObjCExpression(valobj, "NSString*", "stringValue", stream);
+    }
+}
+
+bool
+lldb_private::formatters::NSURLSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (strcmp(class_name, "NSURL") == 0)
+    {
+        uint64_t offset_text = ptr_size + ptr_size + 8; // ISA + pointer + 8 bytes of data (even on 32bit)
+        uint64_t offset_base = offset_text + ptr_size;
+        ClangASTType type(valobj.GetClangType());
+        ValueObjectSP text(valobj.GetSyntheticChildAtOffset(offset_text, type, true));
+        ValueObjectSP base(valobj.GetSyntheticChildAtOffset(offset_base, type, true));
+        if (!text)
+            return false;
+        if (text->GetValueAsUnsigned(0) == 0)
+            return false;
+        StreamString summary;
+        if (!NSStringSummaryProvider(*text, summary))
+            return false;
+        if (base && base->GetValueAsUnsigned(0))
+        {
+            if (summary.GetSize() > 0)
+                summary.GetString().resize(summary.GetSize()-1);
+            summary.Printf(" -- ");
+            StreamString base_summary;
+            if (NSURLSummaryProvider(*base, base_summary) && base_summary.GetSize() > 0)
+                summary.Printf("%s",base_summary.GetSize() > 2 ? base_summary.GetData() + 2 : base_summary.GetData());
+        }
+        if (summary.GetSize())
+        {
+            stream.Printf("%s",summary.GetData());
+            return true;
+        }
+    }
+    else
+    {
+        return ExtractSummaryFromObjCExpression(valobj, "NSString*", "description", stream);
+    }
+    return false;
+}
+
+bool
+lldb_private::formatters::NSDateSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint64_t date_value_bits = 0;
+    double date_value = 0.0;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (strcmp(class_name,"NSDate") == 0 ||
+        strcmp(class_name,"__NSDate") == 0 ||
+        strcmp(class_name,"__NSTaggedDate") == 0)
+    {
+        uint64_t info_bits=0,value_bits = 0;
+        if (descriptor->GetTaggedPointerInfo(&info_bits,&value_bits))
+        {
+            date_value_bits = ((value_bits << 8) | (info_bits << 4));
+            date_value = *((double*)&date_value_bits);
+        }
+        else
+        {
+            Error error;
+            date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+ptr_size, 8, 0, error);
+            date_value = *((double*)&date_value_bits);
+            if (error.Fail())
+                return false;
+        }
+    }
+    else if (!strcmp(class_name,"NSCalendarDate"))
+    {
+        Error error;
+        date_value_bits = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr+2*ptr_size, 8, 0, error);
+        date_value = *((double*)&date_value_bits);
+        if (error.Fail())
+            return false;
+    }
+    else
+    {
+        if (ExtractValueFromObjCExpression(valobj, "NSTimeInterval", "ExtractValueFromObjCExpression", date_value_bits) == false)
+            return false;
+        date_value = *((double*)&date_value_bits);
+    }
+    if (date_value == -63114076800)
+    {
+        stream.Printf("0001-12-30 00:00:00 +0000");
+        return true;
+    }
+    // this snippet of code assumes that time_t == seconds since Jan-1-1970
+    // this is generally true and POSIXly happy, but might break if a library
+    // vendor decides to get creative
+    time_t epoch = GetOSXEpoch();
+    epoch = epoch + (time_t)date_value;
+    tm *tm_date = localtime(&epoch);
+    if (!tm_date)
+        return false;
+    std::string buffer(1024,0);
+    if (strftime (&buffer[0], 1023, "%Z", tm_date) == 0)
+        return false;
+    stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year+1900, tm_date->tm_mon+1, tm_date->tm_mday, tm_date->tm_hour, tm_date->tm_min, tm_date->tm_sec, buffer.c_str());
+    return true;
+}
diff --git a/source/DataFormatters/DataVisualization.cpp b/source/DataFormatters/DataVisualization.cpp
new file mode 100644
index 0000000..c1ef359
--- /dev/null
+++ b/source/DataFormatters/DataVisualization.cpp
@@ -0,0 +1,279 @@
+//===-- DataVisualization.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/lldb-python.h"
+
+#include "lldb/DataFormatters/DataVisualization.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+#include "lldb/Core/Debugger.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static FormatManager&
+GetFormatManager()
+{
+    static FormatManager g_format_manager;
+    return g_format_manager;
+}
+
+void
+DataVisualization::ForceUpdate ()
+{
+    GetFormatManager().Changed();
+}
+
+uint32_t
+DataVisualization::GetCurrentRevision ()
+{
+    return GetFormatManager().GetCurrentRevision();
+}
+
+lldb::TypeFormatImplSP
+DataVisualization::ValueFormats::GetFormat (ValueObject& valobj, lldb::DynamicValueType use_dynamic)
+{
+    lldb::TypeFormatImplSP entry;
+    GetFormatManager().GetValueNavigator().Get(valobj, entry, use_dynamic);
+    return entry;
+}
+
+lldb::TypeFormatImplSP
+DataVisualization::ValueFormats::GetFormat (const ConstString &type)
+{
+    lldb::TypeFormatImplSP entry;
+    GetFormatManager().GetValueNavigator().Get(type, entry);
+    return entry;
+}
+
+void
+DataVisualization::ValueFormats::Add (const ConstString &type, const lldb::TypeFormatImplSP &entry)
+{
+    GetFormatManager().GetValueNavigator().Add(FormatManager::GetValidTypeName(type),entry);
+}
+
+bool
+DataVisualization::ValueFormats::Delete (const ConstString &type)
+{
+    return GetFormatManager().GetValueNavigator().Delete(type);
+}
+
+void
+DataVisualization::ValueFormats::Clear ()
+{
+    GetFormatManager().GetValueNavigator().Clear();
+}
+
+void
+DataVisualization::ValueFormats::LoopThrough (TypeFormatImpl::ValueCallback callback, void* callback_baton)
+{
+    GetFormatManager().GetValueNavigator().LoopThrough(callback, callback_baton);
+}
+
+size_t
+DataVisualization::ValueFormats::GetCount ()
+{
+    return GetFormatManager().GetValueNavigator().GetCount();
+}
+
+lldb::TypeNameSpecifierImplSP
+DataVisualization::ValueFormats::GetTypeNameSpecifierForFormatAtIndex (size_t index)
+{
+    return GetFormatManager().GetValueNavigator().GetTypeNameSpecifierAtIndex(index);
+}
+
+lldb::TypeFormatImplSP
+DataVisualization::ValueFormats::GetFormatAtIndex (size_t index)
+{
+    return GetFormatManager().GetValueNavigator().GetAtIndex(index);
+}
+
+lldb::TypeSummaryImplSP
+DataVisualization::GetSummaryFormat (ValueObject& valobj,
+                                     lldb::DynamicValueType use_dynamic)
+{
+    return GetFormatManager().GetSummaryFormat(valobj, use_dynamic);
+}
+
+lldb::TypeSummaryImplSP
+DataVisualization::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    return GetFormatManager().GetSummaryForType(type_sp);
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+DataVisualization::GetSyntheticChildren (ValueObject& valobj,
+                                         lldb::DynamicValueType use_dynamic)
+{
+    return GetFormatManager().GetSyntheticChildren(valobj, use_dynamic);
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+DataVisualization::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    return GetFormatManager().GetSyntheticChildrenForType(type_sp);
+}
+#endif
+
+lldb::TypeFilterImplSP
+DataVisualization::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    return GetFormatManager().GetFilterForType(type_sp);
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::ScriptedSyntheticChildrenSP
+DataVisualization::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    return GetFormatManager().GetSyntheticForType(type_sp);
+}
+#endif
+
+bool
+DataVisualization::AnyMatches (ConstString type_name,
+                               TypeCategoryImpl::FormatCategoryItems items,
+                               bool only_enabled,
+                               const char** matching_category,
+                               TypeCategoryImpl::FormatCategoryItems* matching_type)
+{
+    return GetFormatManager().AnyMatches(type_name,
+                                         items,
+                                         only_enabled,
+                                         matching_category,
+                                         matching_type);
+}
+
+bool
+DataVisualization::Categories::GetCategory (const ConstString &category, lldb::TypeCategoryImplSP &entry,
+                                            bool allow_create)
+{
+    entry = GetFormatManager().GetCategory(category, allow_create);
+    return (entry.get() != NULL);
+}
+
+void
+DataVisualization::Categories::Add (const ConstString &category)
+{
+    GetFormatManager().GetCategory(category);
+}
+
+bool
+DataVisualization::Categories::Delete (const ConstString &category)
+{
+    GetFormatManager().DisableCategory(category);
+    return GetFormatManager().DeleteCategory(category);
+}
+
+void
+DataVisualization::Categories::Clear ()
+{
+    GetFormatManager().ClearCategories();
+}
+
+void
+DataVisualization::Categories::Clear (const ConstString &category)
+{
+    GetFormatManager().GetCategory(category)->Clear(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
+}
+
+void
+DataVisualization::Categories::Enable (const ConstString& category,
+                                       TypeCategoryMap::Position pos)
+{
+    if (GetFormatManager().GetCategory(category)->IsEnabled())
+        GetFormatManager().DisableCategory(category);
+    GetFormatManager().EnableCategory(category, pos);
+}
+
+void
+DataVisualization::Categories::Disable (const ConstString& category)
+{
+    if (GetFormatManager().GetCategory(category)->IsEnabled() == true)
+        GetFormatManager().DisableCategory(category);
+}
+
+void
+DataVisualization::Categories::Enable (const lldb::TypeCategoryImplSP& category,
+                                       TypeCategoryMap::Position pos)
+{
+    if (category.get())
+    {
+        if (category->IsEnabled())
+            GetFormatManager().DisableCategory(category);
+        GetFormatManager().EnableCategory(category, pos);
+    }
+}
+
+void
+DataVisualization::Categories::Disable (const lldb::TypeCategoryImplSP& category)
+{
+    if (category.get() && category->IsEnabled() == true)
+        GetFormatManager().DisableCategory(category);
+}
+
+void
+DataVisualization::Categories::LoopThrough (FormatManager::CategoryCallback callback, void* callback_baton)
+{
+    GetFormatManager().LoopThroughCategories(callback, callback_baton);
+}
+
+uint32_t
+DataVisualization::Categories::GetCount ()
+{
+    return GetFormatManager().GetCategoriesCount();
+}
+
+lldb::TypeCategoryImplSP
+DataVisualization::Categories::GetCategoryAtIndex (size_t index)
+{
+    return GetFormatManager().GetCategoryAtIndex(index);
+}
+
+bool
+DataVisualization::NamedSummaryFormats::GetSummaryFormat (const ConstString &type, lldb::TypeSummaryImplSP &entry)
+{
+    return GetFormatManager().GetNamedSummaryNavigator().Get(type,entry);
+}
+
+void
+DataVisualization::NamedSummaryFormats::Add (const ConstString &type, const lldb::TypeSummaryImplSP &entry)
+{
+    GetFormatManager().GetNamedSummaryNavigator().Add(FormatManager::GetValidTypeName(type),entry);
+}
+
+bool
+DataVisualization::NamedSummaryFormats::Delete (const ConstString &type)
+{
+    return GetFormatManager().GetNamedSummaryNavigator().Delete(type);
+}
+
+void
+DataVisualization::NamedSummaryFormats::Clear ()
+{
+    GetFormatManager().GetNamedSummaryNavigator().Clear();
+}
+
+void
+DataVisualization::NamedSummaryFormats::LoopThrough (TypeSummaryImpl::SummaryCallback callback, void* callback_baton)
+{
+    GetFormatManager().GetNamedSummaryNavigator().LoopThrough(callback, callback_baton);
+}
+
+uint32_t
+DataVisualization::NamedSummaryFormats::GetCount ()
+{
+    return GetFormatManager().GetNamedSummaryNavigator().GetCount();
+}
diff --git a/source/DataFormatters/FormatCache.cpp b/source/DataFormatters/FormatCache.cpp
new file mode 100644
index 0000000..af7b1c3
--- /dev/null
+++ b/source/DataFormatters/FormatCache.cpp
@@ -0,0 +1,169 @@
+//===-- FormatCache.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/lldb-python.h"
+
+// C Includes
+
+// C++ Includes
+
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/DataFormatters/FormatCache.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+FormatCache::Entry::Entry () :
+m_summary_cached(false),
+m_synthetic_cached(false),
+m_summary_sp(),
+m_synthetic_sp()
+{}
+
+FormatCache::Entry::Entry (lldb::TypeSummaryImplSP summary_sp) :
+m_synthetic_cached(false),
+m_synthetic_sp()
+{
+    SetSummary (summary_sp);
+}
+
+FormatCache::Entry::Entry (lldb::SyntheticChildrenSP synthetic_sp) :
+m_summary_cached(false),
+m_summary_sp()
+{
+    SetSynthetic (synthetic_sp);
+}
+
+FormatCache::Entry::Entry (lldb::TypeSummaryImplSP summary_sp,lldb::SyntheticChildrenSP synthetic_sp)
+{
+    SetSummary (summary_sp);
+    SetSynthetic (synthetic_sp);
+}
+
+bool
+FormatCache::Entry::IsSummaryCached ()
+{
+    return m_summary_cached;
+}
+
+bool
+FormatCache::Entry::IsSyntheticCached ()
+{
+    return m_synthetic_cached;
+}
+
+lldb::TypeSummaryImplSP
+FormatCache::Entry::GetSummary ()
+{
+    return m_summary_sp;
+}
+
+lldb::SyntheticChildrenSP
+FormatCache::Entry::GetSynthetic ()
+{
+    return m_synthetic_sp;
+}
+
+void
+FormatCache::Entry::SetSummary (lldb::TypeSummaryImplSP summary_sp)
+{
+    m_summary_cached = true;
+    m_summary_sp = summary_sp;
+}
+
+void
+FormatCache::Entry::SetSynthetic (lldb::SyntheticChildrenSP synthetic_sp)
+{
+    m_synthetic_cached = true;
+    m_synthetic_sp = synthetic_sp;
+}
+
+FormatCache::FormatCache () :
+m_map(),
+m_mutex (Mutex::eMutexTypeRecursive)
+#ifdef LLDB_CONFIGURATION_DEBUG
+,m_cache_hits(0),m_cache_misses(0)
+#endif
+{
+}
+
+FormatCache::Entry&
+FormatCache::GetEntry (const ConstString& type)
+{
+    auto i = m_map.find(type),
+    e = m_map.end();
+    if (i != e)
+        return i->second;
+    m_map[type] = FormatCache::Entry();
+    return m_map[type];
+}
+
+bool
+FormatCache::GetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
+{
+    Mutex::Locker lock(m_mutex);
+    auto entry = GetEntry(type);
+    if (entry.IsSummaryCached())
+    {
+#ifdef LLDB_CONFIGURATION_DEBUG
+        m_cache_hits++;
+#endif
+        summary_sp = entry.GetSummary();
+        return true;
+    }
+#ifdef LLDB_CONFIGURATION_DEBUG
+    m_cache_misses++;
+#endif
+    summary_sp.reset();
+    return false;
+}
+
+bool
+FormatCache::GetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
+{
+    Mutex::Locker lock(m_mutex);
+    auto entry = GetEntry(type);
+    if (entry.IsSyntheticCached())
+    {
+#ifdef LLDB_CONFIGURATION_DEBUG
+        m_cache_hits++;
+#endif
+        synthetic_sp = entry.GetSynthetic();
+        return true;
+    }
+#ifdef LLDB_CONFIGURATION_DEBUG
+    m_cache_misses++;
+#endif
+    synthetic_sp.reset();
+    return false;
+}
+
+void
+FormatCache::SetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
+{
+    Mutex::Locker lock(m_mutex);
+    GetEntry(type).SetSummary(summary_sp);
+}
+
+void
+FormatCache::SetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
+{
+    Mutex::Locker lock(m_mutex);
+    GetEntry(type).SetSynthetic(synthetic_sp);
+}
+
+void
+FormatCache::Clear ()
+{
+    Mutex::Locker lock(m_mutex);
+    m_map.clear();
+}
+
diff --git a/source/DataFormatters/FormatClasses.cpp b/source/DataFormatters/FormatClasses.cpp
new file mode 100644
index 0000000..c67f86a
--- /dev/null
+++ b/source/DataFormatters/FormatClasses.cpp
@@ -0,0 +1,33 @@
+//===-- FormatClasses.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/lldb-python.h"
+
+// C Includes
+
+// C++ Includes
+
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/lldb-public.h"
+#include "lldb/lldb-enumerations.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/Timer.h"
+#include "lldb/DataFormatters/FormatClasses.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
diff --git a/source/DataFormatters/FormatManager.cpp b/source/DataFormatters/FormatManager.cpp
new file mode 100644
index 0000000..eeae8bc
--- /dev/null
+++ b/source/DataFormatters/FormatManager.cpp
@@ -0,0 +1,1083 @@
+//===-- FormatManager.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/lldb-python.h"
+
+#include "lldb/DataFormatters/FormatManager.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+#include "lldb/Interpreter/ScriptInterpreterPython.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Platform.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+struct FormatInfo
+{
+    Format format;
+    const char format_char; // One or more format characters that can be used for this format.
+    const char *format_name;    // Long format name that can be used to specify the current format
+};
+
+static FormatInfo 
+g_format_infos[] = 
+{
+    { eFormatDefault        , '\0'  , "default"             },
+    { eFormatBoolean        , 'B'   , "boolean"             },
+    { eFormatBinary         , 'b'   , "binary"              },
+    { eFormatBytes          , 'y'   , "bytes"               },
+    { eFormatBytesWithASCII , 'Y'   , "bytes with ASCII"    },
+    { eFormatChar           , 'c'   , "character"           },
+    { eFormatCharPrintable  , 'C'   , "printable character" },
+    { eFormatComplexFloat   , 'F'   , "complex float"       },
+    { eFormatCString        , 's'   , "c-string"            },
+    { eFormatDecimal        , 'd'   , "decimal"             },
+    { eFormatEnum           , 'E'   , "enumeration"         },
+    { eFormatHex            , 'x'   , "hex"                 },
+    { eFormatHexUppercase   , 'X'   , "uppercase hex"       },
+    { eFormatFloat          , 'f'   , "float"               },
+    { eFormatOctal          , 'o'   , "octal"               },
+    { eFormatOSType         , 'O'   , "OSType"              },
+    { eFormatUnicode16      , 'U'   , "unicode16"           },
+    { eFormatUnicode32      , '\0'  , "unicode32"           },
+    { eFormatUnsigned       , 'u'   , "unsigned decimal"    },
+    { eFormatPointer        , 'p'   , "pointer"             },
+    { eFormatVectorOfChar   , '\0'  , "char[]"              },
+    { eFormatVectorOfSInt8  , '\0'  , "int8_t[]"            },
+    { eFormatVectorOfUInt8  , '\0'  , "uint8_t[]"           },
+    { eFormatVectorOfSInt16 , '\0'  , "int16_t[]"           },
+    { eFormatVectorOfUInt16 , '\0'  , "uint16_t[]"          },
+    { eFormatVectorOfSInt32 , '\0'  , "int32_t[]"           },
+    { eFormatVectorOfUInt32 , '\0'  , "uint32_t[]"          },
+    { eFormatVectorOfSInt64 , '\0'  , "int64_t[]"           },
+    { eFormatVectorOfUInt64 , '\0'  , "uint64_t[]"          },
+    { eFormatVectorOfFloat32, '\0'  , "float32[]"           },
+    { eFormatVectorOfFloat64, '\0'  , "float64[]"           },
+    { eFormatVectorOfUInt128, '\0'  , "uint128_t[]"         },
+    { eFormatComplexInteger , 'I'   , "complex integer"     },
+    { eFormatCharArray      , 'a'   , "character array"     },
+    { eFormatAddressInfo    , 'A'   , "address"             },
+    { eFormatHexFloat       , '\0'  , "hex float"           },
+    { eFormatInstruction    , 'i'   , "instruction"         },
+    { eFormatVoid           , 'v'   , "void"                }
+};
+
+static uint32_t 
+g_num_format_infos = sizeof(g_format_infos)/sizeof(FormatInfo);
+
+static bool
+GetFormatFromFormatChar (char format_char, Format &format)
+{
+    for (uint32_t i=0; i<g_num_format_infos; ++i)
+    {
+        if (g_format_infos[i].format_char == format_char)
+        {
+            format = g_format_infos[i].format;
+            return true;
+        }
+    }
+    format = eFormatInvalid;
+    return false;
+}
+
+static bool
+GetFormatFromFormatName (const char *format_name, bool partial_match_ok, Format &format)
+{
+    uint32_t i;
+    for (i=0; i<g_num_format_infos; ++i)
+    {
+        if (strcasecmp (g_format_infos[i].format_name, format_name) == 0)
+        {
+            format = g_format_infos[i].format;
+            return true;
+        }
+    }
+    
+    if (partial_match_ok)
+    {
+        for (i=0; i<g_num_format_infos; ++i)
+        {
+            if (strcasestr (g_format_infos[i].format_name, format_name) == g_format_infos[i].format_name)
+            {
+                format = g_format_infos[i].format;
+                return true;
+            }
+        }
+    }
+    format = eFormatInvalid;
+    return false;
+}
+
+bool
+FormatManager::GetFormatFromCString (const char *format_cstr,
+                                     bool partial_match_ok,
+                                     lldb::Format &format)
+{
+    bool success = false;
+    if (format_cstr && format_cstr[0])
+    {
+        if (format_cstr[1] == '\0')
+        {
+            success = GetFormatFromFormatChar (format_cstr[0], format);
+            if (success)
+                return true;
+        }
+        
+        success = GetFormatFromFormatName (format_cstr, partial_match_ok, format);
+    }
+    if (!success)
+        format = eFormatInvalid;
+    return success;
+}
+
+char
+FormatManager::GetFormatAsFormatChar (lldb::Format format)
+{
+    for (uint32_t i=0; i<g_num_format_infos; ++i)
+    {
+        if (g_format_infos[i].format == format)
+            return g_format_infos[i].format_char;
+    }
+    return '\0';
+}
+
+const char *
+FormatManager::GetFormatAsCString (Format format)
+{
+    if (format >= eFormatDefault && format < kNumFormats)
+        return g_format_infos[format].format_name;
+    return NULL;
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::TypeSummaryImplSP();
+    lldb::TypeSummaryImplSP summary_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::TypeSummaryImplSP summary_current_sp = category_sp->GetSummaryForType(type_sp);
+        if (summary_current_sp && (summary_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            summary_chosen_sp = summary_current_sp;
+        }
+    }
+    return summary_chosen_sp;
+}
+
+lldb::TypeFilterImplSP
+FormatManager::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::TypeFilterImplSP();
+    lldb::TypeFilterImplSP filter_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::TypeFilterImplSP filter_current_sp((TypeFilterImpl*)category_sp->GetFilterForType(type_sp).get());
+        if (filter_current_sp && (filter_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            filter_chosen_sp = filter_current_sp;
+        }
+    }
+    return filter_chosen_sp;
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::ScriptedSyntheticChildrenSP
+FormatManager::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::ScriptedSyntheticChildrenSP();
+    lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
+    uint32_t num_categories = m_categories_map.GetCount();
+    lldb::TypeCategoryImplSP category_sp;
+    uint32_t prio_category = UINT32_MAX;
+    for (uint32_t category_id = 0;
+         category_id < num_categories;
+         category_id++)
+    {
+        category_sp = GetCategoryAtIndex(category_id);
+        if (category_sp->IsEnabled() == false)
+            continue;
+        lldb::ScriptedSyntheticChildrenSP synth_current_sp((ScriptedSyntheticChildren*)category_sp->GetSyntheticForType(type_sp).get());
+        if (synth_current_sp && (synth_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
+        {
+            prio_category = category_sp->GetEnabledPosition();
+            synth_chosen_sp = synth_current_sp;
+        }
+    }
+    return synth_chosen_sp;
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+FormatManager::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    if (!type_sp)
+        return lldb::SyntheticChildrenSP();
+    lldb::TypeFilterImplSP filter_sp = GetFilterForType(type_sp);
+    lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp);
+    if (filter_sp->GetRevision() > synth_sp->GetRevision())
+        return lldb::SyntheticChildrenSP(filter_sp.get());
+    else
+        return lldb::SyntheticChildrenSP(synth_sp.get());
+}
+#endif
+
+lldb::TypeCategoryImplSP
+FormatManager::GetCategory (const ConstString& category_name,
+                         bool can_create)
+{
+    if (!category_name)
+        return GetCategory(m_default_category_name);
+    lldb::TypeCategoryImplSP category;
+    if (m_categories_map.Get(category_name, category))
+        return category;
+    
+    if (!can_create)
+        return lldb::TypeCategoryImplSP();
+    
+    m_categories_map.Add(category_name,lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
+    return GetCategory(category_name);
+}
+
+lldb::Format
+FormatManager::GetSingleItemFormat(lldb::Format vector_format)
+{
+    switch(vector_format)
+    {
+        case eFormatVectorOfChar:
+            return eFormatCharArray;
+            
+        case eFormatVectorOfSInt8:
+        case eFormatVectorOfSInt16:
+        case eFormatVectorOfSInt32:
+        case eFormatVectorOfSInt64:
+            return eFormatDecimal;
+            
+        case eFormatVectorOfUInt8:
+        case eFormatVectorOfUInt16:
+        case eFormatVectorOfUInt32:
+        case eFormatVectorOfUInt64:
+        case eFormatVectorOfUInt128:
+            return eFormatHex;
+            
+        case eFormatVectorOfFloat32:
+        case eFormatVectorOfFloat64:
+            return eFormatFloat;
+            
+        default:
+            return lldb::eFormatInvalid;
+    }
+}
+
+ConstString
+FormatManager::GetValidTypeName (const ConstString& type)
+{
+    return ::GetValidTypeName_Impl(type);
+}
+
+ConstString
+GetTypeForCache (ValueObject& valobj,
+                 lldb::DynamicValueType use_dynamic)
+{
+    if (use_dynamic == lldb::eNoDynamicValues)
+    {
+        if (valobj.IsDynamic())
+        {
+            if (valobj.GetStaticValue())
+                return valobj.GetStaticValue()->GetQualifiedTypeName();
+            else
+                return ConstString();
+        }
+        else
+            return valobj.GetQualifiedTypeName();
+    }
+    if (valobj.IsDynamic())
+        return valobj.GetQualifiedTypeName();
+    if (valobj.GetDynamicValue(use_dynamic))
+        return valobj.GetDynamicValue(use_dynamic)->GetQualifiedTypeName();
+    return ConstString();
+}
+
+lldb::TypeSummaryImplSP
+FormatManager::GetSummaryFormat (ValueObject& valobj,
+                                 lldb::DynamicValueType use_dynamic)
+{
+    TypeSummaryImplSP retval;
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    ConstString valobj_type(GetTypeForCache(valobj, use_dynamic));
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache for type %s", valobj_type.AsCString("<invalid>"));
+        if (m_format_cache.GetSummary(valobj_type,retval))
+        {
+            if (log)
+            {
+                log->Printf("[FormatManager::GetSummaryFormat] Cache search success. Returning.");
+                if (log->GetDebug())
+                    log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+            }
+            return retval;
+        }
+        if (log)
+            log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. Going normal route");
+    }
+    retval = m_categories_map.GetSummaryFormat(valobj, use_dynamic);
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",retval.get(),valobj_type.AsCString("<invalid>"));
+        m_format_cache.SetSummary(valobj_type,retval);
+    }
+    if (log && log->GetDebug())
+        log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+    return retval;
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+FormatManager::GetSyntheticChildren (ValueObject& valobj,
+                                     lldb::DynamicValueType use_dynamic)
+{
+    SyntheticChildrenSP retval;
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    ConstString valobj_type(GetTypeForCache(valobj, use_dynamic));
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into cache for type %s", valobj_type.AsCString("<invalid>"));
+        if (m_format_cache.GetSynthetic(valobj_type,retval))
+        {
+            if (log)
+            {
+                log->Printf("[FormatManager::GetSyntheticChildren] Cache search success. Returning.");
+                if (log->GetDebug())
+                    log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+            }
+            return retval;
+        }
+        if (log)
+            log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. Going normal route");
+    }
+    retval = m_categories_map.GetSyntheticChildren(valobj, use_dynamic);
+    if (valobj_type)
+    {
+        if (log)
+            log->Printf("[FormatManager::GetSyntheticChildren] Caching %p for type %s",retval.get(),valobj_type.AsCString("<invalid>"));
+        m_format_cache.SetSynthetic(valobj_type,retval);
+    }
+    if (log && log->GetDebug())
+        log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+    return retval;
+}
+#endif
+
+FormatManager::FormatManager() :
+    m_format_cache(),
+    m_value_nav("format",this),
+    m_named_summaries_map(this),
+    m_last_revision(0),
+    m_categories_map(this),
+    m_default_category_name(ConstString("default")),
+    m_system_category_name(ConstString("system")), 
+    m_gnu_cpp_category_name(ConstString("gnu-libstdc++")),
+    m_libcxx_category_name(ConstString("libcxx")),
+    m_objc_category_name(ConstString("objc")),
+    m_corefoundation_category_name(ConstString("CoreFoundation")),
+    m_coregraphics_category_name(ConstString("CoreGraphics")),
+    m_coreservices_category_name(ConstString("CoreServices")),
+    m_vectortypes_category_name(ConstString("VectorTypes")),
+    m_appkit_category_name(ConstString("AppKit"))
+{
+    LoadSystemFormatters();
+    LoadLibStdcppFormatters();
+    LoadLibcxxFormatters();
+    LoadObjCFormatters();
+    
+    EnableCategory(m_objc_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_corefoundation_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_appkit_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_coreservices_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_coregraphics_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_gnu_cpp_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_libcxx_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_vectortypes_category_name,TypeCategoryMap::Last);
+    EnableCategory(m_system_category_name,TypeCategoryMap::Last);
+}
+
+static void
+AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
+                 const char* string,
+                 ConstString type_name,
+                 TypeSummaryImpl::Flags flags,
+                 bool regex = false)
+{
+    lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags,
+                                                               string));
+    
+    if (regex)
+        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+    else
+        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+static void
+AddScriptSummary(TypeCategoryImpl::SharedPointer category_sp,
+                 const char* funct_name,
+                 ConstString type_name,
+                 TypeSummaryImpl::Flags flags,
+                 bool regex = false)
+{
+    
+    std::string code("     ");
+    code.append(funct_name).append("(valobj,internal_dict)");
+    
+    lldb::TypeSummaryImplSP summary_sp(new ScriptSummaryFormat(flags,
+                                                               funct_name,
+                                                               code.c_str()));
+    if (regex)
+        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+    else
+        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+static void
+AddCXXSummary (TypeCategoryImpl::SharedPointer category_sp,
+               CXXFunctionSummaryFormat::Callback funct,
+               const char* description,
+               ConstString type_name,
+               TypeSummaryImpl::Flags flags,
+               bool regex = false)
+{
+    lldb::TypeSummaryImplSP summary_sp(new CXXFunctionSummaryFormat(flags,funct,description));
+    if (regex)
+        category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
+    else
+        category_sp->GetSummaryNavigator()->Add(type_name, summary_sp);
+}
+#endif
+
+#ifndef LLDB_DISABLE_PYTHON
+static void AddCXXSynthetic  (TypeCategoryImpl::SharedPointer category_sp,
+                              CXXSyntheticChildren::CreateFrontEndCallback generator,
+                              const char* description,
+                              ConstString type_name,
+                              ScriptedSyntheticChildren::Flags flags,
+                              bool regex = false)
+{
+    lldb::SyntheticChildrenSP synth_sp(new CXXSyntheticChildren(flags,description,generator));
+    if (regex)
+        category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), synth_sp);
+    else
+        category_sp->GetSyntheticNavigator()->Add(type_name,synth_sp);
+}
+#endif
+
+void
+FormatManager::LoadLibStdcppFormatters()
+{
+    TypeSummaryImpl::Flags stl_summary_flags;
+    stl_summary_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+    lldb::TypeSummaryImplSP std_string_summary_sp(new StringSummaryFormat(stl_summary_flags,
+                                                                          "${var._M_dataplus._M_p}"));
+    
+    TypeCategoryImpl::SharedPointer gnu_category_sp = GetCategory(m_gnu_cpp_category_name);
+    
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::string"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char>"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char,std::char_traits<char>,std::allocator<char> >"),
+                                                std_string_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
+                                                std_string_summary_sp);
+    
+    // making sure we force-pick the summary for printing wstring (_M_p is a wchar_t*)
+    lldb::TypeSummaryImplSP std_wstring_summary_sp(new StringSummaryFormat(stl_summary_flags,
+                                                                           "${var._M_dataplus._M_p%S}"));
+    
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::wstring"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t>"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> >"),
+                                                std_wstring_summary_sp);
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >"),
+                                                std_wstring_summary_sp);
+    
+    
+#ifndef LLDB_DISABLE_PYTHON
+    
+    SyntheticChildren::Flags stl_synth_flags;
+    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
+    
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdVectorSynthProvider")));
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdMapSynthProvider")));
+    gnu_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+                                                       SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                 "lldb.formatters.cpp.gnu_libstdcpp.StdListSynthProvider")));
+    
+    stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(true);
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::vector<.+>(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::map<.+> >(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+    gnu_category_sp->GetRegexSummaryNavigator()->Add(RegularExpressionSP(new RegularExpression("^std::list<.+>(( )?&)?$")),
+                                                     TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags,
+                                                                                               "size=${svar%#}")));
+
+    AddCXXSynthetic(gnu_category_sp, lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
+    
+    AddCXXSynthetic(gnu_category_sp, lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
+    
+    gnu_category_sp->GetSummaryNavigator()->Add(ConstString("std::vector<std::allocator<bool> >"),
+                                                   TypeSummaryImplSP(new StringSummaryFormat(stl_summary_flags, "size=${svar%#}")));
+    
+    gnu_category_sp->GetSyntheticNavigator()->Add(ConstString("std::vector<std::allocator<bool> >"),
+                                                     SyntheticChildrenSP(new CXXSyntheticChildren(stl_synth_flags,"libc++ std::vector<bool> synthetic children",lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEndCreator)));
+
+#endif
+}
+
+void
+FormatManager::LoadLibcxxFormatters()
+{
+    TypeSummaryImpl::Flags stl_summary_flags;
+    stl_summary_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+#ifndef LLDB_DISABLE_PYTHON
+    //std::string code("     lldb.formatters.cpp.libcxx.stdstring_SummaryProvider(valobj,internal_dict)");
+    //lldb::TypeSummaryImplSP std_string_summary_sp(new ScriptSummaryFormat(stl_summary_flags, "lldb.formatters.cpp.libcxx.stdstring_SummaryProvider",code.c_str()));
+    
+    lldb::TypeSummaryImplSP std_string_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxStringSummaryProvider, "std::string summary provider"));
+    lldb::TypeSummaryImplSP std_wstring_summary_sp(new CXXFunctionSummaryFormat(stl_summary_flags, lldb_private::formatters::LibcxxWStringSummaryProvider, "std::wstring summary provider"));
+
+    TypeCategoryImpl::SharedPointer libcxx_category_sp = GetCategory(m_libcxx_category_name);
+    
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::string"),
+                                                   std_string_summary_sp);
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >"),
+                                                   std_string_summary_sp);
+
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::wstring"),
+                                                   std_wstring_summary_sp);
+    libcxx_category_sp->GetSummaryNavigator()->Add(ConstString("std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >"),
+                                                   std_wstring_summary_sp);
+    
+    SyntheticChildren::Flags stl_synth_flags;
+    stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
+    
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator, "libc++ std::vector synthetic children", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator, "libc++ std::list synthetic children", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::map synthetic children", ConstString("^std::__1::map<.+> >(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator, "libc++ std::vector<bool> synthetic children", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_synth_flags);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::set synthetic children", ConstString("^std::__1::set<.+> >(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multiset synthetic children", ConstString("^std::__1::multiset<.+> >(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator, "libc++ std::multimap synthetic children", ConstString("^std::__1::multimap<.+> >(( )?&)?$"), stl_synth_flags, true);
+
+    libcxx_category_sp->GetRegexSyntheticNavigator()->Add(RegularExpressionSP(new RegularExpression("^(std::__1::)deque<.+>(( )?&)?$")),
+                                                          SyntheticChildrenSP(new ScriptedSyntheticChildren(stl_synth_flags,
+                                                                                                    "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
+    
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "shared_ptr synthetic children", ConstString("^(std::__1::)shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator, "weak_ptr synthetic children", ConstString("^(std::__1::)weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
+    
+    stl_summary_flags.SetDontShowChildren(false);stl_summary_flags.SetSkipPointers(false);
+    
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector summary provider", ConstString("^std::__1::vector<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::list summary provider", ConstString("^std::__1::list<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::map summary provider", ConstString("^std::__1::map<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::deque summary provider", ConstString("^std::__1::deque<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::vector<bool> summary provider", ConstString("std::__1::vector<std::__1::allocator<bool> >"), stl_summary_flags);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::set summary provider", ConstString("^std::__1::set<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multiset summary provider", ConstString("^std::__1::multiset<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddCXXSummary(libcxx_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider, "libc++ std::multimap summary provider", ConstString("^std::__1::multimap<.+>(( )?&)?$"), stl_summary_flags, true);
+
+    stl_summary_flags.SetSkipPointers(true);
+    AddStringSummary(libcxx_category_sp, "{${var.__ptr_%S}} (strong=${var.count} weak=${var.weak_count})}", ConstString("^std::__1::shared_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
+    AddStringSummary(libcxx_category_sp, "{${var.__ptr_%S}} (strong=${var.count} weak=${var.weak_count})}", ConstString("^std::__1::weak_ptr<.+>(( )?&)?$"), stl_summary_flags, true);
+    
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator, "std::vector iterator synthetic children", ConstString("^std::__1::__wrap_iter<.+>$"), stl_synth_flags, true);
+    
+    AddCXXSynthetic(libcxx_category_sp, lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator, "std::map iterator synthetic children", ConstString("^std::__1::__map_iterator<.+>$"), stl_synth_flags, true);
+    
+#endif
+}
+
+void
+FormatManager::LoadSystemFormatters()
+{
+    
+    TypeSummaryImpl::Flags string_flags;
+    string_flags.SetCascades(true)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+    
+    lldb::TypeSummaryImplSP string_format(new StringSummaryFormat(string_flags, "${var%s}"));
+    
+    
+    lldb::TypeSummaryImplSP string_array_format(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
+                                                                        .SetSkipPointers(true)
+                                                                        .SetSkipReferences(false)
+                                                                        .SetDontShowChildren(true)
+                                                                        .SetDontShowValue(true)
+                                                                        .SetShowMembersOneLiner(false)
+                                                                        .SetHideItemNames(false),
+                                                                        "${var%s}"));
+    
+    lldb::RegularExpressionSP any_size_char_arr(new RegularExpression("char \\[[0-9]+\\]"));
+    
+    TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name);
+    
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("char *"), string_format);
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("unsigned char *"), string_format);
+    sys_category_sp->GetRegexSummaryNavigator()->Add(any_size_char_arr, string_array_format);
+    
+    lldb::TypeSummaryImplSP ostype_summary(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
+                                                                   .SetSkipPointers(true)
+                                                                   .SetSkipReferences(true)
+                                                                   .SetDontShowChildren(true)
+                                                                   .SetDontShowValue(false)
+                                                                   .SetShowMembersOneLiner(false)
+                                                                   .SetHideItemNames(false),
+                                                                   "${var%O}"));
+    
+    sys_category_sp->GetSummaryNavigator()->Add(ConstString("OSType"), ostype_summary);
+    
+#ifndef LLDB_DISABLE_PYTHON
+    // FIXME because of a bug in the FormatNavigator we need to add a summary for both X* and const X* (<rdar://problem/12717717>)
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "char16_t * summary provider", ConstString("char16_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32StringSummaryProvider, "char32_t * summary provider", ConstString("char32_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharStringSummaryProvider, "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16StringSummaryProvider, "unichar * summary provider", ConstString("unichar *"), string_flags);
+    
+    TypeSummaryImpl::Flags widechar_flags;
+    widechar_flags.SetDontShowValue(true)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetCascades(true)
+    .SetDontShowChildren(true)
+    .SetHideItemNames(true)
+    .SetShowMembersOneLiner(false);
+    
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "char16_t summary provider", ConstString("char16_t"), widechar_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char32SummaryProvider, "char32_t summary provider", ConstString("char32_t"), widechar_flags);
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::WCharSummaryProvider, "wchar_t summary provider", ConstString("wchar_t"), widechar_flags);
+
+    AddCXXSummary(sys_category_sp, lldb_private::formatters::Char16SummaryProvider, "unichar summary provider", ConstString("unichar"), widechar_flags);
+    
+#endif
+}
+
+void
+FormatManager::LoadObjCFormatters()
+{
+    TypeSummaryImpl::Flags objc_flags;
+    objc_flags.SetCascades(false)
+    .SetSkipPointers(true)
+    .SetSkipReferences(true)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(true)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+
+    TypeCategoryImpl::SharedPointer objc_category_sp = GetCategory(m_objc_category_name);
+    
+    lldb::TypeSummaryImplSP ObjC_BOOL_summary(new CXXFunctionSummaryFormat(objc_flags, lldb_private::formatters::ObjCBOOLSummaryProvider,""));
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL"),
+                                                 ObjC_BOOL_summary);
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL &"),
+                                                 ObjC_BOOL_summary);
+    objc_category_sp->GetSummaryNavigator()->Add(ConstString("BOOL *"),
+                                                 ObjC_BOOL_summary);
+
+#ifndef LLDB_DISABLE_PYTHON
+    // we need to skip pointers here since we are special casing a SEL* when retrieving its value
+    objc_flags.SetSkipPointers(true);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("SEL"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("struct objc_selector"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>, "SEL summary provider", ConstString("objc_selector"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("objc_selector *"), objc_flags);
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>, "SEL summary provider", ConstString("SEL *"), objc_flags);
+    
+    AddCXXSummary(objc_category_sp, lldb_private::formatters::ObjCClassSummaryProvider, "Class summary provider", ConstString("Class"), objc_flags);
+    
+    SyntheticChildren::Flags class_synth_flags;
+    class_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(false);
+    
+    AddCXXSynthetic(objc_category_sp, lldb_private::formatters::ObjCClassSyntheticFrontEndCreator, "Class synthetic children", ConstString("Class"), class_synth_flags);
+#endif // LLDB_DISABLE_PYTHON
+
+    objc_flags.SetSkipPointers(false);
+    objc_flags.SetCascades(true);
+    objc_flags.SetSkipReferences(false);
+    
+    AddStringSummary (objc_category_sp,
+                      "${var.__FuncPtr%A}",
+                      ConstString("__block_literal_generic"),
+                      objc_flags);
+
+    TypeCategoryImpl::SharedPointer corefoundation_category_sp = GetCategory(m_corefoundation_category_name);
+
+    AddStringSummary(corefoundation_category_sp,
+                     "${var.years} years, ${var.months} months, ${var.days} days, ${var.hours} hours, ${var.minutes} minutes ${var.seconds} seconds",
+                     ConstString("CFGregorianUnits"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "location=${var.location} length=${var.length}",
+                     ConstString("CFRange"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("NSPoint"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "location=${var.location}, length=${var.length}",
+                     ConstString("NSRange"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "${var.origin}, ${var.size}",
+                     ConstString("NSRect"),
+                     objc_flags);
+    AddStringSummary(corefoundation_category_sp,
+                     "(${var.origin}, ${var.size}), ...",
+                     ConstString("NSRectArray"),
+                     objc_flags);
+    AddStringSummary(objc_category_sp,
+                     "(width=${var.width}, height=${var.height})",
+                     ConstString("NSSize"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer coregraphics_category_sp = GetCategory(m_coregraphics_category_name);
+    
+    AddStringSummary(coregraphics_category_sp,
+                     "(width=${var.width}, height=${var.height})",
+                     ConstString("CGSize"),
+                     objc_flags);
+    AddStringSummary(coregraphics_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("CGPoint"),
+                     objc_flags);
+    AddStringSummary(coregraphics_category_sp,
+                     "origin=${var.origin} size=${var.size}",
+                     ConstString("CGRect"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer coreservices_category_sp = GetCategory(m_coreservices_category_name);
+    
+    AddStringSummary(coreservices_category_sp,
+                     "red=${var.red} green=${var.green} blue=${var.blue}",
+                     ConstString("RGBColor"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})",
+                     ConstString("Rect"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(v=${var.v}, h=${var.h})",
+                     ConstString("Point"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "${var.month}/${var.day}/${var.year}  ${var.hour} :${var.minute} :${var.second} dayOfWeek:${var.dayOfWeek}",
+                     ConstString("DateTimeRect *"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "${var.ld.month}/${var.ld.day}/${var.ld.year} ${var.ld.hour} :${var.ld.minute} :${var.ld.second} dayOfWeek:${var.ld.dayOfWeek}",
+                     ConstString("LongDateRect"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "(x=${var.x}, y=${var.y})",
+                     ConstString("HIPoint"),
+                     objc_flags);
+    AddStringSummary(coreservices_category_sp,
+                     "origin=${var.origin} size=${var.size}",
+                     ConstString("HIRect"),
+                     objc_flags);
+    
+    TypeCategoryImpl::SharedPointer appkit_category_sp = GetCategory(m_appkit_category_name);
+    
+    TypeSummaryImpl::Flags appkit_flags;
+    appkit_flags.SetCascades(true)
+    .SetSkipPointers(false)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(false)
+    .SetHideItemNames(false);
+
+    appkit_flags.SetDontShowChildren(false);
+    
+
+#ifndef LLDB_DISABLE_PYTHON
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSArraySummaryProvider, "NSArray summary provider", ConstString("CFMutableArrayRef"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("NSMutableDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSCFDictionary"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<false>, "NSDictionary summary provider", ConstString("__NSDictionaryM"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFDictionaryRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDictionarySummaryProvider<true>, "NSDictionary summary provider", ConstString("CFMutableDictionaryRef"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSSet summary", ConstString("NSSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFSetRef summary", ConstString("CFSetRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>, "CFMutableSetRef summary", ConstString("CFMutableSetRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSCFSet summary", ConstString("__NSCFSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetI summary", ConstString("__NSSetI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSSetM summary", ConstString("__NSSetM"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSCountedSet summary", ConstString("NSCountedSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "NSOrderedSet summary", ConstString("NSOrderedSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetI summary", ConstString("__NSOrderedSetI"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>, "__NSOrderedSetM summary", ConstString("__NSOrderedSetM"), appkit_flags);
+
+    // AddSummary(appkit_category_sp, "${var.key%@} -> ${var.value%@}", ConstString("$_lldb_typegen_nspair"), appkit_flags);
+    
+    appkit_flags.SetDontShowChildren(true);
+    
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayM"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSArrayI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSArray"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("NSMutableArray"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("__NSCFArray"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFMutableArrayRef"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSArraySyntheticFrontEndCreator, "NSArray synthetic children", ConstString("CFArrayRef"), ScriptedSyntheticChildren::Flags());
+
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryM"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("__NSDictionaryI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSDictionary"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("NSMutableDictionary"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFDictionaryRef"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSDictionarySyntheticFrontEndCreator, "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"), ScriptedSyntheticChildren::Flags());
+
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSSet synthetic children", ConstString("NSSet"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetI synthetic children", ConstString("__NSSetI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSSetM synthetic children", ConstString("__NSSetM"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSMutableSet synthetic children", ConstString("NSMutableSet"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "NSOrderedSet synthetic children", ConstString("NSOrderedSet"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetI synthetic children", ConstString("__NSOrderedSetI"), ScriptedSyntheticChildren::Flags());
+    AddCXXSynthetic(appkit_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator, "__NSOrderedSetM synthetic children", ConstString("__NSOrderedSetM"), ScriptedSyntheticChildren::Flags());
+    
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFBagRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("__CFBag"), appkit_flags);
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("const struct __CFBag"), appkit_flags);
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBagSummaryProvider, "CFBag summary provider", ConstString("CFMutableBagRef"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("CFBinaryHeapRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp,lldb_private::formatters::CFBinaryHeapSummaryProvider, "CFBinaryHeap summary provider", ConstString("__CFBinaryHeap"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFStringRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("CFMutableStringRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSMutableString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFConstantString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("__NSCFString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFConstantString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSCFString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSStringSummaryProvider, "NSString summary provider", ConstString("NSPathStore2"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSAttributedStringSummaryProvider, "NSAttributedString summary provider", ConstString("NSAttributedString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSMutableAttributedString"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMutableAttributedStringSummaryProvider, "NSMutableAttributedString summary provider", ConstString("NSConcreteMutableAttributedString"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSBundleSummaryProvider, "NSBundle summary provider", ConstString("NSBundle"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("NSConcreteMutableData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>, "NSData summary provider", ConstString("__NSCFData"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFDataRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>, "NSData summary provider", ConstString("CFMutableDataRef"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSMachPortSummaryProvider, "NSMachPort summary provider", ConstString("NSMachPort"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSNotification"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNotificationSummaryProvider, "NSNotification summary provider", ConstString("NSConcreteNotification"), appkit_flags);
+
+    AddStringSummary(appkit_category_sp, "domain: ${var._domain} - code: ${var._code}", ConstString("NSError"), appkit_flags);
+    AddStringSummary(appkit_category_sp,"name:${var.name%S} reason:${var.reason%S}",ConstString("NSException"),appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("__NSCFNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSNumberSummaryProvider, "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSDecimalNumber summary provider", ConstString("NSDecimalNumber"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSHost summary provider", ConstString("NSHost"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSTask summary provider", ConstString("NSTask"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::RuntimeSpecificDescriptionSummaryProvider, "NSValue summary provider", ConstString("NSValue"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("NSURL"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSURLSummaryProvider, "NSURL summary provider", ConstString("CFURLRef"), appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSDate"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSDate"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("__NSTaggedDate"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSDateSummaryProvider, "NSDate summary provider", ConstString("NSCalendarDate"), appkit_flags);
+
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("NSTimeZone"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("CFTimeZoneRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider, "NSTimeZone summary provider", ConstString("__NSTimeZone"), appkit_flags);
+
+    // CFAbsoluteTime is actually a double rather than a pointer to an object
+    // we do not care about the numeric value, since it is probably meaningless to users
+    appkit_flags.SetDontShowValue(true);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::CFAbsoluteTimeSummaryProvider, "CFAbsoluteTime summary provider", ConstString("CFAbsoluteTime"), appkit_flags);
+    appkit_flags.SetDontShowValue(false);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSIndexSet"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider, "NSIndexSet summary provider", ConstString("NSMutableIndexSet"), appkit_flags);
+
+    AddStringSummary(appkit_category_sp,
+                     "@\"${var.month%d}/${var.day%d}/${var.year%d} ${var.hour%d}:${var.minute%d}:${var.second}\"",
+                     ConstString("CFGregorianDate"),
+                     appkit_flags);
+    
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFBitVectorRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("CFMutableBitVectorRef"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFBitVector"), appkit_flags);
+    AddCXXSummary(appkit_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider, "CFBitVector summary provider", ConstString("__CFMutableBitVector"), appkit_flags);
+#endif // LLDB_DISABLE_PYTHON
+    
+    TypeCategoryImpl::SharedPointer vectors_category_sp = GetCategory(m_vectortypes_category_name);
+
+    TypeSummaryImpl::Flags vector_flags;
+    vector_flags.SetCascades(true)
+    .SetSkipPointers(true)
+    .SetSkipReferences(false)
+    .SetDontShowChildren(true)
+    .SetDontShowValue(false)
+    .SetShowMembersOneLiner(true)
+    .SetHideItemNames(true);
+    
+    AddStringSummary(vectors_category_sp,
+                     "${var.uint128}",
+                     ConstString("builtin_type_vec128"),
+                     objc_flags);
+
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("float [4]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("int32_t [4]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("int16_t [8]"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vDouble"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vFloat"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt8"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vSInt32"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt8"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt16"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vUInt32"),
+                     vector_flags);
+    AddStringSummary(vectors_category_sp,
+                     "",
+                     ConstString("vBool32"),
+                     vector_flags);
+}
diff --git a/source/DataFormatters/LibCxx.cpp b/source/DataFormatters/LibCxx.cpp
new file mode 100644
index 0000000..cdc57f6
--- /dev/null
+++ b/source/DataFormatters/LibCxx.cpp
@@ -0,0 +1,519 @@
+//===-- LibCxx.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_count(0),
+m_base_data_address(0),
+m_options()
+{
+    if (valobj_sp)
+        Update();
+    m_options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+}
+
+size_t
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return m_count;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx >= m_count)
+        return ValueObjectSP();
+    if (m_base_data_address == 0 || m_count == 0)
+        return ValueObjectSP();
+    size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
+    size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
+    lldb::addr_t byte_location = m_base_data_address + byte_idx;
+    ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
+    if (!process_sp)
+        return ValueObjectSP();
+    uint8_t byte = 0;
+    uint8_t mask = 0;
+    Error err;
+    size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
+    if (err.Fail() || bytes_read == 0)
+        return ValueObjectSP();
+    switch (bit_index)
+    {
+        case 0:
+            mask = 1; break;
+        case 1:
+            mask = 2; break;
+        case 2:
+            mask = 4; break;
+        case 3:
+            mask = 8; break;
+        case 4:
+            mask = 16; break;
+        case 5:
+            mask = 32; break;
+        case 6:
+            mask = 64; break;
+        case 7:
+            mask = 128; break;
+        default:
+            return ValueObjectSP();
+    }
+    bool bit_set = ((byte & mask) != 0);
+    Target& target(process_sp->GetTarget());
+    ValueObjectSP retval_sp;
+    if (bit_set)
+        target.EvaluateExpression("(bool)true", NULL, retval_sp);
+    else
+        target.EvaluateExpression("(bool)false", NULL, retval_sp);
+    StreamString name; name.Printf("[%zu]",idx);
+    if (retval_sp)
+        retval_sp->SetName(ConstString(name.GetData()));
+    return retval_sp;
+}
+
+/*(std::__1::vector<std::__1::allocator<bool> >) vBool = {
+ __begin_ = 0x00000001001000e0
+ __size_ = 56
+ __cap_alloc_ = {
+ std::__1::__libcpp_compressed_pair_imp<unsigned long, std::__1::allocator<unsigned long> > = {
+ __first_ = 1
+ }
+ }
+ }*/
+
+bool
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update()
+{
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName(ConstString("__size_"), true));
+    if (!size_sp)
+        return false;
+    m_count = size_sp->GetValueAsUnsigned(0);
+    if (!m_count)
+        return true;
+    ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName(ConstString("__begin_"), true));
+    if (!begin_sp)
+    {
+        m_count = 0;
+        return false;
+    }
+    m_base_data_address = begin_sp->GetValueAsUnsigned(0);
+    if (!m_base_data_address)
+    {
+        m_count = 0;
+        return false;
+    }
+    return false;
+}
+
+bool
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (!m_count || !m_base_data_address)
+        return UINT32_MAX;
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::~LibcxxVectorBoolSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibcxxVectorBoolSyntheticFrontEnd(valobj_sp));
+}
+
+/*
+ (lldb) fr var ibeg --raw --ptr-depth 1
+ (std::__1::__map_iterator<std::__1::__tree_iterator<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, std::__1::__tree_node<std::__1::pair<int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >, void *> *, long> >) ibeg = {
+ __i_ = {
+ __ptr_ = 0x0000000100103870 {
+ std::__1::__tree_node_base<void *> = {
+ std::__1::__tree_end_node<std::__1::__tree_node_base<void *> *> = {
+ __left_ = 0x0000000000000000
+ }
+ __right_ = 0x0000000000000000
+ __parent_ = 0x00000001001038b0
+ __is_black_ = true
+ }
+ __value_ = {
+ first = 0
+ second = { std::string }
+ */
+
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_pair_ptr()
+{
+    if (valobj_sp)
+        Update();
+}
+
+bool
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update()
+{
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    
+    TargetSP target_sp(valobj_sp->GetTargetSP());
+    
+    if (!target_sp)
+        return false;
+
+    if (!valobj_sp)
+        return false;
+
+    // this must be a ValueObject* because it is a child of the ValueObject we are producing children for
+    // it if were a ValueObjectSP, we would end up with a loop (iterator -> synthetic -> child -> parent == iterator)
+    // and that would in turn leak memory by never allowing the ValueObjects to die and free their memory
+    m_pair_ptr = valobj_sp->GetValueForExpressionPath(".__i_.__ptr_->__value_",
+                                                     NULL,
+                                                     NULL,
+                                                     NULL,
+                                                     ValueObject::GetValueForExpressionPathOptions().DontCheckDotVsArrowSyntax().DontAllowSyntheticChildren(),
+                                                     NULL).get();
+    
+    return false;
+}
+
+size_t
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return 2;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (!m_pair_ptr)
+        return lldb::ValueObjectSP();
+    return m_pair_ptr->GetChildAtIndex(idx, true);
+}
+
+bool
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (name == ConstString("first"))
+        return 0;
+    if (name == ConstString("second"))
+        return 1;
+    return UINT32_MAX;
+}
+
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::~LibCxxMapIteratorSyntheticFrontEnd ()
+{
+    // this will be deleted when its parent dies (since it's a child object)
+    //delete m_pair_ptr;
+}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp));
+}
+
+/*
+ (lldb) fr var ibeg --raw --ptr-depth 1 -T
+ (std::__1::__wrap_iter<int *>) ibeg = {
+ (std::__1::__wrap_iter<int *>::iterator_type) __i = 0x00000001001037a0 {
+ (int) *__i = 1
+ }
+ }
+*/
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    static ConstString g_item_name;
+    if (!g_item_name)
+        g_item_name.SetCString("__i");
+    if (!valobj_sp)
+        return NULL;
+    return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name));
+}
+
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_cntrl(NULL),
+m_count_sp(),
+m_weak_count_sp(),
+m_ptr_size(0),
+m_byte_order(lldb::eByteOrderInvalid)
+{
+    if (valobj_sp)
+        Update();
+}
+
+size_t
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return (m_cntrl ? 1 : 0);
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (!m_cntrl)
+        return lldb::ValueObjectSP();
+
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return lldb::ValueObjectSP();
+
+    if (idx == 0)
+        return valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true);
+
+    if (idx > 2)
+        return lldb::ValueObjectSP();
+
+    if (idx == 1)
+    {
+        if (!m_count_sp)
+        {
+            ValueObjectSP shared_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_owners_"),true));
+            if (!shared_owners_sp)
+                return lldb::ValueObjectSP();
+            uint64_t count = 1 + shared_owners_sp->GetValueAsUnsigned(0);
+            DataExtractor data(&count, 8, m_byte_order, m_ptr_size);
+            m_count_sp = ValueObject::CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_owners_sp->GetClangType());
+        }
+        return m_count_sp;
+    }
+    else /* if (idx == 2) */
+    {
+        if (!m_weak_count_sp)
+        {
+            ValueObjectSP shared_weak_owners_sp(m_cntrl->GetChildMemberWithName(ConstString("__shared_weak_owners_"),true));
+            if (!shared_weak_owners_sp)
+                return lldb::ValueObjectSP();
+            uint64_t count = 1 + shared_weak_owners_sp->GetValueAsUnsigned(0);
+            DataExtractor data(&count, 8, m_byte_order, m_ptr_size);
+            m_weak_count_sp = ValueObject::CreateValueObjectFromData("count", data, valobj_sp->GetExecutionContextRef(), shared_weak_owners_sp->GetClangType());
+        }
+        return m_weak_count_sp;
+    }
+}
+
+bool
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update()
+{
+    m_count_sp.reset();
+    m_weak_count_sp.reset();
+    m_cntrl = NULL;
+    
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    
+    TargetSP target_sp(valobj_sp->GetTargetSP());
+    if (!target_sp)
+        return false;
+    
+    m_byte_order = target_sp->GetArchitecture().GetByteOrder();
+    m_ptr_size = target_sp->GetArchitecture().GetAddressByteSize();
+    
+    lldb::ValueObjectSP cntrl_sp(valobj_sp->GetChildMemberWithName(ConstString("__cntrl_"),true));
+    
+    m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular dependency
+    return false;
+}
+
+bool
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (name == ConstString("__ptr_"))
+        return 0;
+    if (name == ConstString("count"))
+        return 1;
+    if (name == ConstString("weak_count"))
+        return 2;
+    return UINT32_MAX;
+}
+
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::~LibcxxSharedPtrSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp));
+}
+
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+    SyntheticChildrenFrontEnd(*valobj_sp.get()),
+    m_start(NULL),
+    m_finish(NULL),
+    m_element_type(),
+    m_element_size(0),
+    m_children()
+{
+    if (valobj_sp)
+        Update();
+}
+
+size_t
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (!m_start || !m_finish)
+        return 0;
+    uint64_t start_val = m_start->GetValueAsUnsigned(0);
+    uint64_t finish_val = m_finish->GetValueAsUnsigned(0);
+
+    if (start_val == 0 || finish_val == 0)
+        return 0;
+    
+    if (start_val >= finish_val)
+        return 0;
+    
+    size_t num_children = (finish_val - start_val);
+    if (num_children % m_element_size)
+        return 0;
+    return num_children/m_element_size;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (!m_start || !m_finish)
+        return lldb::ValueObjectSP();
+    
+    auto cached = m_children.find(idx);
+    if (cached != m_children.end())
+        return cached->second;
+    
+    uint64_t offset = idx * m_element_size;
+    offset = offset + m_start->GetValueAsUnsigned(0);
+    StreamString name;
+    name.Printf("[%zu]",idx);
+    ValueObjectSP child_sp = ValueObject::CreateValueObjectFromAddress(name.GetData(), offset, m_backend.GetExecutionContextRef(), m_element_type);
+    m_children[idx] = child_sp;
+    return child_sp;
+}
+
+bool
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update()
+{
+    m_start = m_finish = NULL;
+    m_children.clear();
+    ValueObjectSP data_type_finder_sp(m_backend.GetChildMemberWithName(ConstString("__end_cap_"),true));
+    if (!data_type_finder_sp)
+        return false;
+    data_type_finder_sp = data_type_finder_sp->GetChildMemberWithName(ConstString("__first_"),true);
+    if (!data_type_finder_sp)
+        return false;
+    m_element_type = data_type_finder_sp->GetClangType().GetPointeeType();
+    m_element_size = m_element_type.GetByteSize();
+    
+    if (m_element_size > 0)
+    {
+        // store raw pointers or end up with a circular dependency
+        m_start = m_backend.GetChildMemberWithName(ConstString("__begin_"),true).get();
+        m_finish = m_backend.GetChildMemberWithName(ConstString("__end_"),true).get();
+    }
+    return false;
+}
+
+bool
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (!m_start || !m_finish)
+        return UINT32_MAX;
+    return ExtractIndexFromString(name.GetCString());
+}
+
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::~LibcxxStdVectorSyntheticFrontEnd ()
+{
+    // these need to stay around because they are child objects who will follow their parent's life cycle
+    // delete m_start;
+    // delete m_finish;
+}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibcxxStdVectorSyntheticFrontEnd(valobj_sp));
+}
+
+bool
+lldb_private::formatters::LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    if (valobj.IsPointerType())
+    {
+        uint64_t value = valobj.GetValueAsUnsigned(0);
+        if (!value)
+            return false;
+        stream.Printf("0x%016" PRIx64 " ", value);
+    }
+    return Debugger::FormatPrompt("size=${svar%#}", NULL, NULL, NULL, stream, &valobj);
+}
diff --git a/source/DataFormatters/LibCxxList.cpp b/source/DataFormatters/LibCxxList.cpp
new file mode 100644
index 0000000..de2ca1b
--- /dev/null
+++ b/source/DataFormatters/LibCxxList.cpp
@@ -0,0 +1,310 @@
+//===-- LibCxxList.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+class ListEntry
+{
+public:
+    ListEntry () {}
+    ListEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
+    ListEntry (const ListEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
+    ListEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
+    
+    ValueObjectSP
+    next ()
+    {
+        if (!m_entry_sp)
+            return m_entry_sp;
+        return m_entry_sp->GetChildMemberWithName(ConstString("__next_"), true);
+    }
+    
+    ValueObjectSP
+    prev ()
+    {
+        if (!m_entry_sp)
+            return m_entry_sp;
+        return m_entry_sp->GetChildMemberWithName(ConstString("__prev_"), true);
+    }
+    
+    uint64_t
+    value ()
+    {
+        if (!m_entry_sp)
+            return 0;
+        return m_entry_sp->GetValueAsUnsigned(0);
+    }
+
+    bool
+    null()
+    {
+        return (value() == 0);
+    }
+    
+    ValueObjectSP
+    GetEntry ()
+    {
+        return m_entry_sp;
+    }
+    
+    void
+    SetEntry (ValueObjectSP entry)
+    {
+        m_entry_sp = entry;
+    }
+    
+    bool
+    operator == (const ListEntry& rhs) const
+    {
+        return (rhs.m_entry_sp.get() == m_entry_sp.get());
+    }
+    
+private:
+    ValueObjectSP m_entry_sp;
+};
+
+class ListIterator
+{
+public:
+    ListIterator () {}
+    ListIterator (ListEntry entry) : m_entry(entry) {}
+    ListIterator (ValueObjectSP entry) : m_entry(entry) {}
+    ListIterator (const ListIterator& rhs) : m_entry(rhs.m_entry) {}
+    ListIterator (ValueObject* entry) : m_entry(entry) {}
+
+    ValueObjectSP
+    value ()
+    {
+        return m_entry.GetEntry();
+    }
+    
+    ValueObjectSP
+    advance (size_t count)
+    {
+        if (count == 0)
+            return m_entry.GetEntry();
+        if (count == 1)
+        {
+            next ();
+            return m_entry.GetEntry();
+        }
+        while (count > 0)
+        {
+            next ();
+            count--;
+            if (m_entry.null())
+                return lldb::ValueObjectSP();
+        }
+        return m_entry.GetEntry();
+    }
+    
+    bool
+    operator == (const ListIterator& rhs) const
+    {
+        return (rhs.m_entry == m_entry);
+    }
+    
+protected:
+    void
+    next ()
+    {
+        m_entry.SetEntry(m_entry.next());
+    }
+    
+    void
+    prev ()
+    {
+        m_entry.SetEntry(m_entry.prev());
+    }
+private:
+    ListEntry m_entry;
+};
+
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_list_capping_size(0),
+m_node_address(),
+m_head(NULL),
+m_tail(NULL),
+m_element_type(),
+m_count(UINT32_MAX),
+m_children()
+{
+    if (valobj_sp)
+        Update();
+}
+
+bool
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::HasLoop()
+{
+    if (g_use_loop_detect == false)
+        return false;
+    ListEntry slow(m_head);
+    ListEntry fast1(m_head);
+    ListEntry fast2(m_head);
+    while (slow.next() && slow.next()->GetValueAsUnsigned(0) != m_node_address)
+    {
+        auto slow_value = slow.value();
+        fast1.SetEntry(fast2.next());
+        fast2.SetEntry(fast1.next());
+        if (fast1.value() == slow_value || fast2.value() == slow_value)
+            return true;
+        slow.SetEntry(slow.next());
+    }
+    return false;
+}
+
+size_t
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (m_count != UINT32_MAX)
+        return m_count;
+    if (!m_head || !m_tail || m_node_address == 0)
+        return 0;
+    ValueObjectSP size_alloc(m_backend.GetChildMemberWithName(ConstString("__size_alloc_"), true));
+    if (size_alloc)
+    {
+        ValueObjectSP first(size_alloc->GetChildMemberWithName(ConstString("__first_"), true));
+        if (first)
+        {
+            m_count = first->GetValueAsUnsigned(UINT32_MAX);
+        }
+    }
+    if (m_count != UINT32_MAX)
+    {
+        if (!HasLoop())
+            return m_count;
+        return m_count = 0;
+    }
+    else
+    {
+        uint64_t next_val = m_head->GetValueAsUnsigned(0);
+        uint64_t prev_val = m_tail->GetValueAsUnsigned(0);
+        if (next_val == 0 || prev_val == 0)
+            return 0;
+        if (next_val == m_node_address)
+            return 0;
+        if (next_val == prev_val)
+            return 1;
+        if (HasLoop())
+            return 0;
+        uint64_t size = 2;
+        ListEntry current(m_head);
+        while (current.next() && current.next()->GetValueAsUnsigned(0) != m_node_address)
+        {
+            size++;
+            current.SetEntry(current.next());
+            if (size > m_list_capping_size)
+                break;
+        }
+        return m_count = (size-1);
+    }
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx >= CalculateNumChildren())
+        return lldb::ValueObjectSP();
+    
+    if (!m_head || !m_tail || m_node_address == 0)
+        return lldb::ValueObjectSP();
+    
+    auto cached = m_children.find(idx);
+    if (cached != m_children.end())
+        return cached->second;
+    
+    ListIterator current(m_head);
+    ValueObjectSP current_sp(current.advance(idx));
+    if (!current_sp)
+        return lldb::ValueObjectSP();
+    current_sp = current_sp->GetChildMemberWithName(ConstString("__value_"), true);
+    if (!current_sp)
+        return lldb::ValueObjectSP();
+    // we need to copy current_sp into a new object otherwise we will end up with all items named __value_
+    DataExtractor data;
+    current_sp->GetData(data);
+    StreamString name;
+    name.Printf("[%zu]",idx);
+    return (m_children[idx] = ValueObject::CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type));
+}
+
+bool
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::Update()
+{
+    m_head = m_tail = NULL;
+    m_node_address = 0;
+    m_count = UINT32_MAX;
+    Error err;
+    ValueObjectSP backend_addr(m_backend.AddressOf(err));
+    m_list_capping_size = 0;
+    if (m_backend.GetTargetSP())
+        m_list_capping_size = m_backend.GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
+    if (m_list_capping_size == 0)
+        m_list_capping_size = 255;
+    if (err.Fail() || backend_addr.get() == NULL)
+        return false;
+    m_node_address = backend_addr->GetValueAsUnsigned(0);
+    if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS)
+        return false;
+    ValueObjectSP impl_sp(m_backend.GetChildMemberWithName(ConstString("__end_"),true));
+    if (!impl_sp)
+        return false;
+    ClangASTType list_type = m_backend.GetClangType();
+    if (list_type.IsReferenceType())
+        list_type = list_type.GetNonReferenceType();
+
+    if (list_type.GetNumTemplateArguments() == 0)
+        return false;
+    lldb::TemplateArgumentKind kind;
+    m_element_type = list_type.GetTemplateArgument(0, kind);
+    m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
+    m_tail = impl_sp->GetChildMemberWithName(ConstString("__prev_"), true).get();
+    return false;
+}
+
+bool
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    return ExtractIndexFromString(name.GetCString());
+}
+
+lldb_private::formatters::LibcxxStdListSyntheticFrontEnd::~LibcxxStdListSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibcxxStdListSyntheticFrontEnd(valobj_sp));
+}
+
diff --git a/source/DataFormatters/LibCxxMap.cpp b/source/DataFormatters/LibCxxMap.cpp
new file mode 100644
index 0000000..5daa40f
--- /dev/null
+++ b/source/DataFormatters/LibCxxMap.cpp
@@ -0,0 +1,409 @@
+//===-- LibCxxList.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+class MapEntry
+{
+public:
+    MapEntry () {}
+    MapEntry (ValueObjectSP entry_sp) : m_entry_sp(entry_sp) {}
+    MapEntry (const MapEntry& rhs) : m_entry_sp(rhs.m_entry_sp) {}
+    MapEntry (ValueObject* entry) : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
+    
+    ValueObjectSP
+    left ()
+    {
+        if (!m_entry_sp)
+            return m_entry_sp;
+        return m_entry_sp->GetChildMemberWithName(ConstString("__left_"), true);
+    }
+    
+    ValueObjectSP
+    right ()
+    {
+        if (!m_entry_sp)
+            return m_entry_sp;
+        return m_entry_sp->GetChildMemberWithName(ConstString("__right_"), true);
+    }
+    
+    ValueObjectSP
+    parent ()
+    {
+        if (!m_entry_sp)
+            return m_entry_sp;
+        return m_entry_sp->GetChildMemberWithName(ConstString("__parent_"), true);
+    }
+    
+    uint64_t
+    value ()
+    {
+        if (!m_entry_sp)
+            return 0;
+        return m_entry_sp->GetValueAsUnsigned(0);
+    }
+    
+    bool
+    error ()
+    {
+        if (!m_entry_sp)
+            return true;
+        return m_entry_sp->GetError().Fail();
+    }
+    
+    bool
+    null()
+    {
+        return (value() == 0);
+    }
+    
+    ValueObjectSP
+    GetEntry ()
+    {
+        return m_entry_sp;
+    }
+    
+    void
+    SetEntry (ValueObjectSP entry)
+    {
+        m_entry_sp = entry;
+    }
+    
+    bool
+    operator == (const MapEntry& rhs) const
+    {
+        return (rhs.m_entry_sp.get() == m_entry_sp.get());
+    }
+    
+private:
+    ValueObjectSP m_entry_sp;
+};
+
+class MapIterator
+{
+public:
+    MapIterator () {}
+    MapIterator (MapEntry entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
+    MapIterator (ValueObjectSP entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
+    MapIterator (const MapIterator& rhs) : m_entry(rhs.m_entry),m_max_depth(rhs.m_max_depth), m_error(false) {}
+    MapIterator (ValueObject* entry, size_t depth = 0) : m_entry(entry), m_max_depth(depth), m_error(false) {}
+    
+    ValueObjectSP
+    value ()
+    {
+        return m_entry.GetEntry();
+    }
+    
+    ValueObjectSP
+    advance (size_t count)
+    {
+        if (m_error)
+            return lldb::ValueObjectSP();
+        if (count == 0)
+            return m_entry.GetEntry();
+        if (count == 1)
+        {
+            next ();
+            return m_entry.GetEntry();
+        }
+        size_t steps = 0;
+        while (count > 0)
+        {
+            if (m_error)
+                return lldb::ValueObjectSP();
+            next ();
+            count--;
+            if (m_entry.null())
+                return lldb::ValueObjectSP();
+            steps++;
+            if (steps > m_max_depth)
+                return lldb::ValueObjectSP();
+        }
+        return m_entry.GetEntry();
+    }
+protected:
+    void
+    next ()
+    {
+        m_entry.SetEntry(increment(m_entry.GetEntry()));
+    }
+
+private:
+    ValueObjectSP
+    tree_min (ValueObjectSP x_sp)
+    {
+        MapEntry x(x_sp);
+        if (x.null())
+            return ValueObjectSP();
+        MapEntry left(x.left());
+        size_t steps = 0;
+        while (left.null() == false)
+        {
+            if (left.error())
+            {
+                m_error = true;
+                return lldb::ValueObjectSP();
+            }
+            x.SetEntry(left.GetEntry());
+            left.SetEntry(x.left());
+            steps++;
+            if (steps > m_max_depth)
+                return lldb::ValueObjectSP();
+        }
+        return x.GetEntry();
+    }
+    
+    ValueObjectSP
+    tree_max (ValueObjectSP x_sp)
+    {
+        MapEntry x(x_sp);
+        if (x.null())
+            return ValueObjectSP();
+        MapEntry right(x.right());
+        size_t steps = 0;
+        while (right.null() == false)
+        {
+            if (right.error())
+                return lldb::ValueObjectSP();
+            x.SetEntry(right.GetEntry());
+            right.SetEntry(x.right());
+            steps++;
+            if (steps > m_max_depth)
+                return lldb::ValueObjectSP();
+        }
+        return x.GetEntry();
+    }
+    
+    bool
+    is_left_child (ValueObjectSP x_sp)
+    {
+        MapEntry x(x_sp);
+        if (x.null())
+            return false;
+        MapEntry rhs(x.parent());
+        rhs.SetEntry(rhs.left());
+        return x.value() == rhs.value();
+    }
+    
+    ValueObjectSP
+    increment (ValueObjectSP x_sp)
+    {
+        MapEntry node(x_sp);
+        if (node.null())
+            return ValueObjectSP();
+        MapEntry right(node.right());
+        if (right.null() == false)
+            return tree_min(right.GetEntry());
+        size_t steps = 0;
+        while (!is_left_child(node.GetEntry()))
+        {
+            if (node.error())
+            {
+                m_error = true;
+                return lldb::ValueObjectSP();
+            }
+            node.SetEntry(node.parent());
+            steps++;
+            if (steps > m_max_depth)
+                return lldb::ValueObjectSP();
+        }
+        return node.parent();
+    }
+        
+    MapEntry m_entry;
+    size_t m_max_depth;
+    bool m_error;
+};
+
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_tree(NULL),
+m_root_node(NULL),
+m_element_type(),
+m_skip_size(UINT32_MAX),
+m_count(UINT32_MAX),
+m_children()
+{
+    if (valobj_sp)
+        Update();
+}
+
+size_t
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (m_count != UINT32_MAX)
+        return m_count;
+    if (m_tree == NULL)
+        return 0;
+    ValueObjectSP m_item(m_tree->GetChildMemberWithName(ConstString("__pair3_"), true));
+    if (!m_item)
+        return 0;
+    m_item = m_item->GetChildMemberWithName(ConstString("__first_"), true);
+    if (!m_item)
+        return 0;
+    m_count = m_item->GetValueAsUnsigned(0);
+    return m_count;
+}
+
+bool
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType()
+{
+    if (m_element_type.GetOpaqueQualType() && m_element_type.GetASTContext())
+        return true;
+    m_element_type.Clear();
+    ValueObjectSP deref;
+    Error error;
+    deref = m_root_node->Dereference(error);
+    if (!deref || error.Fail())
+        return false;
+    deref = deref->GetChildMemberWithName(ConstString("__value_"), true);
+    if (!deref)
+        return false;
+    m_element_type = deref->GetClangType();
+    return true;
+}
+
+void
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset (const lldb::ValueObjectSP& node)
+{
+    if (m_skip_size != UINT32_MAX)
+        return;
+    if (!node)
+        return;
+    ClangASTType node_type(node->GetClangType());
+    uint64_t bit_offset;
+    if (node_type.GetIndexOfFieldWithName("__value_", NULL, &bit_offset) == UINT32_MAX)
+        return;
+    m_skip_size = bit_offset / 8u;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx >= CalculateNumChildren())
+        return lldb::ValueObjectSP();
+    if (m_tree == NULL || m_root_node == NULL)
+        return lldb::ValueObjectSP();
+    
+    auto cached = m_children.find(idx);
+    if (cached != m_children.end())
+        return cached->second;
+    
+    bool need_to_skip = (idx > 0);
+    MapIterator iterator(m_root_node, CalculateNumChildren());
+    ValueObjectSP iterated_sp(iterator.advance(idx));
+    if (iterated_sp.get() == NULL)
+    {
+        // this tree is garbage - stop
+        m_tree = NULL; // this will stop all future searches until an Update() happens
+        return iterated_sp;
+    }
+    if (GetDataType())
+    {
+        if (!need_to_skip)
+        {
+            Error error;
+            iterated_sp = iterated_sp->Dereference(error);
+            if (!iterated_sp || error.Fail())
+            {
+                m_tree = NULL;
+                return lldb::ValueObjectSP();
+            }
+            GetValueOffset(iterated_sp);
+            iterated_sp = iterated_sp->GetChildMemberWithName(ConstString("__value_"), true);
+            if (!iterated_sp)
+            {
+                m_tree = NULL;
+                return lldb::ValueObjectSP();
+            }
+        }
+        else
+        {
+            // because of the way our debug info is made, we need to read item 0 first
+            // so that we can cache information used to generate other elements
+            if (m_skip_size == UINT32_MAX)
+                GetChildAtIndex(0);
+            if (m_skip_size == UINT32_MAX)
+            {
+                m_tree = NULL;
+                return lldb::ValueObjectSP();
+            }
+            iterated_sp = iterated_sp->GetSyntheticChildAtOffset(m_skip_size, m_element_type, true);
+            if (!iterated_sp)
+            {
+                m_tree = NULL;
+                return lldb::ValueObjectSP();
+            }
+        }
+    }
+    else
+    {
+        m_tree = NULL;
+        return lldb::ValueObjectSP();
+    }
+    // at this point we have a valid 
+    // we need to copy current_sp into a new object otherwise we will end up with all items named __value_
+    DataExtractor data;
+    iterated_sp->GetData(data);
+    StreamString name;
+    name.Printf("[%zu]",idx);
+    return (m_children[idx] = ValueObject::CreateValueObjectFromData(name.GetData(), data, m_backend.GetExecutionContextRef(), m_element_type));
+}
+
+bool
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update()
+{
+    m_count = UINT32_MAX;
+    m_tree = m_root_node = NULL;
+    m_children.clear();
+    m_tree = m_backend.GetChildMemberWithName(ConstString("__tree_"), true).get();
+    if (!m_tree)
+        return false;
+    m_root_node = m_tree->GetChildMemberWithName(ConstString("__begin_node_"), true).get();
+    return false;
+}
+
+bool
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    return ExtractIndexFromString(name.GetCString());
+}
+
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::~LibcxxStdMapSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibcxxStdMapSyntheticFrontEnd(valobj_sp));
+}
diff --git a/source/DataFormatters/LibStdcpp.cpp b/source/DataFormatters/LibStdcpp.cpp
new file mode 100644
index 0000000..e0f23cc
--- /dev/null
+++ b/source/DataFormatters/LibStdcpp.cpp
@@ -0,0 +1,331 @@
+//===-- LibStdcpp.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::LibstdcppVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_count(0),
+m_base_data_address(0),
+m_options()
+{
+    if (valobj_sp)
+        Update();
+    m_options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+}
+
+size_t
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return m_count;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx >= m_count)
+        return ValueObjectSP();
+    if (m_base_data_address == 0 || m_count == 0)
+        return ValueObjectSP();
+    size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
+    size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
+    lldb::addr_t byte_location = m_base_data_address + byte_idx;
+    ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
+    if (!process_sp)
+        return ValueObjectSP();
+    uint8_t byte = 0;
+    uint8_t mask = 0;
+    Error err;
+    size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
+    if (err.Fail() || bytes_read == 0)
+        return ValueObjectSP();
+    switch (bit_index)
+    {
+        case 0:
+            mask = 1; break;
+        case 1:
+            mask = 2; break;
+        case 2:
+            mask = 4; break;
+        case 3:
+            mask = 8; break;
+        case 4:
+            mask = 16; break;
+        case 5:
+            mask = 32; break;
+        case 6:
+            mask = 64; break;
+        case 7:
+            mask = 128; break;
+        default:
+            return ValueObjectSP();
+    }
+    bool bit_set = ((byte & mask) != 0);
+    Target& target(process_sp->GetTarget());
+    ValueObjectSP retval_sp;
+    if (bit_set)
+        target.EvaluateExpression("(bool)true", NULL, retval_sp);
+    else
+        target.EvaluateExpression("(bool)false", NULL, retval_sp);
+    StreamString name; name.Printf("[%zu]",idx);
+    if (retval_sp)
+        retval_sp->SetName(ConstString(name.GetData()));
+    return retval_sp;
+}
+
+/*((std::vector<std::allocator<bool> >) vBool = {
+ (std::_Bvector_base<std::allocator<bool> >) std::_Bvector_base<std::allocator<bool> > = {
+ (std::_Bvector_base<std::allocator<bool> >::_Bvector_impl) _M_impl = {
+ (std::_Bit_iterator) _M_start = {
+ (std::_Bit_iterator_base) std::_Bit_iterator_base = {
+ (_Bit_type *) _M_p = 0x0016b160
+ (unsigned int) _M_offset = 0
+ }
+ }
+ (std::_Bit_iterator) _M_finish = {
+ (std::_Bit_iterator_base) std::_Bit_iterator_base = {
+ (_Bit_type *) _M_p = 0x0016b16c
+ (unsigned int) _M_offset = 16
+ }
+ }
+ (_Bit_type *) _M_end_of_storage = 0x0016b170
+ }
+ }
+ }
+ */
+
+bool
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::Update()
+{
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    
+    ValueObjectSP m_impl_sp(valobj_sp->GetChildMemberWithName(ConstString("_M_impl"), true));
+    if (!m_impl_sp)
+        return false;
+    
+    ValueObjectSP m_start_sp(m_impl_sp->GetChildMemberWithName(ConstString("_M_start"), true));
+    ValueObjectSP m_finish_sp(m_impl_sp->GetChildMemberWithName(ConstString("_M_finish"), true));
+    
+    ValueObjectSP start_p_sp, finish_p_sp, finish_offset_sp;
+    
+    if (!m_start_sp || !m_finish_sp)
+        return false;
+    
+    start_p_sp = m_start_sp->GetChildMemberWithName(ConstString("_M_p"), true);
+    finish_p_sp = m_finish_sp->GetChildMemberWithName(ConstString("_M_p"), true);
+    finish_offset_sp = m_finish_sp->GetChildMemberWithName(ConstString("_M_offset"), true);
+    
+    if (!start_p_sp || !finish_offset_sp || !finish_p_sp)
+        return false;
+    
+    m_base_data_address = start_p_sp->GetValueAsUnsigned(0);
+    if (!m_base_data_address)
+        return false;
+    
+    lldb::addr_t end_data_address(finish_p_sp->GetValueAsUnsigned(0));
+    if (!end_data_address)
+        return false;
+    
+    if (end_data_address < m_base_data_address)
+        return false;
+    else
+        m_count = finish_offset_sp->GetValueAsUnsigned(0) + (end_data_address-m_base_data_address)*8;
+    
+    return true;
+}
+
+bool
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (!m_count || !m_base_data_address)
+        return UINT32_MAX;
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEnd::~LibstdcppVectorBoolSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibstdcppVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibstdcppVectorBoolSyntheticFrontEnd(valobj_sp));
+}
+
+/*
+ (std::_Rb_tree_iterator<std::pair<const int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >) ibeg = {
+ (_Base_ptr) _M_node = 0x0000000100103910 {
+ (std::_Rb_tree_color) _M_color = _S_black
+ (std::_Rb_tree_node_base::_Base_ptr) _M_parent = 0x00000001001038c0
+ (std::_Rb_tree_node_base::_Base_ptr) _M_left = 0x0000000000000000
+ (std::_Rb_tree_node_base::_Base_ptr) _M_right = 0x0000000000000000
+ }
+ }
+ */
+
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+    SyntheticChildrenFrontEnd(*valobj_sp.get()),
+    m_exe_ctx_ref(),
+    m_pair_address(0),
+    m_pair_type(),
+    m_options(),
+    m_pair_sp()
+{
+    if (valobj_sp)
+        Update();
+    m_options.SetCoerceToId(false)
+    .SetUnwindOnError(true)
+    .SetKeepInMemory(true)
+    .SetUseDynamic(lldb::eDynamicCanRunTarget);
+}
+
+bool
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::Update()
+{
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    
+    TargetSP target_sp(valobj_sp->GetTargetSP());
+    
+    if (!target_sp)
+        return false;
+    
+    bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
+    
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    
+    ValueObjectSP _M_node_sp(valobj_sp->GetChildMemberWithName(ConstString("_M_node"), true));
+    if (!_M_node_sp)
+        return false;
+    
+    m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
+    if (m_pair_address == 0)
+        return false;
+    
+    m_pair_address += (is_64bit ? 32 : 16);
+    
+    ClangASTType my_type(valobj_sp->GetClangType());
+    if (my_type.GetNumTemplateArguments() >= 1)
+    {
+        TemplateArgumentKind kind;
+        ClangASTType pair_type = my_type.GetTemplateArgument(0, kind);
+        if (kind != eTemplateArgumentKindType && kind != eTemplateArgumentKindTemplate && kind != eTemplateArgumentKindTemplateExpansion)
+            return false;
+        m_pair_type = pair_type;
+    }
+    else
+        return false;
+    
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::CalculateNumChildren ()
+{
+    return 2;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (m_pair_address != 0 && m_pair_type)
+    {
+        if (!m_pair_sp)
+            m_pair_sp = ValueObject::CreateValueObjectFromAddress("pair", m_pair_address, m_exe_ctx_ref, m_pair_type);
+        if (m_pair_sp)
+            return m_pair_sp->GetChildAtIndex(idx, true);
+    }
+    return lldb::ValueObjectSP();
+}
+
+bool
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (name == ConstString("first"))
+        return 0;
+    if (name == ConstString("second"))
+        return 1;
+    return UINT32_MAX;
+}
+
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEnd::~LibstdcppMapIteratorSyntheticFrontEnd ()
+{}
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    if (!valobj_sp)
+        return NULL;
+    return (new LibstdcppMapIteratorSyntheticFrontEnd(valobj_sp));
+}
+
+/*
+ (lldb) fr var ibeg --ptr-depth 1
+ (__gnu_cxx::__normal_iterator<int *, std::vector<int, std::allocator<int> > >) ibeg = {
+ _M_current = 0x00000001001037a0 {
+ *_M_current = 1
+ }
+ }
+ */
+
+SyntheticChildrenFrontEnd*
+lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    static ConstString g_item_name;
+    if (!g_item_name)
+        g_item_name.SetCString("_M_current");
+    if (!valobj_sp)
+        return NULL;
+    return (new VectorIteratorSyntheticFrontEnd(valobj_sp,g_item_name));
+}
diff --git a/source/DataFormatters/NSArray.cpp b/source/DataFormatters/NSArray.cpp
new file mode 100644
index 0000000..d8ee9bf
--- /dev/null
+++ b/source/DataFormatters/NSArray.cpp
@@ -0,0 +1,371 @@
+//===-- NSArray.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+bool
+lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint64_t value = 0;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"__NSArrayI"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    else if (!strcmp(class_name,"__NSArrayM"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    else if (!strcmp(class_name,"__NSCFArray"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + 2 * ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+    }
+    else
+    {
+        if (!ExtractValueFromObjCExpression(valobj, "int", "count", value))
+            return false;
+    }
+    
+    stream.Printf("@\"%" PRIu64 " object%s\"",
+                  value,
+                  value == 1 ? "" : "s");
+    return true;
+}
+
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+    SyntheticChildrenFrontEnd(*valobj_sp.get()),
+    m_exe_ctx_ref(),
+    m_ptr_size(8),
+    m_data_32(NULL),
+    m_data_64(NULL)
+{
+    if (valobj_sp)
+    {
+        clang::ASTContext *ast = valobj_sp->GetClangType().GetASTContext();
+        if (ast)
+            m_id_type = ClangASTType(ast, ast->ObjCBuiltinIdTy);
+    }
+}
+
+size_t
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (m_data_32)
+        return m_data_32->_used;
+    if (m_data_64)
+        return m_data_64->_used;
+    return 0;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (!m_data_32 && !m_data_64)
+        return lldb::ValueObjectSP();
+    if (idx >= CalculateNumChildren())
+        return lldb::ValueObjectSP();
+    lldb::addr_t object_at_idx = (m_data_32 ? m_data_32->_data : m_data_64->_data);
+    size_t pyhs_idx = idx;
+    pyhs_idx += (m_data_32 ? m_data_32->offset : m_data_64->offset);
+    if ((m_data_32 ? m_data_32->_size : m_data_64->_size) <= pyhs_idx)
+        pyhs_idx -= (m_data_32 ? m_data_32->_size : m_data_64->_size);
+    object_at_idx += (pyhs_idx * m_ptr_size);
+    StreamString idx_name;
+    idx_name.Printf("[%zu]",idx);
+    lldb::ValueObjectSP retval_sp = ValueObject::CreateValueObjectFromAddress(idx_name.GetData(),
+                                                                              object_at_idx,
+                                                                              m_exe_ctx_ref,
+                                                                              m_id_type);
+    m_children.push_back(retval_sp);
+    return retval_sp;
+}
+
+bool
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::Update()
+{
+    m_children.clear();
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    m_ptr_size = 0;
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
+    if (m_ptr_size == 4)
+    {
+        m_data_32 = new DataDescriptor_32();
+        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
+    }
+    else
+    {
+        m_data_64 = new DataDescriptor_64();
+        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
+    }
+    if (error.Fail())
+        return false;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    if (!m_data_32 && !m_data_64)
+        return UINT32_MAX;
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+lldb_private::formatters::NSArrayMSyntheticFrontEnd::~NSArrayMSyntheticFrontEnd ()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
+lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+    SyntheticChildrenFrontEnd (*valobj_sp.get()),
+    m_exe_ctx_ref (),
+    m_ptr_size (8),
+    m_items (0),
+    m_data_ptr (0)
+{
+    if (valobj_sp)
+    {
+        clang::ASTContext *ast = valobj_sp->GetClangType().GetASTContext();
+        if (ast)
+            m_id_type = ClangASTType(ast, ast->ObjCBuiltinIdTy);
+    }
+}
+
+lldb_private::formatters::NSArrayISyntheticFrontEnd::~NSArrayISyntheticFrontEnd ()
+{
+}
+
+size_t
+lldb_private::formatters::NSArrayISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+size_t
+lldb_private::formatters::NSArrayISyntheticFrontEnd::CalculateNumChildren ()
+{
+    return m_items;
+}
+
+bool
+lldb_private::formatters::NSArrayISyntheticFrontEnd::Update()
+{
+    m_ptr_size = 0;
+    m_items = 0;
+    m_data_ptr = 0;
+    m_children.clear();
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
+    m_items = process_sp->ReadPointerFromMemory(data_location, error);
+    if (error.Fail())
+        return false;
+    m_data_ptr = data_location+m_ptr_size;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSArrayISyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (idx >= CalculateNumChildren())
+        return lldb::ValueObjectSP();
+    lldb::addr_t object_at_idx = m_data_ptr;
+    object_at_idx += (idx * m_ptr_size);
+    ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+    if (!process_sp)
+        return lldb::ValueObjectSP();
+    Error error;
+    if (error.Fail())
+        return lldb::ValueObjectSP();
+    StreamString idx_name;
+    idx_name.Printf("[%zu]",idx);
+    lldb::ValueObjectSP retval_sp = ValueObject::CreateValueObjectFromAddress(idx_name.GetData(), object_at_idx, m_exe_ctx_ref, m_id_type);
+    m_children.push_back(retval_sp);
+    return retval_sp;
+}
+
+SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return NULL;
+    ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    if (!runtime)
+        return NULL;
+    
+    if (!valobj_sp->IsPointerType())
+    {
+        Error error;
+        valobj_sp = valobj_sp->AddressOf(error);
+        if (error.Fail() || !valobj_sp)
+            return NULL;
+    }
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return NULL;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return NULL;
+    
+    if (!strcmp(class_name,"__NSArrayI"))
+    {
+        return (new NSArrayISyntheticFrontEnd(valobj_sp));
+    }
+    else if (!strcmp(class_name,"__NSArrayM"))
+    {
+        return (new NSArrayMSyntheticFrontEnd(valobj_sp));
+    }
+    else
+    {
+        return (new NSArrayCodeRunningSyntheticFrontEnd(valobj_sp));
+    }
+}
+
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get())
+{}
+
+size_t
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::CalculateNumChildren ()
+{
+    uint64_t count = 0;
+    if (ExtractValueFromObjCExpression(m_backend, "int", "count", count))
+        return count;
+    return 0;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    StreamString idx_name;
+    idx_name.Printf("[%zu]",idx);
+    lldb::ValueObjectSP valobj_sp = CallSelectorOnObject(m_backend,"id","objectAtIndex:",idx);
+    if (valobj_sp)
+        valobj_sp->SetName(ConstString(idx_name.GetData()));
+    return valobj_sp;
+}
+
+bool
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::Update()
+{
+    return false;
+}
+
+bool
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    return 0;
+}
+
+lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::~NSArrayCodeRunningSyntheticFrontEnd ()
+{}
diff --git a/source/DataFormatters/NSDictionary.cpp b/source/DataFormatters/NSDictionary.cpp
new file mode 100644
index 0000000..05a5dda
--- /dev/null
+++ b/source/DataFormatters/NSDictionary.cpp
@@ -0,0 +1,579 @@
+//===-- NSDictionary.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+#include "clang/AST/DeclCXX.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+static ClangASTType
+GetLLDBNSPairType (TargetSP target_sp)
+{
+    ClangASTType clang_type;
+
+    ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext();
+
+    if (target_ast_context)
+    {
+        clang::ASTContext *ast = target_ast_context->getASTContext();
+
+        if (ast)
+        {
+            const char* type_name = "__lldb_autogen_nspair";
+            
+            clang::IdentifierInfo &myIdent = ast->Idents.get(type_name);
+            clang::DeclarationName myName = ast->DeclarationNames.getIdentifier(&myIdent);
+
+            clang::DeclContext::lookup_const_result result = ast->getTranslationUnitDecl()->lookup(myName);
+
+            for (clang::NamedDecl *named_decl : result)
+            {
+                if (const clang::CXXRecordDecl *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(named_decl))
+                {
+                    clang_type.SetClangType(ast, clang::QualType(record_decl->getTypeForDecl(), 0));
+                    break;
+                }
+                else
+                {
+                    // somebody else (the user?) has defined a type with the magic name already - fail!!!
+                    return clang_type;
+                }
+            }
+
+            if (!clang_type)
+            {
+                clang_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, type_name, clang::TTK_Struct, lldb::eLanguageTypeC);
+                
+                if (clang_type)
+                {
+                    clang_type.StartTagDeclarationDefinition();
+                    ClangASTType id_clang_type = target_ast_context->GetBasicType (eBasicTypeObjCID);
+                    clang_type.AddFieldToRecordType("key", id_clang_type, lldb::eAccessPublic, 0);
+                    clang_type.AddFieldToRecordType("value", id_clang_type, lldb::eAccessPublic, 0);
+                    clang_type.CompleteTagDeclarationDefinition();
+                }
+            }
+        }
+    }
+    return clang_type;
+}
+
+template<bool name_entries>
+bool
+lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    bool is_64bit = (ptr_size == 8);
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint64_t value = 0;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"__NSDictionaryI"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
+    }
+    else if (!strcmp(class_name,"__NSDictionaryM"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
+    }
+    /*else if (!strcmp(class_name,"__NSCFDictionary"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error);
+        if (error.Fail())
+            return false;
+        if (is_64bit)
+            value &= ~0x0f1f000000000000UL;
+    }*/
+    else
+    {
+        if (!ExtractValueFromObjCExpression(valobj, "int", "count", value))
+            return false;
+    }
+    
+    stream.Printf("%s%" PRIu64 " %s%s",
+                  (name_entries ? "@\"" : ""),
+                  value,
+                  (name_entries ? (value == 1 ? "entry" : "entries") : (value == 1 ? "key/value pair" : "key/value pairs")),
+                  (name_entries ? "\"" : ""));
+    return true;
+}
+
+SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    
+    lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return NULL;
+    ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    if (!runtime)
+        return NULL;
+    
+    if (!valobj_sp->IsPointerType())
+    {
+        Error error;
+        valobj_sp = valobj_sp->AddressOf(error);
+        if (error.Fail() || !valobj_sp)
+            return NULL;
+    }
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return NULL;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return NULL;
+    
+    if (!strcmp(class_name,"__NSDictionaryI"))
+    {
+        return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
+    }
+    else if (!strcmp(class_name,"__NSDictionaryM"))
+    {
+        return (new NSDictionaryMSyntheticFrontEnd(valobj_sp));
+    }
+    else
+    {
+        return (new NSDictionaryCodeRunningSyntheticFrontEnd(valobj_sp));
+    }
+}
+
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get())
+{}
+
+size_t
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::CalculateNumChildren ()
+{
+    uint64_t count = 0;
+    if (ExtractValueFromObjCExpression(m_backend, "int", "count", count))
+        return count;
+    return 0;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    StreamString idx_name;
+    idx_name.Printf("[%zu]",idx);
+    StreamString key_fetcher_expr;
+    key_fetcher_expr.Printf("(id)[(NSArray*)[(id)0x%" PRIx64 " allKeys] objectAtIndex:%zu]",m_backend.GetPointerValue(),idx);
+    StreamString value_fetcher_expr;
+    value_fetcher_expr.Printf("(id)[(id)0x%" PRIx64 " objectForKey:(%s)]",m_backend.GetPointerValue(),key_fetcher_expr.GetData());
+    StreamString object_fetcher_expr;
+    object_fetcher_expr.Printf("struct __lldb_autogen_nspair { id key; id value; } _lldb_valgen_item; _lldb_valgen_item.key = %s; _lldb_valgen_item.value = %s; _lldb_valgen_item;",key_fetcher_expr.GetData(),value_fetcher_expr.GetData());
+    lldb::ValueObjectSP child_sp;
+    m_backend.GetTargetSP()->EvaluateExpression(object_fetcher_expr.GetData(), m_backend.GetFrameSP().get(), child_sp,
+                                                EvaluateExpressionOptions().SetKeepInMemory(true));
+    if (child_sp)
+        child_sp->SetName(ConstString(idx_name.GetData()));
+    return child_sp;
+}
+
+bool
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::Update()
+{
+    return false;
+}
+
+bool
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    return 0;
+}
+
+lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::~NSDictionaryCodeRunningSyntheticFrontEnd ()
+{}
+
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_ptr_size(8),
+m_order(lldb::eByteOrderInvalid),
+m_data_32(NULL),
+m_data_64(NULL),
+m_pair_type()
+{
+}
+
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd ()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
+size_t
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+size_t
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (!m_data_32 && !m_data_64)
+        return 0;
+    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
+}
+
+bool
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update()
+{
+    m_children.clear();
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+    m_ptr_size = 0;
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    m_order = process_sp->GetByteOrder();
+    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
+    if (m_ptr_size == 4)
+    {
+        m_data_32 = new DataDescriptor_32();
+        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
+    }
+    else
+    {
+        m_data_64 = new DataDescriptor_64();
+        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
+    }
+    if (error.Fail())
+        return false;
+    m_data_ptr = data_location + m_ptr_size;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    uint32_t num_children = CalculateNumChildren();
+    
+    if (idx >= num_children)
+        return lldb::ValueObjectSP();
+    
+    if (m_children.empty())
+    {
+        // do the scan phase
+        lldb::addr_t key_at_idx = 0, val_at_idx = 0;
+        
+        uint32_t tries = 0;
+        uint32_t test_idx = 0;
+        
+        while(tries < num_children)
+        {
+            key_at_idx = m_data_ptr + (2*test_idx * m_ptr_size);
+            val_at_idx = key_at_idx + m_ptr_size;
+            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+            if (!process_sp)
+                return lldb::ValueObjectSP();
+            Error error;
+            key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            
+            test_idx++;
+            
+            if (!key_at_idx || !val_at_idx)
+                continue;
+            tries++;
+            
+            DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()};
+            
+            m_children.push_back(descriptor);
+        }
+    }
+    
+    if (idx >= m_children.size()) // should never happen
+        return lldb::ValueObjectSP();
+    
+    DictionaryItemDescriptor &dict_item = m_children[idx];
+    if (!dict_item.valobj_sp)
+    {
+        if (!m_pair_type.IsValid())
+        {
+            TargetSP target_sp(m_backend.GetTargetSP());
+            if (!target_sp)
+                return ValueObjectSP();
+            m_pair_type = GetLLDBNSPairType(target_sp);
+        }
+        if (!m_pair_type.IsValid())
+            return ValueObjectSP();
+        
+        DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0));
+        
+        if (m_ptr_size == 8)
+        {
+            uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
+            *data_ptr = dict_item.key_ptr;
+            *(data_ptr+1) = dict_item.val_ptr;
+        }
+        else
+        {
+            uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
+            *data_ptr = dict_item.key_ptr;
+            *(data_ptr+1) = dict_item.val_ptr;
+        }
+        
+        StreamString idx_name;
+        idx_name.Printf("[%zu]",idx);
+        DataExtractor data(buffer_sp, m_order, m_ptr_size);
+        dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type);
+    }
+    return dict_item.valobj_sp;
+}
+
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_ptr_size(8),
+m_order(lldb::eByteOrderInvalid),
+m_data_32(NULL),
+m_data_64(NULL),
+m_pair_type()
+{
+}
+
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd ()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
+size_t
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+size_t
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (!m_data_32 && !m_data_64)
+        return 0;
+    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
+}
+
+bool
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::Update()
+{
+    m_children.clear();
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    m_ptr_size = 0;
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    m_order = process_sp->GetByteOrder();
+    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
+    if (m_ptr_size == 4)
+    {
+        m_data_32 = new DataDescriptor_32();
+        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
+    }
+    else
+    {
+        m_data_64 = new DataDescriptor_64();
+        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
+    }
+    if (error.Fail())
+        return false;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    lldb::addr_t m_keys_ptr = (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr);
+    lldb::addr_t m_values_ptr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
+    
+    uint32_t num_children = CalculateNumChildren();
+    
+    if (idx >= num_children)
+        return lldb::ValueObjectSP();
+    
+    if (m_children.empty())
+    {
+        // do the scan phase
+        lldb::addr_t key_at_idx = 0, val_at_idx = 0;
+        
+        uint32_t tries = 0;
+        uint32_t test_idx = 0;
+        
+        while(tries < num_children)
+        {
+            key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
+            val_at_idx = m_values_ptr + (test_idx * m_ptr_size);;
+            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+            if (!process_sp)
+                return lldb::ValueObjectSP();
+            Error error;
+            key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            
+            test_idx++;
+            
+            if (!key_at_idx || !val_at_idx)
+                continue;
+            tries++;
+            
+            DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()};
+            
+            m_children.push_back(descriptor);
+        }
+    }
+    
+    if (idx >= m_children.size()) // should never happen
+        return lldb::ValueObjectSP();
+    
+    DictionaryItemDescriptor &dict_item = m_children[idx];
+    if (!dict_item.valobj_sp)
+    {
+        if (!m_pair_type.IsValid())
+        {
+            TargetSP target_sp(m_backend.GetTargetSP());
+            if (!target_sp)
+                return ValueObjectSP();
+            m_pair_type = GetLLDBNSPairType(target_sp);
+        }
+        if (!m_pair_type.IsValid())
+            return ValueObjectSP();
+        
+        DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0));
+        
+        if (m_ptr_size == 8)
+        {
+            uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
+            *data_ptr = dict_item.key_ptr;
+            *(data_ptr+1) = dict_item.val_ptr;
+        }
+        else
+        {
+            uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
+            *data_ptr = dict_item.key_ptr;
+            *(data_ptr+1) = dict_item.val_ptr;
+        }
+        
+        StreamString idx_name;
+        idx_name.Printf("[%zu]",idx);
+        DataExtractor data(buffer_sp, m_order, m_ptr_size);
+        dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type);
+    }
+    return dict_item.valobj_sp;
+}
+
+template bool
+lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ;
+
+template bool
+lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ;
diff --git a/source/DataFormatters/NSSet.cpp b/source/DataFormatters/NSSet.cpp
new file mode 100644
index 0000000..02eb2bf
--- /dev/null
+++ b/source/DataFormatters/NSSet.cpp
@@ -0,0 +1,513 @@
+//===-- NSSet.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/lldb-python.h"
+
+#include "lldb/DataFormatters/CXXFormatterFunctions.h"
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Host/Endian.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+template<bool cf_style>
+bool
+lldb_private::formatters::NSSetSummaryProvider (ValueObject& valobj, Stream& stream)
+{
+    ProcessSP process_sp = valobj.GetProcessSP();
+    if (!process_sp)
+        return false;
+    
+    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    
+    if (!runtime)
+        return false;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return false;
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    bool is_64bit = (ptr_size == 8);
+    
+    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
+    
+    if (!valobj_addr)
+        return false;
+    
+    uint64_t value = 0;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return false;
+    
+    if (!strcmp(class_name,"__NSSetI"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
+    }
+    else if (!strcmp(class_name,"__NSSetM"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
+    }
+    /*else if (!strcmp(class_name,"__NSCFSet"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error);
+        if (error.Fail())
+            return false;
+        if (is_64bit)
+            value &= ~0x1fff000000000000UL;
+    }
+    else if (!strcmp(class_name,"NSCountedSet"))
+    {
+        Error error;
+        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
+        if (error.Fail())
+            return false;
+        value = process_sp->ReadUnsignedIntegerFromMemory(value + (is_64bit ? 20 : 12), 4, 0, error);
+        if (error.Fail())
+            return false;
+        if (is_64bit)
+            value &= ~0x1fff000000000000UL;
+    }*/
+    else
+    {
+        if (!ExtractValueFromObjCExpression(valobj, "int", "count", value))
+            return false;
+    }
+    
+    stream.Printf("%s%" PRIu64 " %s%s",
+                  (cf_style ? "@\"" : ""),
+                  value,
+                  (cf_style ? (value == 1 ? "value" : "values") : (value == 1 ? "object" : "objects")),
+                  (cf_style ? "\"" : ""));
+    return true;
+}
+
+SyntheticChildrenFrontEnd* lldb_private::formatters::NSSetSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
+{
+    lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return NULL;
+    ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
+    if (!runtime)
+        return NULL;
+    
+    if (!valobj_sp->IsPointerType())
+    {
+        Error error;
+        valobj_sp = valobj_sp->AddressOf(error);
+        if (error.Fail() || !valobj_sp)
+            return NULL;
+    }
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
+    
+    if (!descriptor.get() || !descriptor->IsValid())
+        return NULL;
+    
+    const char* class_name = descriptor->GetClassName().GetCString();
+    
+    if (!class_name || !*class_name)
+        return NULL;
+    
+    if (!strcmp(class_name,"__NSSetI"))
+    {
+        return (new NSSetISyntheticFrontEnd(valobj_sp));
+    }
+    else if (!strcmp(class_name,"__NSSetM"))
+    {
+        return (new NSSetMSyntheticFrontEnd(valobj_sp));
+    }
+    else if ((!strcmp(class_name,"__NSOrderedSetI")) || (!strcmp(class_name,"__NSOrderedSetM")))
+    {
+        return new NSOrderedSetSyntheticFrontEnd(valobj_sp); // this runs code
+    }
+    else
+    {
+        return /*(new NSSetCodeRunningSyntheticFrontEnd(valobj_sp))*/ NULL;
+    }
+}
+
+lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_ptr_size(8),
+m_data_32(NULL),
+m_data_64(NULL)
+{
+    if (valobj_sp)
+        Update();
+}
+
+lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd ()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
+size_t
+lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+size_t
+lldb_private::formatters::NSSetISyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (!m_data_32 && !m_data_64)
+        return 0;
+    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
+}
+
+bool
+lldb_private::formatters::NSSetISyntheticFrontEnd::Update()
+{
+    m_children.clear();
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+    m_ptr_size = 0;
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    if (!valobj_sp)
+        return false;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    if (valobj_sp->IsPointerType())
+    {
+        valobj_sp = valobj_sp->Dereference(error);
+        if (error.Fail() || !valobj_sp)
+            return false;
+    }
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size;
+    if (m_ptr_size == 4)
+    {
+        m_data_32 = new DataDescriptor_32();
+        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
+    }
+    else
+    {
+        m_data_64 = new DataDescriptor_64();
+        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
+    }
+    if (error.Fail())
+        return false;
+    m_data_ptr = data_location + m_ptr_size;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSSetISyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSSetISyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    uint32_t num_children = CalculateNumChildren();
+    
+    if (idx >= num_children)
+        return lldb::ValueObjectSP();
+    
+    if (m_children.empty())
+    {
+        // do the scan phase
+        lldb::addr_t obj_at_idx = 0;
+        
+        uint32_t tries = 0;
+        uint32_t test_idx = 0;
+        
+        while(tries < num_children)
+        {
+            obj_at_idx = m_data_ptr + (test_idx * m_ptr_size);
+            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+            if (!process_sp)
+                return lldb::ValueObjectSP();
+            Error error;
+            obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            
+            test_idx++;
+            
+            if (!obj_at_idx)
+                continue;
+            tries++;
+            
+            SetItemDescriptor descriptor = {obj_at_idx,lldb::ValueObjectSP()};
+            
+            m_children.push_back(descriptor);
+        }
+    }
+    
+    if (idx >= m_children.size()) // should never happen
+        return lldb::ValueObjectSP();
+    
+    SetItemDescriptor &set_item = m_children[idx];
+    if (!set_item.valobj_sp)
+    {
+        // make the new ValueObject
+        StreamString expr;
+        expr.Printf("(id)%" PRIu64,set_item.item_ptr);
+        StreamString idx_name;
+        idx_name.Printf("[%zu]",idx);
+        set_item.valobj_sp = ValueObject::CreateValueObjectFromExpression(idx_name.GetData(), expr.GetData(), m_exe_ctx_ref);
+    }
+    return set_item.valobj_sp;
+}
+
+lldb_private::formatters::NSSetMSyntheticFrontEnd::NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_exe_ctx_ref(),
+m_ptr_size(8),
+m_data_32(NULL),
+m_data_64(NULL)
+{
+    if (valobj_sp)
+        Update ();
+}
+
+lldb_private::formatters::NSSetMSyntheticFrontEnd::~NSSetMSyntheticFrontEnd ()
+{
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+}
+
+size_t
+lldb_private::formatters::NSSetMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+size_t
+lldb_private::formatters::NSSetMSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (!m_data_32 && !m_data_64)
+        return 0;
+    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
+}
+
+bool
+lldb_private::formatters::NSSetMSyntheticFrontEnd::Update()
+{
+    m_children.clear();
+    ValueObjectSP valobj_sp = m_backend.GetSP();
+    m_ptr_size = 0;
+    delete m_data_32;
+    m_data_32 = NULL;
+    delete m_data_64;
+    m_data_64 = NULL;
+    if (!valobj_sp)
+        return false;
+    if (!valobj_sp)
+        return false;
+    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
+    Error error;
+    if (valobj_sp->IsPointerType())
+    {
+        valobj_sp = valobj_sp->Dereference(error);
+        if (error.Fail() || !valobj_sp)
+            return false;
+    }
+    error.Clear();
+    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
+    if (!process_sp)
+        return false;
+    m_ptr_size = process_sp->GetAddressByteSize();
+    uint64_t data_location = valobj_sp->GetAddressOf() + m_ptr_size;
+    if (m_ptr_size == 4)
+    {
+        m_data_32 = new DataDescriptor_32();
+        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
+    }
+    else
+    {
+        m_data_64 = new DataDescriptor_64();
+        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
+    }
+    if (error.Fail())
+        return false;
+    return false;
+}
+
+bool
+lldb_private::formatters::NSSetMSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSSetMSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    lldb::addr_t m_objs_addr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
+
+    uint32_t num_children = CalculateNumChildren();
+    
+    if (idx >= num_children)
+        return lldb::ValueObjectSP();
+    
+    if (m_children.empty())
+    {
+        // do the scan phase
+        lldb::addr_t obj_at_idx = 0;
+        
+        uint32_t tries = 0;
+        uint32_t test_idx = 0;
+        
+        while(tries < num_children)
+        {
+            obj_at_idx = m_objs_addr + (test_idx * m_ptr_size);
+            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
+            if (!process_sp)
+                return lldb::ValueObjectSP();
+            Error error;
+            obj_at_idx = process_sp->ReadPointerFromMemory(obj_at_idx, error);
+            if (error.Fail())
+                return lldb::ValueObjectSP();
+            
+            test_idx++;
+            
+            if (!obj_at_idx)
+                continue;
+            tries++;
+            
+            SetItemDescriptor descriptor = {obj_at_idx,lldb::ValueObjectSP()};
+            
+            m_children.push_back(descriptor);
+        }
+    }
+    
+    if (idx >= m_children.size()) // should never happen
+        return lldb::ValueObjectSP();
+    
+    SetItemDescriptor &set_item = m_children[idx];
+    if (!set_item.valobj_sp)
+    {
+        // make the new ValueObject
+        StreamString expr;
+        expr.Printf("(id)%" PRIu64,set_item.item_ptr);
+        StreamString idx_name;
+        idx_name.Printf("[%zu]",idx);
+        set_item.valobj_sp = ValueObject::CreateValueObjectFromExpression(idx_name.GetData(), expr.GetData(), m_exe_ctx_ref);
+    }
+    return set_item.valobj_sp;
+}
+
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
+SyntheticChildrenFrontEnd(*valobj_sp.get()),
+m_count(UINT32_MAX),
+m_children()
+{}
+
+size_t
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::CalculateNumChildren ()
+{
+    if (m_count != UINT32_MAX)
+        return m_count;
+    uint64_t count_temp;
+    if (ExtractValueFromObjCExpression(m_backend,"unsigned int","count",count_temp))
+        return (m_count = count_temp);
+    return (m_count = 0);
+}
+
+lldb::ValueObjectSP
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetChildAtIndex (size_t idx)
+{
+    auto iter = m_children.find(idx);
+    if (iter == m_children.end())
+    {
+        lldb::ValueObjectSP retval_sp;
+        if (idx <= m_count)
+        {
+            retval_sp = CallSelectorOnObject(m_backend, "id", "objectAtIndex", idx);
+            if (retval_sp)
+            {
+                StreamString idx_name;
+                idx_name.Printf("[%zu]",idx);
+                retval_sp->SetName(ConstString(idx_name.GetData()));
+            }
+            m_children[idx] = retval_sp;
+        }
+        return retval_sp;
+    }
+    else
+        return iter->second;
+}
+
+bool
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::Update()
+{
+    return false;
+}
+
+bool
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::MightHaveChildren ()
+{
+    return true;
+}
+
+size_t
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
+{
+    const char* item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+        return UINT32_MAX;
+    return idx;
+}
+
+lldb_private::formatters::NSOrderedSetSyntheticFrontEnd::~NSOrderedSetSyntheticFrontEnd ()
+{
+}
+
+template bool
+lldb_private::formatters::NSSetSummaryProvider<true> (ValueObject& valobj, Stream& stream);
+
+template bool
+lldb_private::formatters::NSSetSummaryProvider<false> (ValueObject& valobj, Stream& stream);
diff --git a/source/DataFormatters/TypeCategory.cpp b/source/DataFormatters/TypeCategory.cpp
new file mode 100644
index 0000000..c887be5
--- /dev/null
+++ b/source/DataFormatters/TypeCategory.cpp
@@ -0,0 +1,382 @@
+//===-- TypeCategory.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/lldb-python.h"
+
+#include "lldb/DataFormatters/TypeCategory.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+using namespace lldb;
+using namespace lldb_private;
+
+TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener* clist,
+                                   ConstString name) :
+m_summary_nav(new SummaryNavigator("summary",clist)),
+m_regex_summary_nav(new RegexSummaryNavigator("regex-summary",clist)),
+m_filter_nav(new FilterNavigator("filter",clist)),
+m_regex_filter_nav(new RegexFilterNavigator("regex-filter",clist)),
+#ifndef LLDB_DISABLE_PYTHON
+m_synth_nav(new SynthNavigator("synth",clist)),
+m_regex_synth_nav(new RegexSynthNavigator("regex-synth",clist)),
+#endif
+m_enabled(false),
+m_change_listener(clist),
+m_mutex(Mutex::eMutexTypeRecursive),
+m_name(name)
+{}
+
+bool
+TypeCategoryImpl::Get (ValueObject& valobj,
+                       lldb::TypeSummaryImplSP& entry,
+                       lldb::DynamicValueType use_dynamic,
+                       uint32_t* reason)
+{
+    if (!IsEnabled())
+        return false;
+    if (GetSummaryNavigator()->Get(valobj, entry, use_dynamic, reason))
+        return true;
+    bool regex = GetRegexSummaryNavigator()->Get(valobj, entry, use_dynamic, reason);
+    if (regex && reason)
+        *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+    return regex;
+}
+
+bool
+TypeCategoryImpl::Get(ValueObject& valobj,
+                      lldb::SyntheticChildrenSP& entry_sp,
+                      lldb::DynamicValueType use_dynamic,
+                      uint32_t* reason)
+{
+    if (!IsEnabled())
+        return false;
+    TypeFilterImpl::SharedPointer filter_sp;
+    uint32_t reason_filter = 0;
+    bool regex_filter = false;
+    // first find both Filter and Synth, and then check which is most recent
+    
+    if (!GetFilterNavigator()->Get(valobj, filter_sp, use_dynamic, &reason_filter))
+        regex_filter = GetRegexFilterNavigator()->Get (valobj, filter_sp, use_dynamic, &reason_filter);
+    
+#ifndef LLDB_DISABLE_PYTHON
+    bool regex_synth = false;
+    uint32_t reason_synth = 0;
+    bool pick_synth = false;
+    ScriptedSyntheticChildren::SharedPointer synth;
+    if (!GetSyntheticNavigator()->Get(valobj, synth, use_dynamic, &reason_synth))
+        regex_synth = GetRegexSyntheticNavigator()->Get (valobj, synth, use_dynamic, &reason_synth);
+    if (!filter_sp.get() && !synth.get())
+        return false;
+    else if (!filter_sp.get() && synth.get())
+        pick_synth = true;
+    
+    else if (filter_sp.get() && !synth.get())
+        pick_synth = false;
+    
+    else /*if (filter_sp.get() && synth.get())*/
+    {
+        if (filter_sp->GetRevision() > synth->GetRevision())
+            pick_synth = false;
+        else
+            pick_synth = true;
+    }
+    if (pick_synth)
+    {
+        if (regex_synth && reason)
+            *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
+        entry_sp = synth;
+        return true;
+    }
+    else
+    {
+        if (regex_filter && reason)
+            *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
+        entry_sp = filter_sp;
+        return true;
+    }
+    
+#else
+    if (filter_sp)
+    {
+        entry_sp = filter_sp;
+        return true;
+    }
+#endif
+    
+    return false;
+    
+}
+
+void
+TypeCategoryImpl::Clear (FormatCategoryItems items)
+{
+    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
+        m_summary_nav->Clear();
+    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
+        m_regex_summary_nav->Clear();
+    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
+        m_filter_nav->Clear();
+    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
+        m_regex_filter_nav->Clear();
+#ifndef LLDB_DISABLE_PYTHON
+    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
+        m_synth_nav->Clear();
+    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
+        m_regex_synth_nav->Clear();
+#endif
+}
+
+bool
+TypeCategoryImpl::Delete (ConstString name,
+                          FormatCategoryItems items)
+{
+    bool success = false;
+    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
+        success = m_summary_nav->Delete(name) || success;
+    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
+        success = m_regex_summary_nav->Delete(name) || success;
+    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
+        success = m_filter_nav->Delete(name) || success;
+    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
+        success = m_regex_filter_nav->Delete(name) || success;
+#ifndef LLDB_DISABLE_PYTHON
+    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
+        success = m_synth_nav->Delete(name) || success;
+    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
+        success = m_regex_synth_nav->Delete(name) || success;
+#endif
+    return success;
+}
+
+uint32_t
+TypeCategoryImpl::GetCount (FormatCategoryItems items)
+{
+    uint32_t count = 0;
+    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
+        count += m_summary_nav->GetCount();
+    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
+        count += m_regex_summary_nav->GetCount();
+    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
+        count += m_filter_nav->GetCount();
+    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
+        count += m_regex_filter_nav->GetCount();
+#ifndef LLDB_DISABLE_PYTHON
+    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
+        count += m_synth_nav->GetCount();
+    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
+        count += m_regex_synth_nav->GetCount();
+#endif
+    return count;
+}
+
+bool
+TypeCategoryImpl::AnyMatches(ConstString type_name,
+                             FormatCategoryItems items,
+                             bool only_enabled,
+                             const char** matching_category,
+                             FormatCategoryItems* matching_type)
+{
+    if (!IsEnabled() && only_enabled)
+        return false;
+    
+    lldb::TypeSummaryImplSP summary;
+    TypeFilterImpl::SharedPointer filter;
+#ifndef LLDB_DISABLE_PYTHON
+    ScriptedSyntheticChildren::SharedPointer synth;
+#endif
+    
+    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
+    {
+        if (m_summary_nav->Get(type_name, summary))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemSummary;
+            return true;
+        }
+    }
+    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
+    {
+        if (m_regex_summary_nav->Get(type_name, summary))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemRegexSummary;
+            return true;
+        }
+    }
+    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
+    {
+        if (m_filter_nav->Get(type_name, filter))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemFilter;
+            return true;
+        }
+    }
+    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
+    {
+        if (m_regex_filter_nav->Get(type_name, filter))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemRegexFilter;
+            return true;
+        }
+    }
+#ifndef LLDB_DISABLE_PYTHON
+    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
+    {
+        if (m_synth_nav->Get(type_name, synth))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemSynth;
+            return true;
+        }
+    }
+    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
+    {
+        if (m_regex_synth_nav->Get(type_name, synth))
+        {
+            if (matching_category)
+                *matching_category = m_name.GetCString();
+            if (matching_type)
+                *matching_type = eFormatCategoryItemRegexSynth;
+            return true;
+        }
+    }
+#endif
+    return false;
+}
+
+TypeCategoryImpl::SummaryNavigator::MapValueType
+TypeCategoryImpl::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    SummaryNavigator::MapValueType retval;
+    
+    if (type_sp)
+    {
+        if (type_sp->IsRegex())
+            m_regex_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
+        else
+            m_summary_nav->GetExact(ConstString(type_sp->GetName()),retval);
+    }
+    
+    return retval;
+}
+
+TypeCategoryImpl::FilterNavigator::MapValueType
+TypeCategoryImpl::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    FilterNavigator::MapValueType retval;
+    
+    if (type_sp)
+    {
+        if (type_sp->IsRegex())
+            m_regex_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
+        else
+            m_filter_nav->GetExact(ConstString(type_sp->GetName()),retval);
+    }
+    
+    return retval;
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+TypeCategoryImpl::SynthNavigator::MapValueType
+TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
+{
+    SynthNavigator::MapValueType retval;
+    
+    if (type_sp)
+    {
+        if (type_sp->IsRegex())
+            m_regex_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
+        else
+            m_synth_nav->GetExact(ConstString(type_sp->GetName()),retval);
+    }
+    
+    return retval;
+}
+#endif
+
+lldb::TypeNameSpecifierImplSP
+TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex (size_t index)
+{
+    if (index < m_summary_nav->GetCount())
+        return m_summary_nav->GetTypeNameSpecifierAtIndex(index);
+    else
+        return m_regex_summary_nav->GetTypeNameSpecifierAtIndex(index-m_summary_nav->GetCount());
+}
+
+TypeCategoryImpl::SummaryNavigator::MapValueType
+TypeCategoryImpl::GetSummaryAtIndex (size_t index)
+{
+    if (index < m_summary_nav->GetCount())
+        return m_summary_nav->GetAtIndex(index);
+    else
+        return m_regex_summary_nav->GetAtIndex(index-m_summary_nav->GetCount());
+}
+
+TypeCategoryImpl::FilterNavigator::MapValueType
+TypeCategoryImpl::GetFilterAtIndex (size_t index)
+{
+    if (index < m_filter_nav->GetCount())
+        return m_filter_nav->GetAtIndex(index);
+    else
+        return m_regex_filter_nav->GetAtIndex(index-m_filter_nav->GetCount());
+}
+
+lldb::TypeNameSpecifierImplSP
+TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex (size_t index)
+{
+    if (index < m_filter_nav->GetCount())
+        return m_filter_nav->GetTypeNameSpecifierAtIndex(index);
+    else
+        return m_regex_filter_nav->GetTypeNameSpecifierAtIndex(index-m_filter_nav->GetCount());
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+TypeCategoryImpl::SynthNavigator::MapValueType
+TypeCategoryImpl::GetSyntheticAtIndex (size_t index)
+{
+    if (index < m_synth_nav->GetCount())
+        return m_synth_nav->GetAtIndex(index);
+    else
+        return m_regex_synth_nav->GetAtIndex(index-m_synth_nav->GetCount());
+}
+
+lldb::TypeNameSpecifierImplSP
+TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex (size_t index)
+{
+    if (index < m_synth_nav->GetCount())
+        return m_synth_nav->GetTypeNameSpecifierAtIndex(index);
+    else
+        return m_regex_synth_nav->GetTypeNameSpecifierAtIndex(index - m_synth_nav->GetCount());
+}
+#endif
+
+void
+TypeCategoryImpl::Enable (bool value, uint32_t position)
+{
+    Mutex::Locker locker(m_mutex);
+    m_enabled = value;
+    m_enabled_position = position;
+    if (m_change_listener)
+        m_change_listener->Changed();
+}
diff --git a/source/DataFormatters/TypeCategoryMap.cpp b/source/DataFormatters/TypeCategoryMap.cpp
new file mode 100644
index 0000000..4b7222a
--- /dev/null
+++ b/source/DataFormatters/TypeCategoryMap.cpp
@@ -0,0 +1,285 @@
+//===-- TypeCategoryMap.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/lldb-python.h"
+
+#include "lldb/DataFormatters/TypeCategoryMap.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+
+using namespace lldb;
+using namespace lldb_private;
+
+TypeCategoryMap::TypeCategoryMap (IFormatChangeListener* lst) :
+m_map_mutex(Mutex::eMutexTypeRecursive),
+listener(lst),
+m_map(),
+m_active_categories()
+{
+    ConstString default_cs("default");
+    lldb::TypeCategoryImplSP default_sp = lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
+    Add(default_cs,default_sp);
+    Enable(default_cs,First);
+}
+
+void
+TypeCategoryMap::Add (KeyType name, const ValueSP& entry)
+{
+    Mutex::Locker locker(m_map_mutex);
+    m_map[name] = entry;
+    if (listener)
+        listener->Changed();
+}
+
+bool
+TypeCategoryMap::Delete (KeyType name)
+{
+    Mutex::Locker locker(m_map_mutex);
+    MapIterator iter = m_map.find(name);
+    if (iter == m_map.end())
+        return false;
+    m_map.erase(name);
+    Disable(name);
+    if (listener)
+        listener->Changed();
+    return true;
+}
+
+bool
+TypeCategoryMap::Enable (KeyType category_name, Position pos)
+{
+    Mutex::Locker locker(m_map_mutex);
+    ValueSP category;
+    if (!Get(category_name,category))
+        return false;
+    return Enable(category, pos);
+}
+
+bool
+TypeCategoryMap::Disable (KeyType category_name)
+{
+    Mutex::Locker locker(m_map_mutex);
+    ValueSP category;
+    if (!Get(category_name,category))
+        return false;
+    return Disable(category);
+}
+
+bool
+TypeCategoryMap::Enable (ValueSP category, Position pos)
+{
+    Mutex::Locker locker(m_map_mutex);
+    if (category.get())
+    {
+        Position pos_w = pos;
+        if (pos == First || m_active_categories.size() == 0)
+            m_active_categories.push_front(category);
+        else if (pos == Last || pos == m_active_categories.size())
+            m_active_categories.push_back(category);
+        else if (pos < m_active_categories.size())
+        {
+            ActiveCategoriesList::iterator iter = m_active_categories.begin();
+            while (pos_w)
+            {
+                pos_w--,iter++;
+            }
+            m_active_categories.insert(iter,category);
+        }
+        else
+            return false;
+        category->Enable(true,
+                         pos);
+        return true;
+    }
+    return false;
+}
+
+bool
+TypeCategoryMap::Disable (ValueSP category)
+{
+    Mutex::Locker locker(m_map_mutex);
+    if (category.get())
+    {
+        m_active_categories.remove_if(delete_matching_categories(category));
+        category->Disable();
+        return true;
+    }
+    return false;
+}
+
+void
+TypeCategoryMap::Clear ()
+{
+    Mutex::Locker locker(m_map_mutex);
+    m_map.clear();
+    m_active_categories.clear();
+    if (listener)
+        listener->Changed();
+}
+
+bool
+TypeCategoryMap::Get (KeyType name, ValueSP& entry)
+{
+    Mutex::Locker locker(m_map_mutex);
+    MapIterator iter = m_map.find(name);
+    if (iter == m_map.end())
+        return false;
+    entry = iter->second;
+    return true;
+}
+
+bool
+TypeCategoryMap::Get (uint32_t pos, ValueSP& entry)
+{
+    Mutex::Locker locker(m_map_mutex);
+    MapIterator iter = m_map.begin();
+    MapIterator end = m_map.end();
+    while (pos > 0)
+    {
+        iter++;
+        pos--;
+        if (iter == end)
+            return false;
+    }
+    entry = iter->second;
+    return false;
+}
+
+bool
+TypeCategoryMap::AnyMatches (ConstString type_name,
+                             TypeCategoryImpl::FormatCategoryItems items,
+                             bool only_enabled,
+                             const char** matching_category,
+                             TypeCategoryImpl::FormatCategoryItems* matching_type)
+{
+    Mutex::Locker locker(m_map_mutex);
+    
+    MapIterator pos, end = m_map.end();
+    for (pos = m_map.begin(); pos != end; pos++)
+    {
+        if (pos->second->AnyMatches(type_name,
+                                    items,
+                                    only_enabled,
+                                    matching_category,
+                                    matching_type))
+            return true;
+    }
+    return false;
+}
+
+lldb::TypeSummaryImplSP
+TypeCategoryMap::GetSummaryFormat (ValueObject& valobj,
+                                   lldb::DynamicValueType use_dynamic)
+{
+    Mutex::Locker locker(m_map_mutex);
+    
+    uint32_t reason_why;
+    ActiveCategoriesIterator begin, end = m_active_categories.end();
+    
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    
+    for (begin = m_active_categories.begin(); begin != end; begin++)
+    {
+        lldb::TypeCategoryImplSP category_sp = *begin;
+        lldb::TypeSummaryImplSP current_format;
+        if (log)
+            log->Printf("\n[CategoryMap::GetSummaryFormat] Trying to use category %s", category_sp->GetName());
+        if (!category_sp->Get(valobj, current_format, use_dynamic, &reason_why))
+            continue;
+        return current_format;
+    }
+    if (log)
+        log->Printf("[CategoryMap::GetSummaryFormat] nothing found - returning empty SP");
+    return lldb::TypeSummaryImplSP();
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+lldb::SyntheticChildrenSP
+TypeCategoryMap::GetSyntheticChildren (ValueObject& valobj,
+                                       lldb::DynamicValueType use_dynamic)
+{
+    Mutex::Locker locker(m_map_mutex);
+    
+    uint32_t reason_why;
+    
+    ActiveCategoriesIterator begin, end = m_active_categories.end();
+    
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
+    
+    for (begin = m_active_categories.begin(); begin != end; begin++)
+    {
+        lldb::TypeCategoryImplSP category_sp = *begin;
+        lldb::SyntheticChildrenSP current_format;
+        if (log)
+            log->Printf("\n[CategoryMap::GetSyntheticChildren] Trying to use category %s", category_sp->GetName());
+        if (!category_sp->Get(valobj, current_format, use_dynamic, &reason_why))
+            continue;
+        return current_format;
+    }
+    if (log)
+        log->Printf("[CategoryMap::GetSyntheticChildren] nothing found - returning empty SP");
+    return lldb::SyntheticChildrenSP();
+}
+#endif
+
+void
+TypeCategoryMap::LoopThrough(CallbackType callback, void* param)
+{
+    if (callback)
+    {
+        Mutex::Locker locker(m_map_mutex);
+        
+        // loop through enabled categories in respective order
+        {
+            ActiveCategoriesIterator begin, end = m_active_categories.end();
+            for (begin = m_active_categories.begin(); begin != end; begin++)
+            {
+                lldb::TypeCategoryImplSP category = *begin;
+                ConstString type = ConstString(category->GetName());
+                if (!callback(param, category))
+                    break;
+            }
+        }
+        
+        // loop through disabled categories in just any order
+        {
+            MapIterator pos, end = m_map.end();
+            for (pos = m_map.begin(); pos != end; pos++)
+            {
+                if (pos->second->IsEnabled())
+                    continue;
+                KeyType type = pos->first;
+                if (!callback(param, pos->second))
+                    break;
+            }
+        }
+    }
+}
+
+TypeCategoryImplSP
+TypeCategoryMap::GetAtIndex (uint32_t index)
+{
+    Mutex::Locker locker(m_map_mutex);
+    
+    if (index < m_map.size())
+    {
+        MapIterator pos, end = m_map.end();
+        for (pos = m_map.begin(); pos != end; pos++)
+        {
+            if (index == 0)
+                return pos->second;
+            index--;
+        }
+    }
+    
+    return TypeCategoryImplSP();
+}
diff --git a/source/DataFormatters/TypeFormat.cpp b/source/DataFormatters/TypeFormat.cpp
new file mode 100644
index 0000000..279704f
--- /dev/null
+++ b/source/DataFormatters/TypeFormat.cpp
@@ -0,0 +1,52 @@
+//===-- TypeFormat.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/lldb-python.h"
+
+// C Includes
+
+// C++ Includes
+
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/lldb-public.h"
+#include "lldb/lldb-enumerations.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/Timer.h"
+#include "lldb/DataFormatters/TypeFormat.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TypeFormatImpl::TypeFormatImpl (lldb::Format f,
+                                const Flags& flags) :
+m_flags(flags),
+m_format (f)
+{
+}
+
+std::string
+TypeFormatImpl::GetDescription()
+{
+    StreamString sstr;
+    sstr.Printf ("%s%s%s%s\n",
+                 FormatManager::GetFormatAsCString (GetFormat()),
+                 Cascades() ? "" : " (not cascading)",
+                 SkipsPointers() ? " (skip pointers)" : "",
+                 SkipsReferences() ? " (skip references)" : "");
+    return sstr.GetString();
+}
+
diff --git a/source/DataFormatters/TypeSummary.cpp b/source/DataFormatters/TypeSummary.cpp
new file mode 100644
index 0000000..8c4d3f7
--- /dev/null
+++ b/source/DataFormatters/TypeSummary.cpp
@@ -0,0 +1,250 @@
+//===-- TypeSummary.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/lldb-python.h"
+
+// C Includes
+
+// C++ Includes
+
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/lldb-public.h"
+#include "lldb/lldb-enumerations.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/Timer.h"
+#include "lldb/DataFormatters/TypeSummary.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
+
+#include "lldb/Host/Host.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TypeSummaryImpl::TypeSummaryImpl (const TypeSummaryImpl::Flags& flags) :
+m_flags(flags)
+{
+}
+
+
+StringSummaryFormat::StringSummaryFormat (const TypeSummaryImpl::Flags& flags,
+                                          const char *format_cstr) :
+TypeSummaryImpl(flags),
+m_format()
+{
+    if (format_cstr)
+        m_format.assign(format_cstr);
+}
+
+bool
+StringSummaryFormat::FormatObject (ValueObject *valobj,
+                                   std::string& retval)
+{
+    if (!valobj)
+    {
+        retval.assign("NULL ValueObject");
+        return false;
+    }
+    
+    StreamString s;
+    ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
+    SymbolContext sc;
+    StackFrame *frame = exe_ctx.GetFramePtr();
+    if (frame)
+        sc = frame->GetSymbolContext(lldb::eSymbolContextEverything);
+    
+    if (IsOneliner())
+    {
+        ValueObject* object;
+        
+        ValueObjectSP synth_valobj = valobj->GetSyntheticValue();
+        if (synth_valobj)
+            object = synth_valobj.get();
+        else
+            object = valobj;
+        
+        const uint32_t num_children = object->GetNumChildren();
+        if (num_children)
+        {
+            s.PutChar('(');
+            
+            for (uint32_t idx=0; idx<num_children; ++idx)
+            {
+                lldb::ValueObjectSP child_sp(object->GetChildAtIndex(idx, true));
+                if (child_sp.get())
+                {
+                    if (idx)
+                        s.PutCString(", ");
+                    if (!HideNames())
+                    {
+                        s.PutCString(child_sp.get()->GetName().AsCString());
+                        s.PutCString(" = ");
+                    }
+                    child_sp.get()->DumpPrintableRepresentation(s,
+                                                                ValueObject::eValueObjectRepresentationStyleSummary,
+                                                                lldb::eFormatInvalid,
+                                                                ValueObject::ePrintableRepresentationSpecialCasesDisable);
+                }
+            }
+            
+            s.PutChar(')');
+            
+            retval.assign(s.GetString());
+            return true;
+        }
+        else
+        {
+            retval.assign("error: oneliner for no children");
+            return false;
+        }
+        
+    }
+    else
+    {
+        if (Debugger::FormatPrompt(m_format.c_str(), &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s, valobj))
+        {
+            retval.assign(s.GetString());
+            return true;
+        }
+        else
+        {
+            retval.assign("error: summary string parsing error");
+            return false;
+        }
+    }
+}
+
+std::string
+StringSummaryFormat::GetDescription ()
+{
+    StreamString sstr;
+    
+    sstr.Printf ("`%s`%s%s%s%s%s%s%s",      m_format.c_str(),
+                 Cascades() ? "" : " (not cascading)",
+                 !DoesPrintChildren() ? "" : " (show children)",
+                 !DoesPrintValue() ? " (hide value)" : "",
+                 IsOneliner() ? " (one-line printout)" : "",
+                 SkipsPointers() ? " (skip pointers)" : "",
+                 SkipsReferences() ? " (skip references)" : "",
+                 HideNames() ? " (hide member names)" : "");
+    return sstr.GetString();
+}
+
+CXXFunctionSummaryFormat::CXXFunctionSummaryFormat (const TypeSummaryImpl::Flags& flags,
+                                                    Callback impl,
+                                                    const char* description) :
+TypeSummaryImpl(flags),
+m_impl(impl),
+m_description(description ? description : "")
+{
+}
+
+bool
+CXXFunctionSummaryFormat::FormatObject (ValueObject *valobj,
+                                        std::string& dest)
+{
+    dest.clear();
+    StreamString stream;
+    if (!m_impl || m_impl(*valobj,stream) == false)
+        return false;
+    dest.assign(stream.GetData());
+    return true;
+}
+
+std::string
+CXXFunctionSummaryFormat::GetDescription ()
+{
+    StreamString sstr;
+    sstr.Printf ("`%s (%p) `%s%s%s%s%s%s%s",      m_description.c_str(),m_impl,
+                 Cascades() ? "" : " (not cascading)",
+                 !DoesPrintChildren() ? "" : " (show children)",
+                 !DoesPrintValue() ? " (hide value)" : "",
+                 IsOneliner() ? " (one-line printout)" : "",
+                 SkipsPointers() ? " (skip pointers)" : "",
+                 SkipsReferences() ? " (skip references)" : "",
+                 HideNames() ? " (hide member names)" : "");
+    return sstr.GetString();
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+
+
+ScriptSummaryFormat::ScriptSummaryFormat (const TypeSummaryImpl::Flags& flags,
+                                          const char * function_name,
+                                          const char * python_script) :
+TypeSummaryImpl(flags),
+m_function_name(),
+m_python_script(),
+m_script_function_sp()
+{
+    if (function_name)
+        m_function_name.assign(function_name);
+    if (python_script)
+        m_python_script.assign(python_script);
+}
+
+bool
+ScriptSummaryFormat::FormatObject (ValueObject *valobj,
+                                   std::string& retval)
+{
+    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
+    
+    if (!valobj)
+        return false;
+    
+    Host::SetCrashDescriptionWithFormat("[Python summary] Name: %s - Function: %s",
+                                        valobj->GetName().AsCString("unknown"),
+                                        m_function_name.c_str());
+
+    TargetSP target_sp(valobj->GetTargetSP());
+    
+    if (!target_sp)
+    {
+        retval.assign("error: no target");
+        return false;
+    }
+    
+    ScriptInterpreter *script_interpreter = target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+    
+    if (!script_interpreter)
+    {
+        retval.assign("error: no ScriptInterpreter");
+        return false;
+    }
+    
+    return script_interpreter->GetScriptedSummary(m_function_name.c_str(),
+                                                  valobj->GetSP(),
+                                                  m_script_function_sp,
+                                                  retval);
+    
+}
+
+std::string
+ScriptSummaryFormat::GetDescription ()
+{
+    StreamString sstr;
+    sstr.Printf ("%s%s%s%s%s%s%s\n%s",       Cascades() ? "" : " (not cascading)",
+                 !DoesPrintChildren() ? "" : " (show children)",
+                 !DoesPrintValue() ? " (hide value)" : "",
+                 IsOneliner() ? " (one-line printout)" : "",
+                 SkipsPointers() ? " (skip pointers)" : "",
+                 SkipsReferences() ? " (skip references)" : "",
+                 HideNames() ? " (hide member names)" : "",
+                 m_python_script.c_str());
+    return sstr.GetString();
+    
+}
+
+#endif // #ifndef LLDB_DISABLE_PYTHON
diff --git a/source/DataFormatters/TypeSynthetic.cpp b/source/DataFormatters/TypeSynthetic.cpp
new file mode 100644
index 0000000..972be48
--- /dev/null
+++ b/source/DataFormatters/TypeSynthetic.cpp
@@ -0,0 +1,114 @@
+//===-- TypeSynthetic.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/lldb-python.h"
+
+// C Includes
+
+// C++ Includes
+
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/lldb-public.h"
+#include "lldb/lldb-enumerations.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/DataFormatters/TypeSynthetic.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Symbol/ClangASTType.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+std::string
+TypeFilterImpl::GetDescription()
+{
+    StreamString sstr;
+    sstr.Printf("%s%s%s {\n",
+                Cascades() ? "" : " (not cascading)",
+                SkipsPointers() ? " (skip pointers)" : "",
+                SkipsReferences() ? " (skip references)" : "");
+    
+    for (size_t i = 0; i < GetCount(); i++)
+    {
+        sstr.Printf("    %s\n",
+                    GetExpressionPathAtIndex(i));
+    }
+    
+    sstr.Printf("}");
+    return sstr.GetString();
+}
+
+std::string
+CXXSyntheticChildren::GetDescription()
+{
+    StreamString sstr;
+    sstr.Printf("%s%s%s Generator at %p - %s",
+                Cascades() ? "" : " (not cascading)",
+                SkipsPointers() ? " (skip pointers)" : "",
+                SkipsReferences() ? " (skip references)" : "",
+                m_create_callback,
+                m_description.c_str());
+    
+    return sstr.GetString();
+}
+
+#ifndef LLDB_DISABLE_PYTHON
+
+ScriptedSyntheticChildren::FrontEnd::FrontEnd(std::string pclass, ValueObject &backend) :
+SyntheticChildrenFrontEnd(backend),
+m_python_class(pclass),
+m_wrapper_sp(),
+m_interpreter(NULL)
+{
+    if (backend == LLDB_INVALID_UID)
+        return;
+    
+    TargetSP target_sp = backend.GetTargetSP();
+    
+    if (!target_sp)
+        return;
+    
+    m_interpreter = target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+    
+    if (m_interpreter != NULL)
+        m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(m_python_class.c_str(), backend.GetSP());
+}
+
+ScriptedSyntheticChildren::FrontEnd::~FrontEnd()
+{
+}
+
+lldb::ValueObjectSP
+ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex (size_t idx)
+{
+    if (!m_wrapper_sp || !m_interpreter)
+        return lldb::ValueObjectSP();
+    
+    return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
+}
+
+std::string
+ScriptedSyntheticChildren::GetDescription()
+{
+    StreamString sstr;
+    sstr.Printf("%s%s%s Python class %s",
+                Cascades() ? "" : " (not cascading)",
+                SkipsPointers() ? " (skip pointers)" : "",
+                SkipsReferences() ? " (skip references)" : "",
+                m_python_class.c_str());
+    
+    return sstr.GetString();
+}
+
+#endif // #ifndef LLDB_DISABLE_PYTHON