16 files changed, 7781 insertions, 0 deletions

diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp
new file mode 100644
index 000000000000..711d324d8aa7
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp
@@ -0,0 +1,573 @@
+//===-- AppleObjCClassDescriptorV2.cpp -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCClassDescriptorV2.h"
+
+#include "lldb/Core/Log.h"
+#include "lldb/Expression/FunctionCaller.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+bool
+ClassDescriptorV2::Read_objc_class (Process* process, std::unique_ptr<objc_class_t> &objc_class) const
+{
+    objc_class.reset(new objc_class_t);
+    
+    bool ret = objc_class->Read (process, m_objc_class_ptr);
+    
+    if (!ret)
+        objc_class.reset();
+    
+    return ret;
+}
+
+bool
+ClassDescriptorV2::objc_class_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t ptr_size = process->GetAddressByteSize();
+    
+    size_t objc_class_size = ptr_size   // uintptr_t isa;
+    + ptr_size   // Class superclass;
+    + ptr_size   // void *cache;
+    + ptr_size   // IMP *vtable;
+    + ptr_size;  // uintptr_t data_NEVER_USE;
+    
+    DataBufferHeap objc_class_buf (objc_class_size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, objc_class_buf.GetBytes(), objc_class_size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(objc_class_buf.GetBytes(), objc_class_size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_isa           = extractor.GetAddress_unchecked(&cursor);   // uintptr_t isa;
+    m_superclass    = extractor.GetAddress_unchecked(&cursor);   // Class superclass;
+    m_cache_ptr     = extractor.GetAddress_unchecked(&cursor);   // void *cache;
+    m_vtable_ptr    = extractor.GetAddress_unchecked(&cursor);   // IMP *vtable;
+    lldb::addr_t data_NEVER_USE = extractor.GetAddress_unchecked(&cursor);   // uintptr_t data_NEVER_USE;
+    
+    m_flags         = (uint8_t)(data_NEVER_USE & (lldb::addr_t)3);
+    m_data_ptr      = data_NEVER_USE & ~(lldb::addr_t)3;
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::class_rw_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t ptr_size = process->GetAddressByteSize();
+    
+    size_t size = sizeof(uint32_t)  // uint32_t flags;
+    + sizeof(uint32_t)  // uint32_t version;
+    + ptr_size          // const class_ro_t *ro;
+    + ptr_size          // union { method_list_t **method_lists; method_list_t *method_list; };
+    + ptr_size          // struct chained_property_list *properties;
+    + ptr_size          // const protocol_list_t **protocols;
+    + ptr_size          // Class firstSubclass;
+    + ptr_size;         // Class nextSiblingClass;
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_flags             = extractor.GetU32_unchecked(&cursor);
+    m_version           = extractor.GetU32_unchecked(&cursor);
+    m_ro_ptr            = extractor.GetAddress_unchecked(&cursor);
+    m_method_list_ptr   = extractor.GetAddress_unchecked(&cursor);
+    m_properties_ptr    = extractor.GetAddress_unchecked(&cursor);
+    m_firstSubclass     = extractor.GetAddress_unchecked(&cursor);
+    m_nextSiblingClass  = extractor.GetAddress_unchecked(&cursor);
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::class_ro_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t ptr_size = process->GetAddressByteSize();
+    
+    size_t size = sizeof(uint32_t)             // uint32_t flags;
+    + sizeof(uint32_t)                         // uint32_t instanceStart;
+    + sizeof(uint32_t)                         // uint32_t instanceSize;
+    + (ptr_size == 8 ? sizeof(uint32_t) : 0)   // uint32_t reserved; // __LP64__ only
+    + ptr_size                                 // const uint8_t *ivarLayout;
+    + ptr_size                                 // const char *name;
+    + ptr_size                                 // const method_list_t *baseMethods;
+    + ptr_size                                 // const protocol_list_t *baseProtocols;
+    + ptr_size                                 // const ivar_list_t *ivars;
+    + ptr_size                                 // const uint8_t *weakIvarLayout;
+    + ptr_size;                                // const property_list_t *baseProperties;
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_flags             = extractor.GetU32_unchecked(&cursor);
+    m_instanceStart     = extractor.GetU32_unchecked(&cursor);
+    m_instanceSize      = extractor.GetU32_unchecked(&cursor);
+    if (ptr_size == 8)
+        m_reserved      = extractor.GetU32_unchecked(&cursor);
+    else
+        m_reserved      = 0;
+    m_ivarLayout_ptr     = extractor.GetAddress_unchecked(&cursor);
+    m_name_ptr           = extractor.GetAddress_unchecked(&cursor);
+    m_baseMethods_ptr    = extractor.GetAddress_unchecked(&cursor);
+    m_baseProtocols_ptr  = extractor.GetAddress_unchecked(&cursor);
+    m_ivars_ptr          = extractor.GetAddress_unchecked(&cursor);
+    m_weakIvarLayout_ptr = extractor.GetAddress_unchecked(&cursor);
+    m_baseProperties_ptr = extractor.GetAddress_unchecked(&cursor);
+    
+    DataBufferHeap name_buf(1024, '\0');
+    
+    process->ReadCStringFromMemory(m_name_ptr, (char*)name_buf.GetBytes(), name_buf.GetByteSize(), error);
+    
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    m_name.assign((char*)name_buf.GetBytes());
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::Read_class_row (Process* process, const objc_class_t &objc_class, std::unique_ptr<class_ro_t> &class_ro, std::unique_ptr<class_rw_t> &class_rw) const
+{
+    class_ro.reset();
+    class_rw.reset();
+    
+    Error error;
+    uint32_t class_row_t_flags = process->ReadUnsignedIntegerFromMemory(objc_class.m_data_ptr, sizeof(uint32_t), 0, error);
+    if (!error.Success())
+        return false;
+    
+    if (class_row_t_flags & RW_REALIZED)
+    {
+        class_rw.reset(new class_rw_t);
+        
+        if (!class_rw->Read(process, objc_class.m_data_ptr))
+        {
+            class_rw.reset();
+            return false;
+        }
+        
+        class_ro.reset(new class_ro_t);
+        
+        if (!class_ro->Read(process, class_rw->m_ro_ptr))
+        {
+            class_rw.reset();
+            class_ro.reset();
+            return false;
+        }
+    }
+    else
+    {
+        class_ro.reset(new class_ro_t);
+        
+        if (!class_ro->Read(process, objc_class.m_data_ptr))
+        {
+            class_ro.reset();
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::method_list_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t size = sizeof(uint32_t)  // uint32_t entsize_NEVER_USE;
+    + sizeof(uint32_t); // uint32_t count;
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_entsize   = extractor.GetU32_unchecked(&cursor) & ~(uint32_t)3;
+    m_count     = extractor.GetU32_unchecked(&cursor);
+    m_first_ptr  = addr + cursor;
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::method_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t size = GetSize(process);
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_name_ptr   = extractor.GetAddress_unchecked(&cursor);
+    m_types_ptr  = extractor.GetAddress_unchecked(&cursor);
+    m_imp_ptr    = extractor.GetAddress_unchecked(&cursor);
+    
+    process->ReadCStringFromMemory(m_name_ptr, m_name, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    process->ReadCStringFromMemory(m_types_ptr, m_types, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::ivar_list_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t size = sizeof(uint32_t)  // uint32_t entsize;
+    + sizeof(uint32_t); // uint32_t count;
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_entsize   = extractor.GetU32_unchecked(&cursor);
+    m_count     = extractor.GetU32_unchecked(&cursor);
+    m_first_ptr = addr + cursor;
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::ivar_t::Read(Process *process, lldb::addr_t addr)
+{
+    size_t size = GetSize(process);
+    
+    DataBufferHeap buffer (size, '\0');
+    Error error;
+    
+    process->ReadMemory(addr, buffer.GetBytes(), size, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(), process->GetAddressByteSize());
+    
+    lldb::offset_t cursor = 0;
+    
+    m_offset_ptr = extractor.GetAddress_unchecked(&cursor);
+    m_name_ptr   = extractor.GetAddress_unchecked(&cursor);
+    m_type_ptr   = extractor.GetAddress_unchecked(&cursor);
+    m_alignment  = extractor.GetU32_unchecked(&cursor);
+    m_size       = extractor.GetU32_unchecked(&cursor);
+    
+    process->ReadCStringFromMemory(m_name_ptr, m_name, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    process->ReadCStringFromMemory(m_type_ptr, m_type, error);
+    if (error.Fail())
+    {
+        return false;
+    }
+    
+    return true;
+}
+
+bool
+ClassDescriptorV2::Describe (std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+                             std::function <bool (const char *, const char *)> const &instance_method_func,
+                             std::function <bool (const char *, const char *)> const &class_method_func,
+                             std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> const &ivar_func) const
+{
+    lldb_private::Process *process = m_runtime.GetProcess();
+    
+    std::unique_ptr<objc_class_t> objc_class;
+    std::unique_ptr<class_ro_t> class_ro;
+    std::unique_ptr<class_rw_t> class_rw;
+    
+    if (!Read_objc_class(process, objc_class))
+        return 0;
+    if (!Read_class_row(process, *objc_class, class_ro, class_rw))
+        return 0;
+    
+    static ConstString NSObject_name("NSObject");
+    
+    if (m_name != NSObject_name && superclass_func)
+        superclass_func(objc_class->m_superclass);
+    
+    if (instance_method_func)
+    {
+        std::unique_ptr<method_list_t> base_method_list;
+        
+        base_method_list.reset(new method_list_t);
+        if (!base_method_list->Read(process, class_ro->m_baseMethods_ptr))
+            return false;
+        
+        if (base_method_list->m_entsize != method_t::GetSize(process))
+            return false;
+        
+        std::unique_ptr<method_t> method;
+        method.reset(new method_t);
+        
+        for (uint32_t i = 0, e = base_method_list->m_count; i < e; ++i)
+        {
+            method->Read(process, base_method_list->m_first_ptr + (i * base_method_list->m_entsize));
+            
+            if (instance_method_func(method->m_name.c_str(), method->m_types.c_str()))
+                break;
+        }
+    }
+    
+    if (class_method_func)
+    {
+        AppleObjCRuntime::ClassDescriptorSP metaclass(GetMetaclass());
+        
+        // We don't care about the metaclass's superclass, or its class methods.  Its instance methods are
+        // our class methods.
+        
+        if (metaclass) {
+            metaclass->Describe(std::function <void (ObjCLanguageRuntime::ObjCISA)> (nullptr),
+                                class_method_func,
+                                std::function <bool (const char *, const char *)> (nullptr),
+                                std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> (nullptr));
+        }
+    }
+    
+    if (ivar_func)
+    {
+        if (class_ro->m_ivars_ptr != 0)
+        {            
+            ivar_list_t ivar_list;
+            if (!ivar_list.Read(process, class_ro->m_ivars_ptr))
+                return false;
+            
+            if (ivar_list.m_entsize != ivar_t::GetSize(process))
+                return false;
+            
+            ivar_t ivar;
+            
+            for (uint32_t i = 0, e = ivar_list.m_count; i < e; ++i)
+            {
+                ivar.Read(process, ivar_list.m_first_ptr + (i * ivar_list.m_entsize));
+                
+                if (ivar_func(ivar.m_name.c_str(), ivar.m_type.c_str(), ivar.m_offset_ptr, ivar.m_size))
+                    break;
+            }
+        }
+    }
+    
+    return true;
+}
+
+ConstString
+ClassDescriptorV2::GetClassName ()
+{
+    if (!m_name)
+    {
+        lldb_private::Process *process = m_runtime.GetProcess();
+        
+        if (process)
+        {
+            std::unique_ptr<objc_class_t> objc_class;
+            std::unique_ptr<class_ro_t> class_ro;
+            std::unique_ptr<class_rw_t> class_rw;
+            
+            if (!Read_objc_class(process, objc_class))
+                return m_name;
+            if (!Read_class_row(process, *objc_class, class_ro, class_rw))
+                return m_name;
+            
+            m_name = ConstString(class_ro->m_name.c_str());
+        }
+    }
+    return m_name;
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+ClassDescriptorV2::GetSuperclass ()
+{
+    lldb_private::Process *process = m_runtime.GetProcess();
+    
+    if (!process)
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    std::unique_ptr<objc_class_t> objc_class;
+    
+    if (!Read_objc_class(process, objc_class))
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    return m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(objc_class->m_superclass);
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+ClassDescriptorV2::GetMetaclass () const
+{
+    lldb_private::Process *process = m_runtime.GetProcess();
+    
+    if (!process)
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    std::unique_ptr<objc_class_t> objc_class;
+    
+    if (!Read_objc_class(process, objc_class))
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    lldb::addr_t candidate_isa = m_runtime.GetPointerISA(objc_class->m_isa);
+    
+    return ObjCLanguageRuntime::ClassDescriptorSP(new ClassDescriptorV2(m_runtime, candidate_isa, nullptr));
+}
+
+uint64_t
+ClassDescriptorV2::GetInstanceSize ()
+{
+    lldb_private::Process *process = m_runtime.GetProcess();
+    
+    if (process)
+    {
+        std::unique_ptr<objc_class_t> objc_class;
+        std::unique_ptr<class_ro_t> class_ro;
+        std::unique_ptr<class_rw_t> class_rw;
+        
+        if (!Read_objc_class(process, objc_class))
+            return 0;
+        if (!Read_class_row(process, *objc_class, class_ro, class_rw))
+            return 0;
+        
+        return class_ro->m_instanceSize;
+    }
+    
+    return 0;
+}
+
+ClassDescriptorV2::iVarsStorage::iVarsStorage ():
+m_filled(false),
+m_ivars(),
+m_mutex(Mutex::eMutexTypeRecursive)
+{}
+
+size_t
+ClassDescriptorV2::iVarsStorage::size ()
+{
+    return m_ivars.size();
+}
+
+ClassDescriptorV2::iVarDescriptor&
+ClassDescriptorV2::iVarsStorage::operator[] (size_t idx)
+{
+    return m_ivars[idx];
+}
+
+void
+ClassDescriptorV2::iVarsStorage::fill (AppleObjCRuntimeV2& runtime, ClassDescriptorV2& descriptor)
+{
+    if (m_filled)
+        return;
+    Mutex::Locker lock(m_mutex);
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES | LIBLLDB_LOG_VERBOSE));
+    if (log)
+        log->Printf("[ClassDescriptorV2::iVarsStorage::fill] class_name = %s", descriptor.GetClassName().AsCString("<unknown"));
+    m_filled = true;
+    ObjCLanguageRuntime::EncodingToTypeSP encoding_to_type_sp(runtime.GetEncodingToType());
+    Process* process(runtime.GetProcess());
+    if (!encoding_to_type_sp)
+        return;
+    descriptor.Describe(nullptr,
+                        nullptr,
+                        nullptr,
+                        [this,process,encoding_to_type_sp,log](const char * name, const char * type, lldb::addr_t offset_ptr, uint64_t size) -> bool {
+                 const bool for_expression = false;
+                 const bool stop_loop = false;
+                 if (log)
+                     log->Printf("[ClassDescriptorV2::iVarsStorage::fill] name = %s, encoding = %s, offset_ptr = %" PRIx64 ", size = %" PRIu64,
+                                 name,type,offset_ptr,size);
+                 CompilerType ivar_type = encoding_to_type_sp->RealizeType(type, for_expression);
+                 if (ivar_type)
+                 {
+                     if (log)
+                         log->Printf("[ClassDescriptorV2::iVarsStorage::fill] name = %s, encoding = %s, offset_ptr = %" PRIx64 ", size = %" PRIu64 " , type_size = %" PRIu64,
+                                     name,type,offset_ptr,size,ivar_type.GetByteSize(nullptr));
+                     Scalar offset_scalar;
+                     Error error;
+                     const int offset_ptr_size = 4;
+                     const bool is_signed = false;
+                     size_t read = process->ReadScalarIntegerFromMemory(offset_ptr, offset_ptr_size, is_signed, offset_scalar, error);
+                     if (error.Success() && 4 == read)
+                     {
+                         if (log)
+                             log->Printf("[ClassDescriptorV2::iVarsStorage::fill] offset_ptr = %" PRIx64 " --> %" PRIu32,
+                                         offset_ptr, offset_scalar.SInt());
+                         m_ivars.push_back({ ConstString(name), ivar_type, size, offset_scalar.SInt() });
+                     }
+                     else if (log)
+                         log->Printf("[ClassDescriptorV2::iVarsStorage::fill] offset_ptr = %" PRIx64 " --> read fail, read = %zu",
+                                     offset_ptr, read);
+                 }
+                 return stop_loop;
+             });
+}
+
+void
+ClassDescriptorV2::GetIVarInformation ()
+{
+    m_ivars_storage.fill(m_runtime, *this);
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h
new file mode 100644
index 000000000000..18591ecd6e93
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h
@@ -0,0 +1,411 @@
+//===-- AppleObjCClassDescriptorV2.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCClassDescriptorV2_h_
+#define liblldb_AppleObjCClassDescriptorV2_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Host/Mutex.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "AppleObjCRuntimeV2.h"
+
+namespace lldb_private {
+
+class ClassDescriptorV2 : public ObjCLanguageRuntime::ClassDescriptor
+{
+public:
+    friend class lldb_private::AppleObjCRuntimeV2;
+    
+    ~ClassDescriptorV2() override = default;
+
+    ConstString
+    GetClassName() override;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetSuperclass() override;
+    
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetMetaclass() const override;
+    
+    bool
+    IsValid() override
+    {
+        return true;    // any Objective-C v2 runtime class descriptor we vend is valid
+    }
+    
+    // a custom descriptor is used for tagged pointers
+    bool
+    GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                         uint64_t* value_bits = nullptr,
+                         uint64_t* payload = nullptr) override
+    {
+        return false;
+    }
+    
+    uint64_t
+    GetInstanceSize() override;
+    
+    ObjCLanguageRuntime::ObjCISA
+    GetISA() override
+    {
+        return m_objc_class_ptr;
+    }
+    
+    bool
+    Describe(std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+             std::function <bool (const char *, const char *)> const &instance_method_func,
+             std::function <bool (const char *, const char *)> const &class_method_func,
+             std::function <bool (const char *, const char *,
+             lldb::addr_t, uint64_t)> const &ivar_func) const override;
+
+    size_t
+    GetNumIVars() override
+    {
+        GetIVarInformation();
+        return m_ivars_storage.size();
+    }
+    
+    iVarDescriptor
+    GetIVarAtIndex(size_t idx) override
+    {
+        if (idx >= GetNumIVars())
+            return iVarDescriptor();
+        return m_ivars_storage[idx];
+    }
+    
+protected:
+    void
+    GetIVarInformation ();
+    
+private:
+    static const uint32_t RW_REALIZED = (1 << 31);
+    
+    struct objc_class_t {
+        ObjCLanguageRuntime::ObjCISA    m_isa;              // The class's metaclass.
+        ObjCLanguageRuntime::ObjCISA    m_superclass;
+        lldb::addr_t                    m_cache_ptr;
+        lldb::addr_t                    m_vtable_ptr;
+        lldb::addr_t                    m_data_ptr;
+        uint8_t                         m_flags;
+        
+        objc_class_t () :
+        m_isa (0),
+        m_superclass (0),
+        m_cache_ptr (0),
+        m_vtable_ptr (0),
+        m_data_ptr (0),
+        m_flags (0)
+        {
+        }
+        
+        void
+        Clear()
+        {
+            m_isa = 0;
+            m_superclass = 0;
+            m_cache_ptr = 0;
+            m_vtable_ptr = 0;
+            m_data_ptr = 0;
+            m_flags = 0;
+        }
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct class_ro_t {
+        uint32_t                        m_flags;
+        uint32_t                        m_instanceStart;
+        uint32_t                        m_instanceSize;
+        uint32_t                        m_reserved;
+        
+        lldb::addr_t                    m_ivarLayout_ptr;
+        lldb::addr_t                    m_name_ptr;
+        lldb::addr_t                    m_baseMethods_ptr;
+        lldb::addr_t                    m_baseProtocols_ptr;
+        lldb::addr_t                    m_ivars_ptr;
+        
+        lldb::addr_t                    m_weakIvarLayout_ptr;
+        lldb::addr_t                    m_baseProperties_ptr;
+        
+        std::string                     m_name;
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct class_rw_t {
+        uint32_t                        m_flags;
+        uint32_t                        m_version;
+        
+        lldb::addr_t                    m_ro_ptr;
+        union {
+            lldb::addr_t                m_method_list_ptr;
+            lldb::addr_t                m_method_lists_ptr;
+        };
+        lldb::addr_t                    m_properties_ptr;
+        lldb::addr_t                    m_protocols_ptr;
+        
+        ObjCLanguageRuntime::ObjCISA    m_firstSubclass;
+        ObjCLanguageRuntime::ObjCISA    m_nextSiblingClass;
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct method_list_t
+    {
+        uint32_t        m_entsize;
+        uint32_t        m_count;
+        lldb::addr_t    m_first_ptr;
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct method_t
+    {
+        lldb::addr_t    m_name_ptr;
+        lldb::addr_t    m_types_ptr;
+        lldb::addr_t    m_imp_ptr;
+        
+        std::string     m_name;
+        std::string     m_types;
+        
+        static size_t GetSize(Process *process)
+        {
+            size_t ptr_size = process->GetAddressByteSize();
+            
+            return ptr_size     // SEL name;
+            + ptr_size   // const char *types;
+            + ptr_size;  // IMP imp;
+        }
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct ivar_list_t
+    {
+        uint32_t        m_entsize;
+        uint32_t        m_count;
+        lldb::addr_t    m_first_ptr;
+        
+        bool Read(Process *process, lldb::addr_t addr);
+    };
+    
+    struct ivar_t
+    {
+        lldb::addr_t    m_offset_ptr;
+        lldb::addr_t    m_name_ptr;
+        lldb::addr_t    m_type_ptr;
+        uint32_t        m_alignment;
+        uint32_t        m_size;
+        
+        std::string     m_name;
+        std::string     m_type;
+        
+        static size_t GetSize(Process *process)
+        {
+            size_t ptr_size = process->GetAddressByteSize();
+            
+            return ptr_size             // uintptr_t *offset;
+            + ptr_size             // const char *name;
+            + ptr_size             // const char *type;
+            + sizeof(uint32_t)     // uint32_t alignment;
+            + sizeof(uint32_t);    // uint32_t size;
+        }
+        
+        bool
+        Read(Process *process, lldb::addr_t addr);
+    };
+    
+    class iVarsStorage
+    {
+    public:
+        iVarsStorage ();
+        
+        size_t
+        size ();
+        
+        iVarDescriptor&
+        operator[] (size_t idx);
+        
+        void
+        fill (AppleObjCRuntimeV2& runtime, ClassDescriptorV2& descriptor);
+        
+    private:
+        bool m_filled;
+        std::vector<iVarDescriptor> m_ivars;
+        Mutex m_mutex;
+    };
+    
+    // The constructor should only be invoked by the runtime as it builds its caches
+    // or populates them.  A ClassDescriptorV2 should only ever exist in a cache.
+    ClassDescriptorV2(AppleObjCRuntimeV2 &runtime, ObjCLanguageRuntime::ObjCISA isa, const char *name) :
+        m_runtime (runtime),
+        m_objc_class_ptr (isa),
+        m_name (name),
+        m_ivars_storage()
+    {
+    }
+    
+    bool
+    Read_objc_class (Process* process, std::unique_ptr<objc_class_t> &objc_class) const;
+    
+    bool
+    Read_class_row (Process* process, const objc_class_t &objc_class, std::unique_ptr<class_ro_t> &class_ro, std::unique_ptr<class_rw_t> &class_rw) const;
+    
+    AppleObjCRuntimeV2 &m_runtime;          // The runtime, so we can read information lazily.
+    lldb::addr_t        m_objc_class_ptr;   // The address of the objc_class_t.  (I.e., objects of this class type have this as their ISA)
+    ConstString         m_name;             // May be NULL
+    iVarsStorage        m_ivars_storage;
+};
+
+// tagged pointer descriptor
+class ClassDescriptorV2Tagged : public ObjCLanguageRuntime::ClassDescriptor
+{
+public:
+    ClassDescriptorV2Tagged (ConstString class_name,
+                             uint64_t payload)
+    {
+        m_name = class_name;
+        if (!m_name)
+        {
+            m_valid = false;
+            return;
+        }
+        m_valid = true;
+        m_payload = payload;
+        m_info_bits = (m_payload & 0xF0ULL) >> 4;
+        m_value_bits = (m_payload & ~0x0000000000000000FFULL) >> 8;
+    }
+    
+    ClassDescriptorV2Tagged (ObjCLanguageRuntime::ClassDescriptorSP actual_class_sp,
+                             uint64_t payload)
+    {
+        if (!actual_class_sp)
+        {
+            m_valid = false;
+            return;
+        }
+        m_name = actual_class_sp->GetClassName();
+        if (!m_name)
+        {
+            m_valid = false;
+            return;
+        }
+        m_valid = true;
+        m_payload = payload;
+        m_info_bits = (m_payload & 0x0FULL);
+        m_value_bits = (m_payload & ~0x0FULL) >> 4;
+    }
+    
+    ~ClassDescriptorV2Tagged() override = default;
+
+    ConstString
+    GetClassName() override
+    {
+        return m_name;
+    }
+    
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetSuperclass() override
+    {
+        // tagged pointers can represent a class that has a superclass, but since that information is not
+        // stored in the object itself, we would have to query the runtime to discover the hierarchy
+        // for the time being, we skip this step in the interest of static discovery
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    }
+    
+    ObjCLanguageRuntime::ClassDescriptorSP
+    GetMetaclass() const override
+    {
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    }
+    
+    bool
+    IsValid() override
+    {
+        return m_valid;
+    }
+    
+    bool
+    IsKVO() override
+    {
+        return false; // tagged pointers are not KVO'ed
+    }
+    
+    bool
+    IsCFType() override
+    {
+        return false; // tagged pointers are not CF objects
+    }
+    
+    bool
+    GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                         uint64_t* value_bits = nullptr,
+                         uint64_t* payload = nullptr) override
+    {
+        if (info_bits)
+            *info_bits = GetInfoBits();
+        if (value_bits)
+            *value_bits = GetValueBits();
+        if (payload)
+            *payload = GetPayload();
+        return true;
+    }
+    
+    uint64_t
+    GetInstanceSize() override
+    {
+        return (IsValid() ? m_pointer_size : 0);
+    }
+    
+    ObjCLanguageRuntime::ObjCISA
+    GetISA() override
+    {
+        return 0; // tagged pointers have no ISA
+    }
+    
+    // these calls are not part of any formal tagged pointers specification
+    virtual uint64_t
+    GetValueBits ()
+    {
+        return (IsValid() ? m_value_bits : 0);
+    }
+    
+    virtual uint64_t
+    GetInfoBits ()
+    {
+        return (IsValid() ? m_info_bits : 0);
+    }
+    
+    virtual uint64_t
+    GetPayload ()
+    {
+        return (IsValid() ? m_payload : 0);
+    }
+
+private:
+    ConstString m_name;
+    uint8_t m_pointer_size;
+    bool m_valid;
+    uint64_t m_info_bits;
+    uint64_t m_value_bits;
+    uint64_t m_payload;
+};
+    
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCClassDescriptorV2_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp
new file mode 100644
index 000000000000..cd6ece297ed1
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp
@@ -0,0 +1,665 @@
+//===-- AppleObjCDeclVendor.cpp ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCDeclVendor.h"
+
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "Plugins/ExpressionParser/Clang/ASTDumper.h"
+#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclObjC.h"
+
+using namespace lldb_private;
+
+class lldb_private::AppleObjCExternalASTSource : public ClangExternalASTSourceCommon
+{
+public:
+    AppleObjCExternalASTSource (AppleObjCDeclVendor &decl_vendor) :
+        m_decl_vendor(decl_vendor)
+    {
+    }
+
+    bool
+    FindExternalVisibleDeclsByName(const clang::DeclContext *decl_ctx, clang::DeclarationName name) override
+    {
+        static unsigned int invocation_id = 0;
+        unsigned int current_id = invocation_id++;
+
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
+
+        if (log)
+        {
+            log->Printf("AppleObjCExternalASTSource::FindExternalVisibleDeclsByName[%u] on (ASTContext*)%p Looking for %s in (%sDecl*)%p",
+                        current_id,
+                        static_cast<void*>(&decl_ctx->getParentASTContext()),
+                        name.getAsString().c_str(), decl_ctx->getDeclKindName(),
+                        static_cast<const void*>(decl_ctx));
+        }
+
+        do
+        {
+            const clang::ObjCInterfaceDecl *interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
+
+            if (!interface_decl)
+                break;
+
+            clang::ObjCInterfaceDecl *non_const_interface_decl = const_cast<clang::ObjCInterfaceDecl*>(interface_decl);
+
+            if (!m_decl_vendor.FinishDecl(non_const_interface_decl))
+                break;
+
+            clang::DeclContext::lookup_result result = non_const_interface_decl->lookup(name);
+
+            return (result.size() != 0);
+        }
+        while(0);
+
+        SetNoExternalVisibleDeclsForName(decl_ctx, name);
+        return false;
+    }
+
+    void
+    CompleteType(clang::TagDecl *tag_decl) override
+    {
+        static unsigned int invocation_id = 0;
+        unsigned int current_id = invocation_id++;
+
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
+
+        if (log)
+        {
+            log->Printf("AppleObjCExternalASTSource::CompleteType[%u] on (ASTContext*)%p Completing (TagDecl*)%p named %s",
+                        current_id,
+                        static_cast<void*>(&tag_decl->getASTContext()),
+                        static_cast<void*>(tag_decl),
+                        tag_decl->getName().str().c_str());
+
+            log->Printf("  AOEAS::CT[%u] Before:", current_id);
+            ASTDumper dumper((clang::Decl*)tag_decl);
+            dumper.ToLog(log, "    [CT] ");
+        }
+
+        if (log)
+        {
+            log->Printf("  AOEAS::CT[%u] After:", current_id);
+            ASTDumper dumper((clang::Decl*)tag_decl);
+            dumper.ToLog(log, "    [CT] ");
+        }
+        return;
+    }
+
+    void
+    CompleteType(clang::ObjCInterfaceDecl *interface_decl) override
+    {
+        static unsigned int invocation_id = 0;
+        unsigned int current_id = invocation_id++;
+
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
+
+        if (log)
+        {
+            log->Printf("AppleObjCExternalASTSource::CompleteType[%u] on (ASTContext*)%p Completing (ObjCInterfaceDecl*)%p named %s",
+                        current_id,
+                        static_cast<void*>(&interface_decl->getASTContext()),
+                        static_cast<void*>(interface_decl),
+                        interface_decl->getName().str().c_str());
+
+            log->Printf("  AOEAS::CT[%u] Before:", current_id);
+            ASTDumper dumper((clang::Decl*)interface_decl);
+            dumper.ToLog(log, "    [CT] ");
+        }
+
+        m_decl_vendor.FinishDecl(interface_decl);
+
+        if (log)
+        {
+            log->Printf("  [CT] After:");
+            ASTDumper dumper((clang::Decl*)interface_decl);
+            dumper.ToLog(log, "    [CT] ");
+        }
+        return;
+    }
+
+    bool
+    layoutRecordType(const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
+                     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
+                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &BaseOffsets,
+                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &VirtualBaseOffsets) override
+    {
+        return false;
+    }
+
+    void
+    StartTranslationUnit(clang::ASTConsumer *Consumer) override
+    {
+        clang::TranslationUnitDecl *translation_unit_decl = m_decl_vendor.m_ast_ctx.getASTContext()->getTranslationUnitDecl();
+        translation_unit_decl->setHasExternalVisibleStorage();
+        translation_unit_decl->setHasExternalLexicalStorage();
+    }
+private:
+    AppleObjCDeclVendor                                    &m_decl_vendor;
+};
+
+AppleObjCDeclVendor::AppleObjCDeclVendor(ObjCLanguageRuntime &runtime) :
+    DeclVendor(),
+    m_runtime(runtime),
+    m_ast_ctx(runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple().getTriple().c_str()),
+    m_type_realizer_sp(m_runtime.GetEncodingToType())
+{
+    m_external_source = new AppleObjCExternalASTSource (*this);
+    llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> external_source_owning_ptr (m_external_source);
+    m_ast_ctx.getASTContext()->setExternalSource(external_source_owning_ptr);
+}
+
+clang::ObjCInterfaceDecl*
+AppleObjCDeclVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa)
+{
+    ISAToInterfaceMap::const_iterator iter = m_isa_to_interface.find(isa);
+    
+    if (iter != m_isa_to_interface.end())
+        return iter->second;
+    
+    clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext();
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor = m_runtime.GetClassDescriptorFromISA(isa);
+    
+    if (!descriptor)
+        return NULL;
+    
+    const ConstString &name(descriptor->GetClassName());
+    
+    clang::IdentifierInfo &identifier_info = ast_ctx->Idents.get(name.GetStringRef());
+
+    clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create(*ast_ctx,
+                                                                                ast_ctx->getTranslationUnitDecl(),
+                                                                                clang::SourceLocation(),
+                                                                                &identifier_info,
+                                                                                nullptr,
+                                                                                nullptr);
+    
+    ClangASTMetadata meta_data;
+    meta_data.SetISAPtr(isa);
+    m_external_source->SetMetadata(new_iface_decl, meta_data);
+    
+    new_iface_decl->setHasExternalVisibleStorage();
+    new_iface_decl->setHasExternalLexicalStorage();
+    
+    ast_ctx->getTranslationUnitDecl()->addDecl(new_iface_decl);
+    
+    m_isa_to_interface[isa] = new_iface_decl;
+    
+    return new_iface_decl;
+}
+
+class ObjCRuntimeMethodType
+{
+public:
+    ObjCRuntimeMethodType (const char *types) : m_is_valid(false)
+    {
+        const char *cursor = types;
+        enum ParserState {
+            Start = 0,
+            InType,
+            InPos
+        } state = Start;
+        const char *type = NULL;
+        int brace_depth = 0;
+        
+        uint32_t stepsLeft = 256;
+        
+        while (1)
+        {
+            if (--stepsLeft == 0)
+            {
+                m_is_valid = false;
+                return;
+            }
+            
+            switch (state)
+            {
+            case Start:
+                {
+                    switch (*cursor)
+                    {
+                    default:
+                        state = InType;
+                        type = cursor;
+                        break;
+                    case '\0':
+                        m_is_valid = true;
+                        return;
+                    case '0': case '1': case '2': case '3': case '4':
+                    case '5': case '6': case '7': case '8': case '9':
+                        m_is_valid = false;
+                        return;
+                    }
+                }
+                break;
+            case InType:
+                {
+                    switch (*cursor)
+                    {
+                    default:
+                        ++cursor;
+                        break;
+                    case '0': case '1': case '2': case '3': case '4':
+                    case '5': case '6': case '7': case '8': case '9':
+                        if (!brace_depth)
+                        {
+                            state = InPos;
+                            if (type)
+                            {
+                                m_type_vector.push_back(std::string(type, (cursor - type)));
+                            }
+                            else
+                            {
+                                m_is_valid = false;
+                                return;
+                            }
+                            type = NULL;
+                        }
+                        else
+                        {
+                            ++cursor;
+                        }
+                        break;
+                    case '[': case '{': case '(':
+                        ++brace_depth;
+                        ++cursor;
+                        break;
+                    case ']': case '}': case ')':
+                        if (!brace_depth)
+                        {
+                            m_is_valid = false;
+                            return;
+                        }
+                        --brace_depth;
+                        ++cursor;
+                        break;
+                    case '\0':
+                        m_is_valid = false;
+                        return;
+                    }
+                }
+                break;
+            case InPos:
+                {
+                    switch (*cursor)
+                    {
+                    default:
+                        state = InType;
+                        type = cursor;
+                        break;
+                    case '0': case '1': case '2': case '3': case '4':
+                    case '5': case '6': case '7': case '8': case '9':
+                        ++cursor;
+                        break;
+                    case '\0':
+                        m_is_valid = true;
+                        return;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    
+    clang::ObjCMethodDecl *BuildMethod (clang::ObjCInterfaceDecl *interface_decl, const char *name, bool instance, ObjCLanguageRuntime::EncodingToTypeSP type_realizer_sp)
+    {
+        if (!m_is_valid || m_type_vector.size() < 3)
+            return NULL;
+        
+        clang::ASTContext &ast_ctx(interface_decl->getASTContext());
+        
+        clang::QualType return_qual_type;
+        
+        const bool isInstance = instance;
+        const bool isVariadic = false;
+        const bool isSynthesized = false;
+        const bool isImplicitlyDeclared = true;
+        const bool isDefined = false;
+        const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
+        const bool HasRelatedResultType = false;
+        const bool for_expression = true;
+        
+        std::vector <clang::IdentifierInfo *> selector_components;
+        
+        const char *name_cursor = name;
+        bool is_zero_argument = true;
+        
+        
+        while (*name_cursor != '\0')
+        {
+            const char *colon_loc = strchr(name_cursor, ':');
+            if (!colon_loc)
+            {
+                selector_components.push_back(&ast_ctx.Idents.get(llvm::StringRef(name_cursor)));
+                break;
+            }
+            else
+            {
+                is_zero_argument = false;
+                selector_components.push_back(&ast_ctx.Idents.get(llvm::StringRef(name_cursor, colon_loc - name_cursor)));
+                name_cursor = colon_loc + 1;
+            }
+        }
+        
+        clang::Selector sel = ast_ctx.Selectors.getSelector(is_zero_argument ? 0 : selector_components.size(), selector_components.data());
+        
+        clang::QualType ret_type = ClangASTContext::GetQualType(type_realizer_sp->RealizeType(interface_decl->getASTContext(), m_type_vector[0].c_str(), for_expression));
+        
+        if (ret_type.isNull())
+            return NULL;
+        
+        clang::ObjCMethodDecl *ret = clang::ObjCMethodDecl::Create(ast_ctx,
+                                                                   clang::SourceLocation(),
+                                                                   clang::SourceLocation(),
+                                                                   sel,
+                                                                   ret_type,
+                                                                   NULL,
+                                                                   interface_decl,
+                                                                   isInstance,
+                                                                   isVariadic,
+                                                                   isSynthesized,
+                                                                   isImplicitlyDeclared,
+                                                                   isDefined,
+                                                                   impControl,
+                                                                   HasRelatedResultType);
+        
+        std::vector <clang::ParmVarDecl*> parm_vars;
+        
+        for (size_t ai = 3, ae = m_type_vector.size();
+             ai != ae;
+             ++ai)
+        {
+            const bool for_expression = true;
+            clang::QualType arg_type = ClangASTContext::GetQualType(type_realizer_sp->RealizeType(ast_ctx, m_type_vector[ai].c_str(), for_expression));
+            
+            if (arg_type.isNull())
+                return NULL; // well, we just wasted a bunch of time.  Wish we could delete the stuff we'd just made!
+
+            parm_vars.push_back(clang::ParmVarDecl::Create(ast_ctx,
+                                                           ret,
+                                                           clang::SourceLocation(),
+                                                           clang::SourceLocation(),
+                                                           NULL,
+                                                           arg_type,
+                                                           NULL,
+                                                           clang::SC_None,
+                                                           NULL));
+        }
+        
+        ret->setMethodParams(ast_ctx, llvm::ArrayRef<clang::ParmVarDecl*>(parm_vars), llvm::ArrayRef<clang::SourceLocation>());
+        
+        return ret;
+    }
+private:
+    typedef std::vector <std::string> TypeVector;
+    
+    TypeVector  m_type_vector;
+    bool        m_is_valid;
+};
+
+bool
+AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
+    
+    ClangASTMetadata *metadata = m_external_source->GetMetadata(interface_decl);
+    ObjCLanguageRuntime::ObjCISA objc_isa = 0;
+    if (metadata)
+     objc_isa = metadata->GetISAPtr();
+    
+    if (!objc_isa)
+        return false;
+    
+    if (!interface_decl->hasExternalVisibleStorage())
+        return true;
+    
+    interface_decl->startDefinition();
+    
+    interface_decl->setHasExternalVisibleStorage(false);
+    interface_decl->setHasExternalLexicalStorage(false);
+    
+    ObjCLanguageRuntime::ClassDescriptorSP descriptor = m_runtime.GetClassDescriptorFromISA(objc_isa);
+    
+    if (!descriptor)
+        return false;
+    
+    auto superclass_func = [interface_decl, this](ObjCLanguageRuntime::ObjCISA isa)
+    {
+        clang::ObjCInterfaceDecl *superclass_decl = GetDeclForISA(isa);
+        
+        if (!superclass_decl)
+            return;
+        
+        FinishDecl(superclass_decl);
+        clang::ASTContext *context = m_ast_ctx.getASTContext();
+        interface_decl->setSuperClass(
+                context->getTrivialTypeSourceInfo(context->getObjCInterfaceType(superclass_decl)));
+    };
+    
+    auto instance_method_func = [log, interface_decl, this](const char *name, const char *types) -> bool
+    {        
+        if (!name || !types)
+            return false; // skip this one
+
+        ObjCRuntimeMethodType method_type(types);
+        
+        clang::ObjCMethodDecl *method_decl = method_type.BuildMethod (interface_decl, name, true, m_type_realizer_sp);
+        
+        if (log)
+            log->Printf("[  AOTV::FD] Instance method [%s] [%s]", name, types);
+        
+        if (method_decl)
+            interface_decl->addDecl(method_decl);
+        
+        return false;
+    };
+    
+    auto class_method_func = [log, interface_decl, this](const char *name, const char *types) -> bool
+    {
+        if (!name || !types)
+            return false; // skip this one
+        
+        ObjCRuntimeMethodType method_type(types);
+        
+        clang::ObjCMethodDecl *method_decl = method_type.BuildMethod (interface_decl, name, false, m_type_realizer_sp);
+        
+        if (log)
+            log->Printf("[  AOTV::FD] Class method [%s] [%s]", name, types);
+        
+        if (method_decl)
+            interface_decl->addDecl(method_decl);
+        
+        return false;
+    };
+    
+    auto ivar_func = [log, interface_decl, this](const char *name, const char *type, lldb::addr_t offset_ptr, uint64_t size) -> bool
+    {
+        if (!name || !type)
+            return false;
+        
+        const bool for_expression = false;
+        
+        if (log)
+            log->Printf("[  AOTV::FD] Instance variable [%s] [%s], offset at %" PRIx64, name, type, offset_ptr);
+        
+        CompilerType ivar_type = m_runtime.GetEncodingToType()->RealizeType(m_ast_ctx, type, for_expression);
+        
+        if (ivar_type.IsValid())
+        {
+            clang::TypeSourceInfo * const type_source_info = nullptr;
+            const bool is_synthesized = false;
+            clang::ObjCIvarDecl *ivar_decl = clang::ObjCIvarDecl::Create (*m_ast_ctx.getASTContext(),
+                                                                          interface_decl,
+                                                                          clang::SourceLocation(),
+                                                                          clang::SourceLocation(),
+                                                                          &m_ast_ctx.getASTContext()->Idents.get(name),
+                                                                          ClangASTContext::GetQualType(ivar_type),
+                                                                          type_source_info,                      // TypeSourceInfo *
+                                                                          clang::ObjCIvarDecl::Public,
+                                                                          0,
+                                                                          is_synthesized);
+            
+            if (ivar_decl)
+            {
+                interface_decl->addDecl(ivar_decl);
+            }
+        }
+        
+        return false;
+    };
+    
+    if (log)
+    {
+        ASTDumper method_dumper ((clang::Decl*)interface_decl);
+        
+        log->Printf("[AppleObjCDeclVendor::FinishDecl] Finishing Objective-C interface for %s", descriptor->GetClassName().AsCString());
+    }
+    
+    
+    if (!descriptor->Describe(superclass_func,
+                              instance_method_func,
+                              class_method_func,
+                              ivar_func))
+        return false;
+    
+    if (log)
+    {
+        ASTDumper method_dumper ((clang::Decl*)interface_decl);
+        
+        log->Printf("[AppleObjCDeclVendor::FinishDecl] Finished Objective-C interface");
+        
+        method_dumper.ToLog(log, "  [AOTV::FD] ");
+    }
+    
+    return true;
+}
+
+uint32_t
+AppleObjCDeclVendor::FindDecls (const ConstString &name,
+                                bool append,
+                                uint32_t max_matches,
+                                std::vector <clang::NamedDecl *> &decls)
+{
+    static unsigned int invocation_id = 0;
+    unsigned int current_id = invocation_id++;
+    
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
+    
+    if (log)
+        log->Printf("AppleObjCDeclVendor::FindTypes [%u] ('%s', %s, %u, )",
+                    current_id,
+                    (const char*)name.AsCString(),
+                    append ? "true" : "false",
+                    max_matches);
+    
+    if (!append)
+        decls.clear();
+    
+    uint32_t ret = 0;
+    
+    do
+    {
+        // See if the type is already in our ASTContext.
+        
+        clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext();
+        
+        clang::IdentifierInfo &identifier_info = ast_ctx->Idents.get(name.GetStringRef());
+        clang::DeclarationName decl_name = ast_ctx->DeclarationNames.getIdentifier(&identifier_info);
+        
+        clang::DeclContext::lookup_result lookup_result = ast_ctx->getTranslationUnitDecl()->lookup(decl_name);
+        
+        if (!lookup_result.empty())
+        {
+            if (clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(lookup_result[0]))
+            {
+                if (log)
+                {
+                    clang::QualType result_iface_type = ast_ctx->getObjCInterfaceType(result_iface_decl);
+                    ASTDumper dumper(result_iface_type);
+                    
+                    uint64_t isa_value = LLDB_INVALID_ADDRESS;
+                    ClangASTMetadata *metadata = m_external_source->GetMetadata(result_iface_decl);
+                    if (metadata)
+                        isa_value = metadata->GetISAPtr();
+                    
+                    log->Printf("AOCTV::FT [%u] Found %s (isa 0x%" PRIx64 ") in the ASTContext",
+                                current_id,
+                                dumper.GetCString(),
+                                isa_value);
+                }
+                    
+                decls.push_back(result_iface_decl);
+                ret++;
+                break;
+            }
+            else
+            {
+                if (log)
+                    log->Printf("AOCTV::FT [%u] There's something in the ASTContext, but it's not something we know about",
+                                current_id);
+                break;
+            }
+        }
+        else if(log)
+        {
+            log->Printf("AOCTV::FT [%u] Couldn't find %s in the ASTContext",
+                        current_id,
+                        name.AsCString());
+        }
+        
+        // It's not.  If it exists, we have to put it into our ASTContext.
+                
+        ObjCLanguageRuntime::ObjCISA isa = m_runtime.GetISA(name);
+    
+        if (!isa)
+        {
+            if (log)
+                log->Printf("AOCTV::FT [%u] Couldn't find the isa",
+                            current_id);
+            
+            break;
+        }
+        
+        clang::ObjCInterfaceDecl *iface_decl = GetDeclForISA(isa);
+        
+        if (!iface_decl)
+        {
+            if (log)
+                log->Printf("AOCTV::FT [%u] Couldn't get the Objective-C interface for isa 0x%" PRIx64,
+                            current_id,
+                            (uint64_t)isa);
+            
+            break;
+        }
+        
+        if (log)
+        {
+            clang::QualType new_iface_type = ast_ctx->getObjCInterfaceType(iface_decl);
+            ASTDumper dumper(new_iface_type);
+            log->Printf("AOCTV::FT [%u] Created %s (isa 0x%" PRIx64 ")",
+                        current_id,
+                        dumper.GetCString(),
+                        (uint64_t)isa);
+        }
+        
+        decls.push_back(iface_decl);
+        ret++;
+        break;
+    } while (0);
+    
+    return ret;
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h
new file mode 100644
index 000000000000..88789c7b5a8d
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h
@@ -0,0 +1,55 @@
+//===-- AppleObjCDeclVendor.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCDeclVendor_h_
+#define liblldb_AppleObjCDeclVendor_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/DeclVendor.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+
+namespace lldb_private {
+
+class AppleObjCExternalASTSource;
+    
+class AppleObjCDeclVendor : public DeclVendor
+{
+public:
+    AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
+    
+    uint32_t
+    FindDecls(const ConstString &name,
+              bool append,
+              uint32_t max_matches,
+              std::vector <clang::NamedDecl *> &decls) override;
+        
+    friend class AppleObjCExternalASTSource;
+
+private:
+    clang::ObjCInterfaceDecl   *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa);
+    bool                        FinishDecl(clang::ObjCInterfaceDecl *decl);
+    
+    ObjCLanguageRuntime        &m_runtime;
+    ClangASTContext             m_ast_ctx;
+    ObjCLanguageRuntime::EncodingToTypeSP m_type_realizer_sp;
+    AppleObjCExternalASTSource *m_external_source;
+    
+    typedef llvm::DenseMap<ObjCLanguageRuntime::ObjCISA, clang::ObjCInterfaceDecl *> ISAToInterfaceMap;
+
+    ISAToInterfaceMap           m_isa_to_interface;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCDeclVendor_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
new file mode 100644
index 000000000000..cdb95250b2f4
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp
@@ -0,0 +1,541 @@
+//===-- AppleObjCRuntime.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCRuntime.h"
+#include "AppleObjCTrampolineHandler.h"
+
+#include "clang/AST/Type.h"
+
+#include "lldb/Breakpoint/BreakpointLocation.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleList.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+#include <vector>
+
+using namespace lldb;
+using namespace lldb_private;
+
+#define PO_FUNCTION_TIMEOUT_USEC 15*1000*1000
+
+AppleObjCRuntime::~AppleObjCRuntime()
+{
+}
+
+AppleObjCRuntime::AppleObjCRuntime(Process *process) :
+    ObjCLanguageRuntime (process),
+    m_read_objc_library (false),
+    m_objc_trampoline_handler_ap (),
+    m_Foundation_major()
+{
+    ReadObjCLibraryIfNeeded (process->GetTarget().GetImages());
+}
+
+bool
+AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &valobj)
+{
+    CompilerType compiler_type(valobj.GetCompilerType());
+    bool is_signed;
+    // ObjC objects can only be pointers (or numbers that actually represents pointers
+    // but haven't been typecast, because reasons..)
+    if (!compiler_type.IsIntegerType (is_signed) && !compiler_type.IsPointerType ())
+        return false;
+    
+    // Make the argument list: we pass one arg, the address of our pointer, to the print function.
+    Value val;
+    
+    if (!valobj.ResolveValue(val.GetScalar()))
+        return false;
+    
+    ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+    return GetObjectDescription(str, val, exe_ctx.GetBestExecutionContextScope());
+                   
+}
+bool
+AppleObjCRuntime::GetObjectDescription (Stream &strm, Value &value, ExecutionContextScope *exe_scope)
+{
+    if (!m_read_objc_library)
+        return false;
+        
+    ExecutionContext exe_ctx;
+    exe_scope->CalculateExecutionContext(exe_ctx);
+    Process *process = exe_ctx.GetProcessPtr();
+    if (!process)
+        return false;
+    
+    // We need other parts of the exe_ctx, but the processes have to match.
+    assert (m_process == process);
+    
+    // Get the function address for the print function.
+    const Address *function_address = GetPrintForDebuggerAddr();
+    if (!function_address)
+        return false;
+    
+    Target *target = exe_ctx.GetTargetPtr();
+    CompilerType compiler_type = value.GetCompilerType();
+    if (compiler_type)
+    {
+        if (!ClangASTContext::IsObjCObjectPointerType(compiler_type))
+        {
+            strm.Printf ("Value doesn't point to an ObjC object.\n");
+            return false;
+        }
+    }
+    else 
+    {
+        // If it is not a pointer, see if we can make it into a pointer.
+        ClangASTContext *ast_context = target->GetScratchClangASTContext();
+        CompilerType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID);
+        if (!opaque_type)
+            opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+        //value.SetContext(Value::eContextTypeClangType, opaque_type_ptr);
+        value.SetCompilerType (opaque_type);
+    }
+
+    ValueList arg_value_list;
+    arg_value_list.PushValue(value);
+    
+    // This is the return value:
+    ClangASTContext *ast_context = target->GetScratchClangASTContext();
+    
+    CompilerType return_compiler_type = ast_context->GetCStringType(true);
+    Value ret;
+//    ret.SetContext(Value::eContextTypeClangType, return_compiler_type);
+    ret.SetCompilerType (return_compiler_type);
+    
+    if (exe_ctx.GetFramePtr() == NULL)
+    {
+        Thread *thread = exe_ctx.GetThreadPtr();
+        if (thread == NULL)
+        {
+            exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread());
+            thread = exe_ctx.GetThreadPtr();
+        }
+        if (thread)
+        {
+            exe_ctx.SetFrameSP(thread->GetSelectedFrame());
+        }
+    }
+    
+    // Now we're ready to call the function:
+    
+    StreamString error_stream;
+    lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS;
+
+    if (!m_print_object_caller_up)
+    {
+        Error error;
+         m_print_object_caller_up.reset(exe_scope->CalculateTarget()->GetFunctionCallerForLanguage (eLanguageTypeObjC,
+                                                                                                    return_compiler_type,
+                                                                                                    *function_address,
+                                                                                                    arg_value_list,
+                                                                                                    "objc-object-description",
+                                                                                                    error));
+        if (error.Fail())
+        {
+            m_print_object_caller_up.reset();
+            strm.Printf("Could not get function runner to call print for debugger function: %s.", error.AsCString());
+            return false;
+        }
+        m_print_object_caller_up->InsertFunction(exe_ctx, wrapper_struct_addr, error_stream);
+    }
+    else
+    {
+        m_print_object_caller_up->WriteFunctionArguments(exe_ctx,
+                                                         wrapper_struct_addr,
+                                                         arg_value_list,
+                                                         error_stream);
+    }
+
+    
+
+    EvaluateExpressionOptions options;
+    options.SetUnwindOnError(true);
+    options.SetTryAllThreads(true);
+    options.SetStopOthers(true);
+    options.SetIgnoreBreakpoints(true);
+    options.SetTimeoutUsec(PO_FUNCTION_TIMEOUT_USEC);
+    
+    ExpressionResults results = m_print_object_caller_up->ExecuteFunction (exe_ctx,
+                                                                           &wrapper_struct_addr,
+                                                                           options,
+                                                                           error_stream,
+                                                                           ret);
+    if (results != eExpressionCompleted)
+    {
+        strm.Printf("Error evaluating Print Object function: %d.\n", results);
+        return false;
+    }
+       
+    addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
+    
+    char buf[512];
+    size_t cstr_len = 0;    
+    size_t full_buffer_len = sizeof (buf) - 1;
+    size_t curr_len = full_buffer_len;
+    while (curr_len == full_buffer_len)
+    {
+        Error error;
+        curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf, sizeof(buf), error);
+        strm.Write (buf, curr_len);
+        cstr_len += curr_len;
+    }
+    return cstr_len > 0;
+}
+
+lldb::ModuleSP
+AppleObjCRuntime::GetObjCModule ()
+{
+    ModuleSP module_sp (m_objc_module_wp.lock());
+    if (module_sp)
+        return module_sp;
+
+    Process *process = GetProcess();
+    if (process)
+    {
+        const ModuleList& modules = process->GetTarget().GetImages();
+        for (uint32_t idx = 0; idx < modules.GetSize(); idx++)
+        {
+            module_sp = modules.GetModuleAtIndex(idx);
+            if (AppleObjCRuntime::AppleIsModuleObjCLibrary(module_sp))
+            {
+                m_objc_module_wp = module_sp;
+                return module_sp;
+            }
+        }
+    }
+    return ModuleSP();
+}
+
+Address *
+AppleObjCRuntime::GetPrintForDebuggerAddr()
+{
+    if (!m_PrintForDebugger_addr.get())
+    {
+        const ModuleList &modules = m_process->GetTarget().GetImages();
+        
+        SymbolContextList contexts;
+        SymbolContext context;
+        
+        if ((!modules.FindSymbolsWithNameAndType(ConstString ("_NSPrintForDebugger"), eSymbolTypeCode, contexts)) &&
+           (!modules.FindSymbolsWithNameAndType(ConstString ("_CFPrintForDebugger"), eSymbolTypeCode, contexts)))
+            return NULL;
+        
+        contexts.GetContextAtIndex(0, context);
+        
+        m_PrintForDebugger_addr.reset(new Address(context.symbol->GetAddress()));
+    }
+    
+    return m_PrintForDebugger_addr.get();
+}
+
+bool
+AppleObjCRuntime::CouldHaveDynamicValue (ValueObject &in_value)
+{
+    return in_value.GetCompilerType().IsPossibleDynamicType (NULL,
+                                                          false, // do not check C++
+                                                          true); // check ObjC
+}
+
+bool
+AppleObjCRuntime::GetDynamicTypeAndAddress (ValueObject &in_value, 
+                                            lldb::DynamicValueType use_dynamic, 
+                                            TypeAndOrName &class_type_or_name, 
+                                            Address &address,
+                                            Value::ValueType &value_type)
+{
+    return false;
+}
+
+TypeAndOrName
+AppleObjCRuntime::FixUpDynamicType (const TypeAndOrName& type_and_or_name,
+                                    ValueObject& static_value)
+{
+    CompilerType static_type(static_value.GetCompilerType());
+    Flags static_type_flags(static_type.GetTypeInfo());
+    
+    TypeAndOrName ret(type_and_or_name);
+    if (type_and_or_name.HasType())
+    {
+        // The type will always be the type of the dynamic object.  If our parent's type was a pointer,
+        // then our type should be a pointer to the type of the dynamic object.  If a reference, then the original type
+        // should be okay...
+        CompilerType orig_type = type_and_or_name.GetCompilerType();
+        CompilerType corrected_type = orig_type;
+        if (static_type_flags.AllSet(eTypeIsPointer))
+            corrected_type = orig_type.GetPointerType ();
+        ret.SetCompilerType(corrected_type);
+    }
+    else
+    {
+        // If we are here we need to adjust our dynamic type name to include the correct & or * symbol
+        std::string corrected_name (type_and_or_name.GetName().GetCString());
+        if (static_type_flags.AllSet(eTypeIsPointer))
+            corrected_name.append(" *");
+        // the parent type should be a correctly pointer'ed or referenc'ed type
+        ret.SetCompilerType(static_type);
+        ret.SetName(corrected_name.c_str());
+    }
+    return ret;
+}
+
+bool
+AppleObjCRuntime::AppleIsModuleObjCLibrary (const ModuleSP &module_sp)
+{
+    if (module_sp)
+    {
+        const FileSpec &module_file_spec = module_sp->GetFileSpec();
+        static ConstString ObjCName ("libobjc.A.dylib");
+        
+        if (module_file_spec)
+        {
+            if (module_file_spec.GetFilename() == ObjCName)
+                return true;
+        }
+    }
+    return false;
+}
+
+// we use the version of Foundation to make assumptions about the ObjC runtime on a target
+uint32_t
+AppleObjCRuntime::GetFoundationVersion ()
+{
+    if (!m_Foundation_major.hasValue())
+    {
+        const ModuleList& modules = m_process->GetTarget().GetImages();
+        uint32_t major = UINT32_MAX;
+        for (uint32_t idx = 0; idx < modules.GetSize(); idx++)
+        {
+            lldb::ModuleSP module_sp = modules.GetModuleAtIndex(idx);
+            if (!module_sp)
+                continue;
+            if (strcmp(module_sp->GetFileSpec().GetFilename().AsCString(""),"Foundation") == 0)
+            {
+                module_sp->GetVersion(&major,1);
+                m_Foundation_major = major;
+                return major;
+            }
+        }
+        return LLDB_INVALID_MODULE_VERSION;
+    }
+    else
+        return m_Foundation_major.getValue();
+}
+
+bool
+AppleObjCRuntime::IsModuleObjCLibrary (const ModuleSP &module_sp)
+{
+    return AppleIsModuleObjCLibrary(module_sp);
+}
+
+bool
+AppleObjCRuntime::ReadObjCLibrary (const ModuleSP &module_sp)
+{
+    // Maybe check here and if we have a handler already, and the UUID of this module is the same as the one in the
+    // current module, then we don't have to reread it?
+    m_objc_trampoline_handler_ap.reset(new AppleObjCTrampolineHandler (m_process->shared_from_this(), module_sp));
+    if (m_objc_trampoline_handler_ap.get() != NULL)
+    {
+        m_read_objc_library = true;
+        return true;
+    }
+    else
+        return false;
+}
+
+ThreadPlanSP
+AppleObjCRuntime::GetStepThroughTrampolinePlan (Thread &thread, bool stop_others)
+{
+    ThreadPlanSP thread_plan_sp;
+    if (m_objc_trampoline_handler_ap.get())
+        thread_plan_sp = m_objc_trampoline_handler_ap->GetStepThroughDispatchPlan (thread, stop_others);
+    return thread_plan_sp;
+}
+
+//------------------------------------------------------------------
+// Static Functions
+//------------------------------------------------------------------
+ObjCLanguageRuntime::ObjCRuntimeVersions
+AppleObjCRuntime::GetObjCVersion (Process *process, ModuleSP &objc_module_sp)
+{
+    if (!process)
+        return ObjCRuntimeVersions::eObjC_VersionUnknown;
+
+    Target &target = process->GetTarget();
+    if (target.GetArchitecture().GetTriple().getVendor() != llvm::Triple::VendorType::Apple)
+        return ObjCRuntimeVersions::eObjC_VersionUnknown;
+
+    const ModuleList &target_modules = target.GetImages();
+    Mutex::Locker modules_locker(target_modules.GetMutex());
+    
+    size_t num_images = target_modules.GetSize();
+    for (size_t i = 0; i < num_images; i++)
+    {
+        ModuleSP module_sp = target_modules.GetModuleAtIndexUnlocked(i);
+        // One tricky bit here is that we might get called as part of the initial module loading, but
+        // before all the pre-run libraries get winnowed from the module list.  So there might actually
+        // be an old and incorrect ObjC library sitting around in the list, and we don't want to look at that.
+        // That's why we call IsLoadedInTarget.
+        
+        if (AppleIsModuleObjCLibrary (module_sp) && module_sp->IsLoadedInTarget(&target))
+        {
+            objc_module_sp = module_sp;
+            ObjectFile *ofile = module_sp->GetObjectFile();
+            if (!ofile)
+                return ObjCRuntimeVersions::eObjC_VersionUnknown;
+            
+            SectionList *sections = module_sp->GetSectionList();
+            if (!sections)
+                return ObjCRuntimeVersions::eObjC_VersionUnknown;
+            SectionSP v1_telltale_section_sp = sections->FindSectionByName(ConstString ("__OBJC"));
+            if (v1_telltale_section_sp)
+            {
+                return ObjCRuntimeVersions::eAppleObjC_V1;
+            }
+            return ObjCRuntimeVersions::eAppleObjC_V2;
+        }
+    }
+            
+    return ObjCRuntimeVersions::eObjC_VersionUnknown;
+}
+
+void
+AppleObjCRuntime::SetExceptionBreakpoints ()
+{
+    const bool catch_bp = false;
+    const bool throw_bp = true;
+    const bool is_internal = true;
+    
+    if (!m_objc_exception_bp_sp)
+    {
+        m_objc_exception_bp_sp = LanguageRuntime::CreateExceptionBreakpoint (m_process->GetTarget(),
+                                                                            GetLanguageType(),
+                                                                            catch_bp, 
+                                                                            throw_bp, 
+                                                                            is_internal);
+        if (m_objc_exception_bp_sp)
+            m_objc_exception_bp_sp->SetBreakpointKind("ObjC exception");
+    }
+    else
+        m_objc_exception_bp_sp->SetEnabled(true);
+}
+
+
+void
+AppleObjCRuntime::ClearExceptionBreakpoints ()
+{
+    if (!m_process)
+        return;
+    
+    if (m_objc_exception_bp_sp.get())
+    {
+        m_objc_exception_bp_sp->SetEnabled (false);
+    }
+}
+
+bool
+AppleObjCRuntime::ExceptionBreakpointsAreSet ()
+{
+    return m_objc_exception_bp_sp && m_objc_exception_bp_sp->IsEnabled();
+}
+
+bool
+AppleObjCRuntime::ExceptionBreakpointsExplainStop (lldb::StopInfoSP stop_reason)
+{
+    if (!m_process)
+        return false;
+    
+    if (!stop_reason || 
+        stop_reason->GetStopReason() != eStopReasonBreakpoint)
+        return false;
+    
+    uint64_t break_site_id = stop_reason->GetValue();
+    return m_process->GetBreakpointSiteList().BreakpointSiteContainsBreakpoint (break_site_id,
+                                                                                m_objc_exception_bp_sp->GetID());
+}
+
+bool
+AppleObjCRuntime::CalculateHasNewLiteralsAndIndexing()
+{
+    if (!m_process)
+        return false;
+    
+    Target &target(m_process->GetTarget());
+    
+    static ConstString s_method_signature("-[NSDictionary objectForKeyedSubscript:]");
+    static ConstString s_arclite_method_signature("__arclite_objectForKeyedSubscript");
+    
+    SymbolContextList sc_list;
+    
+    if (target.GetImages().FindSymbolsWithNameAndType(s_method_signature, eSymbolTypeCode, sc_list) ||
+        target.GetImages().FindSymbolsWithNameAndType(s_arclite_method_signature, eSymbolTypeCode, sc_list))
+        return true;
+    else
+        return false;
+}
+
+lldb::SearchFilterSP
+AppleObjCRuntime::CreateExceptionSearchFilter ()
+{
+    Target &target = m_process->GetTarget();
+    
+    if (target.GetArchitecture().GetTriple().getVendor() == llvm::Triple::Apple)
+    {
+        FileSpecList filter_modules;
+        filter_modules.Append(FileSpec("libobjc.A.dylib", false));
+        return target.GetSearchFilterForModuleList(&filter_modules);
+    }
+    else
+    {
+        return LanguageRuntime::CreateExceptionSearchFilter();
+    }
+}
+
+void
+AppleObjCRuntime::ReadObjCLibraryIfNeeded (const ModuleList &module_list)
+{
+    if (!HasReadObjCLibrary ())
+    {
+        Mutex::Locker locker (module_list.GetMutex ());
+
+        size_t num_modules = module_list.GetSize();
+        for (size_t i = 0; i < num_modules; i++)
+        {
+            auto mod = module_list.GetModuleAtIndex (i);
+            if (IsModuleObjCLibrary (mod))
+            {
+                ReadObjCLibrary (mod);
+                break;
+            }
+        }
+    }
+}
+
+void
+AppleObjCRuntime::ModulesDidLoad (const ModuleList &module_list)
+{
+    ReadObjCLibraryIfNeeded (module_list);
+}
+
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h
new file mode 100644
index 000000000000..342824e79b1f
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h
@@ -0,0 +1,148 @@
+//===-- AppleObjCRuntime.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCRuntime_h_
+#define liblldb_AppleObjCRuntime_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "llvm/ADT/Optional.h"
+
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Target/LanguageRuntime.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "AppleObjCTrampolineHandler.h"
+#include "AppleThreadPlanStepThroughObjCTrampoline.h"
+
+namespace lldb_private {
+    
+class AppleObjCRuntime :
+        public lldb_private::ObjCLanguageRuntime
+{
+public:
+    ~AppleObjCRuntime() override;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    // Note there is no CreateInstance, Initialize & Terminate functions here, because
+    // you can't make an instance of this generic runtime.
+
+    static bool classof(const ObjCLanguageRuntime* runtime)
+    {
+        switch (runtime->GetRuntimeVersion())
+        {
+            case ObjCRuntimeVersions::eAppleObjC_V1:
+            case ObjCRuntimeVersions::eAppleObjC_V2:
+                return true;
+            default:
+                return false;
+        }
+    }
+    
+    // These are generic runtime functions:
+    bool
+    GetObjectDescription (Stream &str, Value &value, ExecutionContextScope *exe_scope) override;
+    
+    bool
+    GetObjectDescription (Stream &str, ValueObject &object) override;
+    
+    bool
+    CouldHaveDynamicValue (ValueObject &in_value) override;
+    
+    bool
+    GetDynamicTypeAndAddress (ValueObject &in_value, 
+                              lldb::DynamicValueType use_dynamic, 
+                              TypeAndOrName &class_type_or_name, 
+                              Address &address,
+                              Value::ValueType &value_type) override;
+
+    TypeAndOrName
+    FixUpDynamicType (const TypeAndOrName& type_and_or_name,
+                      ValueObject& static_value) override;
+    
+    // These are the ObjC specific functions.
+    
+    bool
+    IsModuleObjCLibrary (const lldb::ModuleSP &module_sp) override;
+    
+    bool
+    ReadObjCLibrary (const lldb::ModuleSP &module_sp) override;
+
+    bool
+    HasReadObjCLibrary ()  override
+    {
+        return m_read_objc_library;
+    }
+    
+    lldb::ThreadPlanSP
+    GetStepThroughTrampolinePlan (Thread &thread, bool stop_others) override;
+    
+    // Get the "libobjc.A.dylib" module from the current target if we can find
+    // it, also cache it once it is found to ensure quick lookups.
+    lldb::ModuleSP
+    GetObjCModule ();
+    
+    // Sync up with the target
+
+    void
+    ModulesDidLoad (const ModuleList &module_list) override;
+
+    void
+    SetExceptionBreakpoints() override;
+
+    void
+    ClearExceptionBreakpoints() override;
+    
+    bool
+    ExceptionBreakpointsAreSet() override;
+    
+    bool
+    ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
+    
+    lldb::SearchFilterSP
+    CreateExceptionSearchFilter() override;
+    
+    uint32_t
+    GetFoundationVersion();
+    
+protected:
+    // Call CreateInstance instead.
+    AppleObjCRuntime(Process *process);
+
+    bool
+    CalculateHasNewLiteralsAndIndexing() override;
+    
+    static bool
+    AppleIsModuleObjCLibrary(const lldb::ModuleSP &module_sp);
+
+    static ObjCRuntimeVersions
+    GetObjCVersion(Process *process, lldb::ModuleSP &objc_module_sp);
+
+    void
+    ReadObjCLibraryIfNeeded(const ModuleList &module_list);
+
+    Address *
+    GetPrintForDebuggerAddr();
+    
+    std::unique_ptr<Address>  m_PrintForDebugger_addr;
+    bool m_read_objc_library;
+    std::unique_ptr<lldb_private::AppleObjCTrampolineHandler> m_objc_trampoline_handler_ap;
+    lldb::BreakpointSP m_objc_exception_bp_sp;
+    lldb::ModuleWP m_objc_module_wp;
+    std::unique_ptr<FunctionCaller>  m_print_object_caller_up;
+    
+    llvm::Optional<uint32_t> m_Foundation_major;
+};
+    
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCRuntime_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
new file mode 100644
index 000000000000..59b28b63f6b3
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp
@@ -0,0 +1,459 @@
+//===-- AppleObjCRuntimeV1.cpp --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCRuntimeV1.h"
+#include "AppleObjCTrampolineHandler.h"
+#include "AppleObjCDeclVendor.h"
+
+#include "clang/AST/Type.h"
+
+#include "lldb/Breakpoint/BreakpointLocation.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+#include <vector>
+
+using namespace lldb;
+using namespace lldb_private;
+
+AppleObjCRuntimeV1::AppleObjCRuntimeV1(Process *process) :
+    AppleObjCRuntime (process),
+    m_hash_signature (),
+    m_isa_hash_table_ptr (LLDB_INVALID_ADDRESS)
+{
+}
+
+// for V1 runtime we just try to return a class name as that is the minimum level of support
+// required for the data formatters to work
+bool
+AppleObjCRuntimeV1::GetDynamicTypeAndAddress (ValueObject &in_value,
+                                              lldb::DynamicValueType use_dynamic,
+                                              TypeAndOrName &class_type_or_name,
+                                              Address &address,
+                                              Value::ValueType &value_type)
+{
+    class_type_or_name.Clear();
+    value_type = Value::ValueType::eValueTypeScalar;
+    if (CouldHaveDynamicValue(in_value))
+    {
+        auto class_descriptor(GetClassDescriptor(in_value));
+        if (class_descriptor && class_descriptor->IsValid() && class_descriptor->GetClassName())
+        {
+            const addr_t object_ptr = in_value.GetPointerValue();
+            address.SetRawAddress(object_ptr);
+            class_type_or_name.SetName(class_descriptor->GetClassName());
+        }
+    }
+    return class_type_or_name.IsEmpty() == false;
+}
+
+//------------------------------------------------------------------
+// Static Functions
+//------------------------------------------------------------------
+lldb_private::LanguageRuntime *
+AppleObjCRuntimeV1::CreateInstance (Process *process, lldb::LanguageType language)
+{
+    // FIXME: This should be a MacOS or iOS process, and we need to look for the OBJC section to make
+    // sure we aren't using the V1 runtime.
+    if (language == eLanguageTypeObjC)
+    {
+        ModuleSP objc_module_sp;
+        
+        if (AppleObjCRuntime::GetObjCVersion (process, objc_module_sp) == ObjCRuntimeVersions::eAppleObjC_V1)
+            return new AppleObjCRuntimeV1 (process);
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+
+void
+AppleObjCRuntimeV1::Initialize()
+{
+    PluginManager::RegisterPlugin (GetPluginNameStatic(),
+                                   "Apple Objective C Language Runtime - Version 1",
+                                   CreateInstance);    
+}
+
+void
+AppleObjCRuntimeV1::Terminate()
+{
+    PluginManager::UnregisterPlugin (CreateInstance);
+}
+
+lldb_private::ConstString
+AppleObjCRuntimeV1::GetPluginNameStatic()
+{
+    static ConstString g_name("apple-objc-v1");
+    return g_name;
+}
+
+//------------------------------------------------------------------
+// PluginInterface protocol
+//------------------------------------------------------------------
+ConstString
+AppleObjCRuntimeV1::GetPluginName()
+{
+    return GetPluginNameStatic();
+}
+
+uint32_t
+AppleObjCRuntimeV1::GetPluginVersion()
+{
+    return 1;
+}
+
+BreakpointResolverSP
+AppleObjCRuntimeV1::CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp)
+{
+    BreakpointResolverSP resolver_sp;
+    
+    if (throw_bp)
+        resolver_sp.reset (new BreakpointResolverName (bkpt,
+                                                       "objc_exception_throw",
+                                                       eFunctionNameTypeBase,
+                                                       eLanguageTypeUnknown,
+                                                       Breakpoint::Exact,
+                                                       eLazyBoolNo));
+    // FIXME: don't do catch yet.
+    return resolver_sp;
+}
+
+struct BufStruct {
+    char contents[2048];
+};
+
+UtilityFunction *
+AppleObjCRuntimeV1::CreateObjectChecker(const char *name)
+{
+    std::unique_ptr<BufStruct> buf(new BufStruct);
+    
+    assert(snprintf(&buf->contents[0], sizeof(buf->contents),
+                    "struct __objc_class                                                    \n"
+                    "{                                                                      \n"
+                    "   struct __objc_class *isa;                                           \n"
+                    "   struct __objc_class *super_class;                                   \n"
+                    "   const char *name;                                                   \n"
+                    "   // rest of struct elided because unused                             \n"
+                    "};                                                                     \n"
+                    "                                                                       \n"
+                    "struct __objc_object                                                   \n"
+                    "{                                                                      \n"
+                    "   struct __objc_class *isa;                                           \n"
+                    "};                                                                     \n"
+                    "                                                                       \n"
+                    "extern \"C\" void                                                      \n"
+                    "%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector)                  \n"
+                    "{                                                                      \n"
+                    "   struct __objc_object *obj = (struct __objc_object*)$__lldb_arg_obj; \n"
+                    "   (int)strlen(obj->isa->name);                                        \n"
+                    "}                                                                      \n",
+                    name) < (int)sizeof(buf->contents));
+
+    Error error;
+    return GetTargetRef().GetUtilityFunctionForLanguage(buf->contents, eLanguageTypeObjC, name, error);
+}
+
+AppleObjCRuntimeV1::ClassDescriptorV1::ClassDescriptorV1 (ValueObject &isa_pointer)
+{
+    Initialize (isa_pointer.GetValueAsUnsigned(0),
+                isa_pointer.GetProcessSP());
+}
+
+AppleObjCRuntimeV1::ClassDescriptorV1::ClassDescriptorV1 (ObjCISA isa, lldb::ProcessSP process_sp)
+{
+    Initialize (isa, process_sp);
+}
+
+void
+AppleObjCRuntimeV1::ClassDescriptorV1::Initialize (ObjCISA isa, lldb::ProcessSP process_sp)
+{
+    if (!isa || !process_sp)
+    {
+        m_valid = false;
+        return;
+    }
+    
+    m_valid = true;
+    
+    Error error;
+    
+    m_isa = process_sp->ReadPointerFromMemory(isa, error);
+    
+    if (error.Fail())
+    {
+        m_valid = false;
+        return;
+    }
+    
+    uint32_t ptr_size = process_sp->GetAddressByteSize();
+    
+    if (!IsPointerValid(m_isa,ptr_size))
+    {
+        m_valid = false;
+        return;
+    }
+
+    m_parent_isa = process_sp->ReadPointerFromMemory(m_isa + ptr_size,error);
+    
+    if (error.Fail())
+    {
+        m_valid = false;
+        return;
+    }
+    
+    if (!IsPointerValid(m_parent_isa,ptr_size,true))
+    {
+        m_valid = false;
+        return;
+    }
+    
+    lldb::addr_t name_ptr = process_sp->ReadPointerFromMemory(m_isa + 2 * ptr_size,error);
+    
+    if (error.Fail())
+    {
+        m_valid = false;
+        return;
+    }
+    
+    lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024, 0));
+    
+    size_t count = process_sp->ReadCStringFromMemory(name_ptr, (char*)buffer_sp->GetBytes(), 1024, error);
+    
+    if (error.Fail())
+    {
+        m_valid = false;
+        return;
+    }
+    
+    if (count)
+        m_name = ConstString((char*)buffer_sp->GetBytes());
+    else
+        m_name = ConstString();
+    
+    m_instance_size = process_sp->ReadUnsignedIntegerFromMemory(m_isa + 5 * ptr_size, ptr_size, 0, error);
+    
+    if (error.Fail())
+    {
+        m_valid = false;
+        return;
+    }
+    
+    m_process_wp = lldb::ProcessWP(process_sp);
+}
+
+AppleObjCRuntime::ClassDescriptorSP
+AppleObjCRuntimeV1::ClassDescriptorV1::GetSuperclass ()
+{
+    if (!m_valid)
+        return AppleObjCRuntime::ClassDescriptorSP();
+    ProcessSP process_sp = m_process_wp.lock();
+    if (!process_sp)
+        return AppleObjCRuntime::ClassDescriptorSP();
+    return ObjCLanguageRuntime::ClassDescriptorSP(new AppleObjCRuntimeV1::ClassDescriptorV1(m_parent_isa,process_sp));
+}
+
+AppleObjCRuntime::ClassDescriptorSP
+AppleObjCRuntimeV1::ClassDescriptorV1::GetMetaclass () const
+{
+    return ClassDescriptorSP();
+}
+
+bool
+AppleObjCRuntimeV1::ClassDescriptorV1::Describe (std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+                                                 std::function <bool (const char *, const char *)> const &instance_method_func,
+                                                 std::function <bool (const char *, const char *)> const &class_method_func,
+                                                 std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> const &ivar_func) const
+{
+    return false;
+}
+
+lldb::addr_t
+AppleObjCRuntimeV1::GetISAHashTablePointer ()
+{
+    if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS)
+    {
+        ModuleSP objc_module_sp(GetObjCModule());
+        
+        if (!objc_module_sp)
+            return LLDB_INVALID_ADDRESS;
+        
+        static ConstString g_objc_debug_class_hash("_objc_debug_class_hash");
+        
+        const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_objc_debug_class_hash, lldb::eSymbolTypeData);
+        if (symbol && symbol->ValueIsAddress())
+        {
+            Process *process = GetProcess();
+            if (process)
+            {
+
+                lldb::addr_t objc_debug_class_hash_addr = symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
+            
+                if (objc_debug_class_hash_addr != LLDB_INVALID_ADDRESS)
+                {
+                    Error error;
+                    lldb::addr_t objc_debug_class_hash_ptr = process->ReadPointerFromMemory(objc_debug_class_hash_addr, error);
+                    if (objc_debug_class_hash_ptr != 0 &&
+                        objc_debug_class_hash_ptr != LLDB_INVALID_ADDRESS)
+                    {
+                        m_isa_hash_table_ptr = objc_debug_class_hash_ptr;
+                    }
+                }
+            }
+        }
+    }
+    return m_isa_hash_table_ptr;
+}
+
+void
+AppleObjCRuntimeV1::UpdateISAToDescriptorMapIfNeeded()
+{
+    // TODO: implement HashTableSignature...
+    Process *process = GetProcess();
+    
+    if (process)
+    {
+        // Update the process stop ID that indicates the last time we updated the
+        // map, whether it was successful or not.
+        m_isa_to_descriptor_stop_id = process->GetStopID();
+        
+        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+        
+        ProcessSP process_sp = process->shared_from_this();
+        
+        ModuleSP objc_module_sp(GetObjCModule());
+        
+        if (!objc_module_sp)
+            return;
+        
+        uint32_t isa_count = 0;
+        
+        lldb::addr_t hash_table_ptr = GetISAHashTablePointer ();
+        if (hash_table_ptr != LLDB_INVALID_ADDRESS)
+        {
+            // Read the NXHashTable struct:
+            //
+            // typedef struct {
+            //     const NXHashTablePrototype *prototype;
+            //     unsigned   count;
+            //     unsigned   nbBuckets;
+            //     void       *buckets;
+            //     const void *info;
+            // } NXHashTable;
+
+            Error error;
+            DataBufferHeap buffer(1024, 0);
+            if (process->ReadMemory(hash_table_ptr, buffer.GetBytes(), 20, error) == 20)
+            {
+                const uint32_t addr_size = m_process->GetAddressByteSize();
+                const ByteOrder byte_order = m_process->GetByteOrder();
+                DataExtractor data (buffer.GetBytes(), buffer.GetByteSize(), byte_order, addr_size);
+                lldb::offset_t offset = addr_size; // Skip prototype
+                const uint32_t count = data.GetU32(&offset);
+                const uint32_t num_buckets = data.GetU32(&offset);
+                const addr_t buckets_ptr = data.GetPointer(&offset);
+                if (m_hash_signature.NeedsUpdate (count, num_buckets, buckets_ptr))
+                {
+                    m_hash_signature.UpdateSignature (count, num_buckets, buckets_ptr);
+
+                    const uint32_t data_size = num_buckets * 2 * sizeof(uint32_t);
+                    buffer.SetByteSize(data_size);
+                    
+                    if (process->ReadMemory(buckets_ptr, buffer.GetBytes(), data_size, error) == data_size)
+                    {
+                        data.SetData(buffer.GetBytes(), buffer.GetByteSize(), byte_order);
+                        offset = 0;
+                        for (uint32_t bucket_idx = 0; bucket_idx < num_buckets; ++bucket_idx)
+                        {
+                            const uint32_t bucket_isa_count = data.GetU32 (&offset);
+                            const lldb::addr_t bucket_data = data.GetU32 (&offset);
+                            
+
+                            if (bucket_isa_count == 0)
+                                continue;
+                            
+                            isa_count += bucket_isa_count;
+
+                            ObjCISA isa;
+                            if (bucket_isa_count == 1)
+                            {
+                                // When we only have one entry in the bucket, the bucket data is the "isa"
+                                isa = bucket_data;
+                                if (isa)
+                                {
+                                    if (!ISAIsCached(isa))
+                                    {
+                                        ClassDescriptorSP descriptor_sp (new ClassDescriptorV1(isa, process_sp));
+                                        
+                                        if (log && log->GetVerbose())
+                                            log->Printf("AppleObjCRuntimeV1 added (ObjCISA)0x%" PRIx64 " from _objc_debug_class_hash to isa->descriptor cache", isa);
+                                        
+                                        AddClass (isa, descriptor_sp);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                // When we have more than one entry in the bucket, the bucket data is a pointer
+                                // to an array of "isa" values
+                                addr_t isa_addr = bucket_data;
+                                for (uint32_t isa_idx = 0; isa_idx < bucket_isa_count; ++isa_idx, isa_addr += addr_size)
+                                {
+                                    isa = m_process->ReadPointerFromMemory(isa_addr, error);
+
+                                    if (isa && isa != LLDB_INVALID_ADDRESS)
+                                    {
+                                        if (!ISAIsCached(isa))
+                                        {
+                                            ClassDescriptorSP descriptor_sp (new ClassDescriptorV1(isa, process_sp));
+                                            
+                                            if (log && log->GetVerbose())
+                                                log->Printf("AppleObjCRuntimeV1 added (ObjCISA)0x%" PRIx64 " from _objc_debug_class_hash to isa->descriptor cache", isa);
+                                            
+                                            AddClass (isa, descriptor_sp);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }        
+    }
+    else
+    {
+        m_isa_to_descriptor_stop_id = UINT32_MAX;
+    }
+}
+
+DeclVendor *
+AppleObjCRuntimeV1::GetDeclVendor()
+{
+    if (!m_decl_vendor_ap.get())
+        m_decl_vendor_ap.reset(new AppleObjCDeclVendor(*this));
+    
+    return m_decl_vendor_ap.get();
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h
new file mode 100644
index 000000000000..9f9fcc69b682
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h
@@ -0,0 +1,207 @@
+//===-- AppleObjCRuntimeV1.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCRuntimeV1_h_
+#define liblldb_AppleObjCRuntimeV1_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "AppleObjCRuntime.h"
+
+namespace lldb_private {
+    
+class AppleObjCRuntimeV1 :
+        public AppleObjCRuntime
+{
+public:
+    ~AppleObjCRuntimeV1() override = default;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static void
+    Initialize();
+    
+    static void
+    Terminate();
+    
+    static lldb_private::LanguageRuntime *
+    CreateInstance(Process *process, lldb::LanguageType language);
+    
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+
+    static bool classof(const ObjCLanguageRuntime* runtime)
+    {
+        switch (runtime->GetRuntimeVersion())
+        {
+            case ObjCRuntimeVersions::eAppleObjC_V1:
+                return true;
+            default:
+                return false;
+        }
+    }
+    
+    class ClassDescriptorV1 : public ObjCLanguageRuntime::ClassDescriptor
+    {
+    public:
+        ClassDescriptorV1 (ValueObject &isa_pointer);
+        ClassDescriptorV1 (ObjCISA isa, lldb::ProcessSP process_sp);
+        
+        ~ClassDescriptorV1() override = default;
+
+        ConstString
+        GetClassName() override
+        {
+            return m_name;
+        }
+        
+        ClassDescriptorSP
+        GetSuperclass() override;
+        
+        ClassDescriptorSP
+        GetMetaclass() const override;
+        
+        bool
+        IsValid() override
+        {
+            return m_valid;
+        }
+        
+        // v1 does not support tagged pointers
+        bool
+        GetTaggedPointerInfo(uint64_t* info_bits = nullptr,
+                             uint64_t* value_bits = nullptr,
+                             uint64_t* payload = nullptr) override
+        {
+            return false;
+        }
+        
+        uint64_t
+        GetInstanceSize() override
+        {
+            return m_instance_size;
+        }
+        
+        ObjCISA
+        GetISA() override
+        {
+            return m_isa;
+        }
+        
+        bool
+        Describe(std::function <void (ObjCLanguageRuntime::ObjCISA)> const &superclass_func,
+                 std::function <bool (const char *, const char *)> const &instance_method_func,
+                 std::function <bool (const char *, const char *)> const &class_method_func,
+                 std::function <bool (const char *, const char *,
+                 lldb::addr_t, uint64_t)> const &ivar_func) const override;
+
+    protected:
+        void
+        Initialize (ObjCISA isa, lldb::ProcessSP process_sp);
+        
+    private:
+        ConstString m_name;
+        ObjCISA m_isa;
+        ObjCISA m_parent_isa;
+        bool m_valid;
+        lldb::ProcessWP m_process_wp;
+        uint64_t m_instance_size;
+    };
+
+    // These are generic runtime functions:
+    bool
+    GetDynamicTypeAndAddress(ValueObject &in_value, 
+                             lldb::DynamicValueType use_dynamic, 
+                             TypeAndOrName &class_type_or_name, 
+                             Address &address,
+                             Value::ValueType &value_type) override;
+
+    UtilityFunction *
+    CreateObjectChecker(const char *) override;
+
+    //------------------------------------------------------------------
+    // PluginInterface protocol
+    //------------------------------------------------------------------
+    ConstString
+    GetPluginName() override;
+    
+    uint32_t
+    GetPluginVersion() override;
+    
+    ObjCRuntimeVersions
+    GetRuntimeVersion() const override
+    {
+        return ObjCRuntimeVersions::eAppleObjC_V1;
+    }
+    
+    void
+    UpdateISAToDescriptorMapIfNeeded() override;
+    
+    DeclVendor *
+    GetDeclVendor() override;
+
+protected:
+    lldb::BreakpointResolverSP
+    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
+    
+    class HashTableSignature
+    {
+    public:
+        HashTableSignature () :
+            m_count (0),
+            m_num_buckets (0),
+            m_buckets_ptr (LLDB_INVALID_ADDRESS)
+        {
+        }
+        
+        bool
+        NeedsUpdate (uint32_t count,
+                     uint32_t num_buckets,
+                     lldb::addr_t buckets_ptr)
+        {
+            return m_count       != count       ||
+                   m_num_buckets != num_buckets ||
+                   m_buckets_ptr != buckets_ptr ;
+        }
+        
+        void
+        UpdateSignature (uint32_t count,
+                         uint32_t num_buckets,
+                         lldb::addr_t buckets_ptr)
+        {
+            m_count = count;
+            m_num_buckets = num_buckets;
+            m_buckets_ptr = buckets_ptr;
+        }
+
+    protected:
+        uint32_t m_count;
+        uint32_t m_num_buckets;
+        lldb::addr_t m_buckets_ptr;
+    };
+    
+    lldb::addr_t
+    GetISAHashTablePointer ();
+    
+    HashTableSignature m_hash_signature;
+    lldb::addr_t m_isa_hash_table_ptr;
+    std::unique_ptr<DeclVendor> m_decl_vendor_ap;
+
+private:
+    AppleObjCRuntimeV1(Process *process);
+};
+    
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCRuntimeV1_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
new file mode 100644
index 000000000000..8c485d97bdc9
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
@@ -0,0 +1,2215 @@
+//===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+#include <stdint.h>
+
+// C++ Includes
+#include <string>
+#include <vector>
+
+// Other libraries and framework includes
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclObjC.h"
+
+// Project includes
+#include "lldb/lldb-enumerations.h"
+#include "lldb/Core/ClangForward.h"
+#include "lldb/Symbol/CompilerType.h"
+
+#include "lldb/Core/ClangForward.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/Timer.h"
+#include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Host/StringConvert.h"
+#include "lldb/Interpreter/CommandObject.h"
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Platform.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+#include "AppleObjCRuntimeV2.h"
+#include "AppleObjCClassDescriptorV2.h"
+#include "AppleObjCTypeEncodingParser.h"
+#include "AppleObjCDeclVendor.h"
+#include "AppleObjCTrampolineHandler.h"
+
+#if defined(__APPLE__)
+#include "Plugins/Platform/MacOSX/PlatformiOSSimulator.h"
+#endif
+
+using namespace lldb;
+using namespace lldb_private;
+
+// 2 second timeout when running utility functions
+#define UTILITY_FUNCTION_TIMEOUT_USEC 2*1000*1000
+
+static const char *g_get_dynamic_class_info_name = "__lldb_apple_objc_v2_get_dynamic_class_info";
+// Testing using the new C++11 raw string literals. If this breaks GCC then we will
+// need to revert to the code above...
+static const char *g_get_dynamic_class_info_body = R"(
+
+extern "C"
+{
+    size_t strlen(const char *);
+    char *strncpy (char * s1, const char * s2, size_t n);
+    int printf(const char * format, ...);
+}
+//#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
+#ifdef ENABLE_DEBUG_PRINTF
+#define DEBUG_PRINTF(fmt, ...) printf(fmt, ## __VA_ARGS__)
+#else
+#define DEBUG_PRINTF(fmt, ...)
+#endif
+
+typedef struct _NXMapTable {
+    void *prototype;
+    unsigned num_classes;
+    unsigned num_buckets_minus_one;
+    void *buckets;
+} NXMapTable;
+
+#define NX_MAPNOTAKEY   ((void *)(-1))
+
+typedef struct BucketInfo
+{
+    const char *name_ptr;
+    Class isa;
+} BucketInfo;
+
+struct ClassInfo
+{
+    Class isa;
+    uint32_t hash;
+} __attribute__((__packed__));
+
+uint32_t
+__lldb_apple_objc_v2_get_dynamic_class_info (void *gdb_objc_realized_classes_ptr,
+                                             void *class_infos_ptr,
+                                             uint32_t class_infos_byte_size)
+{
+    DEBUG_PRINTF ("gdb_objc_realized_classes_ptr = %p\n", gdb_objc_realized_classes_ptr);
+    DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
+    DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);
+    const NXMapTable *grc = (const NXMapTable *)gdb_objc_realized_classes_ptr;
+    if (grc)
+    {
+        const unsigned num_classes = grc->num_classes;
+        if (class_infos_ptr)
+        {
+            const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
+            ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
+            BucketInfo *buckets = (BucketInfo *)grc->buckets;
+            
+            uint32_t idx = 0;
+            for (unsigned i=0; i<=grc->num_buckets_minus_one; ++i)
+            {
+                if (buckets[i].name_ptr != NX_MAPNOTAKEY)
+                {
+                    if (idx < max_class_infos)
+                    {
+                        const char *s = buckets[i].name_ptr;
+                        uint32_t h = 5381;
+                        for (unsigned char c = *s; c; c = *++s)
+                            h = ((h << 5) + h) + c;
+                        class_infos[idx].hash = h;
+                        class_infos[idx].isa = buckets[i].isa;
+                    }
+                    ++idx;
+                }
+            }
+            if (idx < max_class_infos)
+            {
+                class_infos[idx].isa = NULL;
+                class_infos[idx].hash = 0;
+            }
+        }
+        return num_classes;
+    }
+    return 0;
+}
+
+)";
+
+static const char *g_get_shared_cache_class_info_name = "__lldb_apple_objc_v2_get_shared_cache_class_info";
+// Testing using the new C++11 raw string literals. If this breaks GCC then we will
+// need to revert to the code above...
+static const char *g_get_shared_cache_class_info_body = R"(
+
+extern "C"
+{
+    const char *class_getName(void *objc_class);
+    size_t strlen(const char *);
+    char *strncpy (char * s1, const char * s2, size_t n);
+    int printf(const char * format, ...);
+}
+
+// #define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
+#ifdef ENABLE_DEBUG_PRINTF
+#define DEBUG_PRINTF(fmt, ...) printf(fmt, ## __VA_ARGS__)
+#else
+#define DEBUG_PRINTF(fmt, ...)
+#endif
+
+
+struct objc_classheader_t {
+    int32_t clsOffset;
+    int32_t hiOffset;
+};
+
+struct objc_clsopt_t {
+    uint32_t capacity;
+    uint32_t occupied;
+    uint32_t shift;
+    uint32_t mask;
+    uint32_t zero;
+    uint32_t unused;
+    uint64_t salt;
+    uint32_t scramble[256];
+    uint8_t tab[0]; // tab[mask+1]
+    //  uint8_t checkbytes[capacity];
+    //  int32_t offset[capacity];
+    //  objc_classheader_t clsOffsets[capacity];
+    //  uint32_t duplicateCount;
+    //  objc_classheader_t duplicateOffsets[duplicateCount];
+};
+
+struct objc_opt_t {
+    uint32_t version;
+    int32_t selopt_offset;
+    int32_t headeropt_offset;
+    int32_t clsopt_offset;
+};
+
+struct objc_opt_v14_t {
+    uint32_t version;
+    uint32_t flags;
+    int32_t selopt_offset;
+    int32_t headeropt_offset;
+    int32_t clsopt_offset;
+};
+
+struct ClassInfo
+{
+    Class isa;
+    uint32_t hash;
+}  __attribute__((__packed__));
+
+uint32_t
+__lldb_apple_objc_v2_get_shared_cache_class_info (void *objc_opt_ro_ptr,
+                                                  void *class_infos_ptr,
+                                                  uint32_t class_infos_byte_size)
+{
+    uint32_t idx = 0;
+    DEBUG_PRINTF ("objc_opt_ro_ptr = %p\n", objc_opt_ro_ptr);
+    DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
+    DEBUG_PRINTF ("class_infos_byte_size = %u (%" PRIu64 " class infos)\n", class_infos_byte_size, (size_t)(class_infos_byte_size/sizeof(ClassInfo)));
+    if (objc_opt_ro_ptr)
+    {
+        const objc_opt_t *objc_opt = (objc_opt_t *)objc_opt_ro_ptr;
+        const objc_opt_v14_t* objc_opt_v14 = (objc_opt_v14_t*)objc_opt_ro_ptr;
+        const bool is_v14_format = objc_opt->version >= 14;
+        if (is_v14_format)
+        {
+            DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v14->version);
+            DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v14->flags);
+            DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v14->selopt_offset);
+            DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt_v14->headeropt_offset);
+            DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt_v14->clsopt_offset);
+        }
+        else
+        {
+            DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt->version);
+            DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt->selopt_offset);
+            DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt->headeropt_offset);
+            DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt->clsopt_offset);
+        }
+        if (objc_opt->version == 12 || objc_opt->version == 13 || objc_opt->version == 14)
+        {
+            const objc_clsopt_t* clsopt = NULL;
+            if (is_v14_format)
+                clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt_v14 + objc_opt_v14->clsopt_offset);
+            else
+                clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt + objc_opt->clsopt_offset);
+            const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
+            ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
+            int32_t invalidEntryOffset = 0;
+            // this is safe to do because the version field order is invariant
+            if (objc_opt->version == 12)
+                invalidEntryOffset = 16;
+            const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
+            const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity);
+            const objc_classheader_t *classOffsets = (const objc_classheader_t *)(offsets + clsopt->capacity);
+            DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity);
+            DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask);
+            DEBUG_PRINTF ("classOffsets = %p\n", classOffsets);
+            for (uint32_t i=0; i<clsopt->capacity; ++i)
+            {
+                const int32_t clsOffset = classOffsets[i].clsOffset;
+                if (clsOffset & 1)
+                    continue; // duplicate
+                else if (clsOffset == invalidEntryOffset)
+                    continue; // invalid offset
+                
+                if (class_infos && idx < max_class_infos)
+                {
+                    class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
+                    const char *name = class_getName (class_infos[idx].isa);
+                    DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
+                    // Hash the class name so we don't have to read it
+                    const char *s = name;
+                    uint32_t h = 5381;
+                    for (unsigned char c = *s; c; c = *++s)
+                        h = ((h << 5) + h) + c;
+                    class_infos[idx].hash = h;
+                }
+                ++idx;
+            }
+            
+            const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity];
+            const uint32_t duplicate_count = *duplicate_count_ptr;
+            const objc_classheader_t *duplicateClassOffsets = (const objc_classheader_t *)(&duplicate_count_ptr[1]);
+            DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count);
+            DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets);
+            for (uint32_t i=0; i<duplicate_count; ++i)
+            {
+                const int32_t clsOffset = duplicateClassOffsets[i].clsOffset;
+                if (clsOffset & 1)
+                    continue; // duplicate
+                else if (clsOffset == invalidEntryOffset)
+                    continue; // invalid offset
+                
+                if (class_infos && idx < max_class_infos)
+                {
+                    class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
+                    const char *name = class_getName (class_infos[idx].isa);
+                    DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
+                    // Hash the class name so we don't have to read it
+                    const char *s = name;
+                    uint32_t h = 5381;
+                    for (unsigned char c = *s; c; c = *++s)
+                        h = ((h << 5) + h) + c;
+                    class_infos[idx].hash = h;
+                }
+                ++idx;
+            }
+        }
+        DEBUG_PRINTF ("%u class_infos\n", idx);
+        DEBUG_PRINTF ("done\n");
+    }
+    return idx;
+}
+
+
+)";
+
+static uint64_t
+ExtractRuntimeGlobalSymbol (Process* process,
+                            ConstString name,
+                            const ModuleSP &module_sp,
+                            Error& error,
+                            bool read_value = true,
+                            uint8_t byte_size = 0,
+                            uint64_t default_value = LLDB_INVALID_ADDRESS,
+                            SymbolType sym_type = lldb::eSymbolTypeData)
+{
+    if (!process)
+    {
+        error.SetErrorString("no process");
+        return default_value;
+    }
+    if (!module_sp)
+    {
+        error.SetErrorString("no module");
+        return default_value;
+    }
+    if (!byte_size)
+        byte_size = process->GetAddressByteSize();
+    const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);
+    if (symbol && symbol->ValueIsAddress())
+    {
+        lldb::addr_t symbol_load_addr = symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
+        if (symbol_load_addr != LLDB_INVALID_ADDRESS)
+        {
+            if (read_value)
+                return process->ReadUnsignedIntegerFromMemory(symbol_load_addr, byte_size, default_value, error);
+            else
+                return symbol_load_addr;
+        }
+        else
+        {
+            error.SetErrorString("symbol address invalid");
+            return default_value;
+        }
+    }
+    else
+    {
+        error.SetErrorString("no symbol");
+        return default_value;
+    }
+}
+
+AppleObjCRuntimeV2::AppleObjCRuntimeV2 (Process *process,
+                                        const ModuleSP &objc_module_sp) :
+    AppleObjCRuntime (process),
+    m_get_class_info_code(),
+    m_get_class_info_args (LLDB_INVALID_ADDRESS),
+    m_get_class_info_args_mutex (Mutex::eMutexTypeNormal),
+    m_get_shared_cache_class_info_code(),
+    m_get_shared_cache_class_info_args (LLDB_INVALID_ADDRESS),
+    m_get_shared_cache_class_info_args_mutex (Mutex::eMutexTypeNormal),
+    m_decl_vendor_ap (),
+    m_isa_hash_table_ptr (LLDB_INVALID_ADDRESS),
+    m_hash_signature (),
+    m_has_object_getClass (false),
+    m_loaded_objc_opt (false),
+    m_non_pointer_isa_cache_ap(NonPointerISACache::CreateInstance(*this,objc_module_sp)),
+    m_tagged_pointer_vendor_ap(TaggedPointerVendorV2::CreateInstance(*this,objc_module_sp)),
+    m_encoding_to_type_sp(),
+    m_noclasses_warning_emitted(false)
+{
+    static const ConstString g_gdb_object_getClass("gdb_object_getClass");
+    m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, eSymbolTypeCode) != NULL);
+}
+
+bool
+AppleObjCRuntimeV2::GetDynamicTypeAndAddress (ValueObject &in_value,
+                                              DynamicValueType use_dynamic, 
+                                              TypeAndOrName &class_type_or_name, 
+                                              Address &address,
+                                              Value::ValueType &value_type)
+{
+    // The Runtime is attached to a particular process, you shouldn't pass in a value from another process.
+    assert (in_value.GetProcessSP().get() == m_process);
+    assert (m_process != NULL);
+    
+    class_type_or_name.Clear();
+    value_type = Value::ValueType::eValueTypeScalar;
+
+    // Make sure we can have a dynamic value before starting...
+    if (CouldHaveDynamicValue (in_value))
+    {
+        // First job, pull out the address at 0 offset from the object  That will be the ISA pointer.
+        ClassDescriptorSP objc_class_sp (GetNonKVOClassDescriptor (in_value));
+        if (objc_class_sp)
+        {
+            const addr_t object_ptr = in_value.GetPointerValue();
+            address.SetRawAddress(object_ptr);
+
+            ConstString class_name (objc_class_sp->GetClassName());
+            class_type_or_name.SetName(class_name);
+            TypeSP type_sp (objc_class_sp->GetType());
+            if (type_sp)
+                class_type_or_name.SetTypeSP (type_sp);
+            else
+            {
+                type_sp = LookupInCompleteClassCache (class_name);
+                if (type_sp)
+                {
+                    objc_class_sp->SetType (type_sp);
+                    class_type_or_name.SetTypeSP (type_sp);
+                }
+                else
+                {
+                    // try to go for a CompilerType at least
+                    DeclVendor* vendor = GetDeclVendor();
+                    if (vendor)
+                    {
+                        std::vector<clang::NamedDecl*> decls;
+                        if (vendor->FindDecls(class_name, false, 1, decls) && decls.size())
+                            class_type_or_name.SetCompilerType(ClangASTContext::GetTypeForDecl(decls[0]));
+                    }
+                }
+            }
+        }
+    }    
+    return class_type_or_name.IsEmpty() == false;
+}
+
+//------------------------------------------------------------------
+// Static Functions
+//------------------------------------------------------------------
+LanguageRuntime *
+AppleObjCRuntimeV2::CreateInstance (Process *process, LanguageType language)
+{
+    // FIXME: This should be a MacOS or iOS process, and we need to look for the OBJC section to make
+    // sure we aren't using the V1 runtime.
+    if (language == eLanguageTypeObjC)
+    {
+        ModuleSP objc_module_sp;
+        
+        if (AppleObjCRuntime::GetObjCVersion (process, objc_module_sp) == ObjCRuntimeVersions::eAppleObjC_V2)
+            return new AppleObjCRuntimeV2 (process, objc_module_sp);
+        else
+            return NULL;
+    }
+    else
+        return NULL;
+}
+
+class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed
+{
+public:
+    CommandObjectObjC_ClassTable_Dump (CommandInterpreter &interpreter) :
+    CommandObjectParsed (interpreter,
+                         "dump",
+                         "Dump information on Objective-C classes known to the current process.",
+                         "language objc class-table dump",
+                         eCommandRequiresProcess       |
+                         eCommandProcessMustBeLaunched |
+                         eCommandProcessMustBePaused   )
+    {
+    }
+
+    ~CommandObjectObjC_ClassTable_Dump() override = default;
+
+protected:
+    bool
+    DoExecute(Args& command, CommandReturnObject &result) override
+    {
+        Process *process = m_exe_ctx.GetProcessPtr();
+        ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
+        if (objc_runtime)
+        {
+            auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
+            auto iterator = iterators_pair.first;
+            for(; iterator != iterators_pair.second; iterator++)
+            {
+                result.GetOutputStream().Printf("isa = 0x%" PRIx64, iterator->first);
+                if (iterator->second)
+                {
+                    result.GetOutputStream().Printf(" name = %s", iterator->second->GetClassName().AsCString("<unknown>"));
+                    result.GetOutputStream().Printf(" instance size = %" PRIu64, iterator->second->GetInstanceSize());
+                    result.GetOutputStream().Printf(" num ivars = %" PRIuPTR, (uintptr_t)iterator->second->GetNumIVars());
+                    if (auto superclass = iterator->second->GetSuperclass())
+                    {
+                        result.GetOutputStream().Printf(" superclass = %s", superclass->GetClassName().AsCString("<unknown>"));
+                    }
+                    result.GetOutputStream().Printf("\n");
+                }
+                else
+                {
+                    result.GetOutputStream().Printf(" has no associated class.\n");
+                }
+            }
+            result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
+            return true;
+        }
+        else
+        {
+            result.AppendError("current process has no Objective-C runtime loaded");
+            result.SetStatus(lldb::eReturnStatusFailed);
+            return false;
+        }
+    }
+};
+
+class CommandObjectMultiwordObjC_TaggedPointer_Info : public CommandObjectParsed
+{
+public:
+    CommandObjectMultiwordObjC_TaggedPointer_Info (CommandInterpreter &interpreter) :
+    CommandObjectParsed (interpreter,
+                         "info",
+                         "Dump information on a tagged pointer.",
+                         "language objc tagged-pointer info",
+                         eCommandRequiresProcess       |
+                         eCommandProcessMustBeLaunched |
+                         eCommandProcessMustBePaused   )
+    {
+        CommandArgumentEntry arg;
+        CommandArgumentData index_arg;
+        
+        // Define the first (and only) variant of this arg.
+        index_arg.arg_type = eArgTypeAddress;
+        index_arg.arg_repetition = eArgRepeatPlus;
+        
+        // There is only one variant this argument could be; put it into the argument entry.
+        arg.push_back (index_arg);
+        
+        // Push the data for the first argument into the m_arguments vector.
+        m_arguments.push_back (arg);
+    }
+
+    ~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default;
+
+protected:
+    bool
+    DoExecute(Args& command, CommandReturnObject &result) override
+    {
+        if (command.GetArgumentCount() == 0)
+        {
+            result.AppendError("this command requires arguments");
+            result.SetStatus(lldb::eReturnStatusFailed);
+            return false;
+        }
+        
+        Process *process = m_exe_ctx.GetProcessPtr();
+        ExecutionContext exe_ctx(process);
+        ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
+        if (objc_runtime)
+        {
+            ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor = objc_runtime->GetTaggedPointerVendor();
+            if (tagged_ptr_vendor)
+            {
+                for (size_t i = 0;
+                     i < command.GetArgumentCount();
+                     i++)
+                {
+                    const char *arg_str = command.GetArgumentAtIndex(i);
+                    if (!arg_str)
+                        continue;
+                    Error error;
+                    lldb::addr_t arg_addr = Args::StringToAddress(&exe_ctx, arg_str, LLDB_INVALID_ADDRESS, &error);
+                    if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS || error.Fail())
+                        continue;
+                    auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr);
+                    if (!descriptor_sp)
+                        continue;
+                    uint64_t info_bits = 0;
+                    uint64_t value_bits = 0;
+                    uint64_t payload = 0;
+                    if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits, &payload))
+                    {
+                        result.GetOutputStream().Printf("0x%" PRIx64 " is tagged.\n\tpayload = 0x%" PRIx64 "\n\tvalue = 0x%" PRIx64 "\n\tinfo bits = 0x%" PRIx64 "\n\tclass = %s\n",
+                                                        (uint64_t)arg_addr,
+                                                        payload,
+                                                        value_bits,
+                                                        info_bits,
+                                                        descriptor_sp->GetClassName().AsCString("<unknown>"));
+                    }
+                    else
+                    {
+                        result.GetOutputStream().Printf("0x%" PRIx64 " is not tagged.\n", (uint64_t)arg_addr);
+                    }
+                }
+            }
+            else
+            {
+                result.AppendError("current process has no tagged pointer support");
+                result.SetStatus(lldb::eReturnStatusFailed);
+                return false;
+            }
+            result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
+            return true;
+        }
+        else
+        {
+            result.AppendError("current process has no Objective-C runtime loaded");
+            result.SetStatus(lldb::eReturnStatusFailed);
+            return false;
+        }
+    }
+};
+
+class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword
+{
+public:
+    CommandObjectMultiwordObjC_ClassTable (CommandInterpreter &interpreter) :
+    CommandObjectMultiword (interpreter,
+                            "class-table",
+                            "A set of commands for operating on the Objective-C class table.",
+                            "class-table <subcommand> [<subcommand-options>]")
+    {
+        LoadSubCommand ("dump",   CommandObjectSP (new CommandObjectObjC_ClassTable_Dump (interpreter)));
+    }
+
+    ~CommandObjectMultiwordObjC_ClassTable() override = default;
+};
+
+class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword
+{
+public:
+    
+    CommandObjectMultiwordObjC_TaggedPointer (CommandInterpreter &interpreter) :
+    CommandObjectMultiword (interpreter,
+                            "tagged-pointer",
+                            "A set of commands for operating on Objective-C tagged pointers.",
+                            "class-table <subcommand> [<subcommand-options>]")
+    {
+        LoadSubCommand ("info",   CommandObjectSP (new CommandObjectMultiwordObjC_TaggedPointer_Info (interpreter)));
+    }
+
+    ~CommandObjectMultiwordObjC_TaggedPointer() override = default;
+};
+
+class CommandObjectMultiwordObjC : public CommandObjectMultiword
+{
+public:
+    CommandObjectMultiwordObjC (CommandInterpreter &interpreter) :
+    CommandObjectMultiword (interpreter,
+                            "objc",
+                            "A set of commands for operating on the Objective-C Language Runtime.",
+                            "objc <subcommand> [<subcommand-options>]")
+    {
+        LoadSubCommand ("class-table",   CommandObjectSP (new CommandObjectMultiwordObjC_ClassTable (interpreter)));
+        LoadSubCommand ("tagged-pointer",   CommandObjectSP (new CommandObjectMultiwordObjC_TaggedPointer (interpreter)));
+    }
+
+    ~CommandObjectMultiwordObjC() override = default;
+};
+
+void
+AppleObjCRuntimeV2::Initialize()
+{
+    PluginManager::RegisterPlugin (GetPluginNameStatic(),
+                                   "Apple Objective C Language Runtime - Version 2",
+                                   CreateInstance,
+                                   [] (CommandInterpreter& interpreter) -> lldb::CommandObjectSP {
+                                       return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter));
+                                   });
+}
+
+void
+AppleObjCRuntimeV2::Terminate()
+{
+    PluginManager::UnregisterPlugin (CreateInstance);
+}
+
+lldb_private::ConstString
+AppleObjCRuntimeV2::GetPluginNameStatic()
+{
+    static ConstString g_name("apple-objc-v2");
+    return g_name;
+}
+
+//------------------------------------------------------------------
+// PluginInterface protocol
+//------------------------------------------------------------------
+lldb_private::ConstString
+AppleObjCRuntimeV2::GetPluginName()
+{
+    return GetPluginNameStatic();
+}
+
+uint32_t
+AppleObjCRuntimeV2::GetPluginVersion()
+{
+    return 1;
+}
+
+BreakpointResolverSP
+AppleObjCRuntimeV2::CreateExceptionResolver (Breakpoint *bkpt, bool catch_bp, bool throw_bp)
+{
+    BreakpointResolverSP resolver_sp;
+    
+    if (throw_bp)
+        resolver_sp.reset (new BreakpointResolverName (bkpt,
+                                                       "objc_exception_throw",
+                                                       eFunctionNameTypeBase,
+                                                       eLanguageTypeUnknown,
+                                                       Breakpoint::Exact,
+                                                       eLazyBoolNo));
+    // FIXME: We don't do catch breakpoints for ObjC yet.
+    // Should there be some way for the runtime to specify what it can do in this regard?
+    return resolver_sp;
+}
+
+UtilityFunction *
+AppleObjCRuntimeV2::CreateObjectChecker(const char *name)
+{
+    char check_function_code[2048];
+    
+    int len = 0;
+    if (m_has_object_getClass)
+    {
+        len = ::snprintf (check_function_code, 
+                          sizeof(check_function_code),
+                          "extern \"C\" void *gdb_object_getClass(void *);                                          \n"
+                          "extern \"C\"  int printf(const char *format, ...);                                       \n"
+                          "extern \"C\" void                                                                        \n"
+                          "%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector)                                    \n"
+                          "{                                                                                        \n"
+                          "   if ($__lldb_arg_obj == (void *)0)                                                     \n"
+                          "       return; // nil is ok                                                              \n" 
+                          "   if (!gdb_object_getClass($__lldb_arg_obj))                                            \n"
+                          "       *((volatile int *)0) = 'ocgc';                                                    \n"
+                          "   else if ($__lldb_arg_selector != (void *)0)                                           \n"
+                          "   {                                                                                     \n"
+                          "        signed char responds = (signed char) [(id) $__lldb_arg_obj                       \n"
+                          "                                                respondsToSelector:                      \n"
+                          "                                       (struct objc_selector *) $__lldb_arg_selector];   \n"
+                          "       if (responds == (signed char) 0)                                                  \n"
+                          "           *((volatile int *)0) = 'ocgc';                                                \n"
+                          "   }                                                                                     \n"
+                          "}                                                                                        \n",
+                          name);
+    }
+    else
+    {
+        len = ::snprintf (check_function_code, 
+                          sizeof(check_function_code), 
+                          "extern \"C\" void *gdb_class_getClass(void *);                                           \n"
+                          "extern \"C\"  int printf(const char *format, ...);                                       \n"
+                          "extern \"C\"  void                                                                       \n"
+                          "%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector)                                    \n"
+                          "{                                                                                        \n"
+                          "   if ($__lldb_arg_obj == (void *)0)                                                     \n"
+                          "       return; // nil is ok                                                              \n" 
+                          "    void **$isa_ptr = (void **)$__lldb_arg_obj;                                          \n"
+                          "    if (*$isa_ptr == (void *)0 || !gdb_class_getClass(*$isa_ptr))                        \n"
+                          "       *((volatile int *)0) = 'ocgc';                                                    \n"
+                          "   else if ($__lldb_arg_selector != (void *)0)                                           \n"
+                          "   {                                                                                     \n"
+                          "        signed char responds = (signed char) [(id) $__lldb_arg_obj                       \n"
+                          "                                                respondsToSelector:                      \n"
+                          "                                        (struct objc_selector *) $__lldb_arg_selector];  \n"
+                          "       if (responds == (signed char) 0)                                                  \n"
+                          "           *((volatile int *)0) = 'ocgc';                                                \n"
+                          "   }                                                                                     \n"
+                          "}                                                                                        \n", 
+                          name);
+    }
+    
+    assert (len < (int)sizeof(check_function_code));
+
+    Error error;
+    return GetTargetRef().GetUtilityFunctionForLanguage(check_function_code, eLanguageTypeObjC, name, error);
+}
+
+size_t
+AppleObjCRuntimeV2::GetByteOffsetForIvar (CompilerType &parent_ast_type, const char *ivar_name)
+{
+    uint32_t ivar_offset = LLDB_INVALID_IVAR_OFFSET;
+
+    const char *class_name = parent_ast_type.GetConstTypeName().AsCString();
+    if (class_name && class_name[0] && ivar_name && ivar_name[0])
+    {
+        //----------------------------------------------------------------------
+        // Make the objective C V2 mangled name for the ivar offset from the
+        // class name and ivar name
+        //----------------------------------------------------------------------
+        std::string buffer("OBJC_IVAR_$_");
+        buffer.append (class_name);
+        buffer.push_back ('.');
+        buffer.append (ivar_name);
+        ConstString ivar_const_str (buffer.c_str());
+        
+        //----------------------------------------------------------------------
+        // Try to get the ivar offset address from the symbol table first using
+        // the name we created above
+        //----------------------------------------------------------------------
+        SymbolContextList sc_list;
+        Target &target = m_process->GetTarget();
+        target.GetImages().FindSymbolsWithNameAndType(ivar_const_str, eSymbolTypeObjCIVar, sc_list);
+
+        addr_t ivar_offset_address = LLDB_INVALID_ADDRESS;
+
+        Error error;
+        SymbolContext ivar_offset_symbol;
+        if (sc_list.GetSize() == 1 && sc_list.GetContextAtIndex(0, ivar_offset_symbol))
+        {
+            if (ivar_offset_symbol.symbol)
+                ivar_offset_address = ivar_offset_symbol.symbol->GetLoadAddress (&target);
+        }
+
+        //----------------------------------------------------------------------
+        // If we didn't get the ivar offset address from the symbol table, fall
+        // back to getting it from the runtime
+        //----------------------------------------------------------------------
+        if (ivar_offset_address == LLDB_INVALID_ADDRESS)
+            ivar_offset_address = LookupRuntimeSymbol(ivar_const_str);
+
+        if (ivar_offset_address != LLDB_INVALID_ADDRESS)
+            ivar_offset = m_process->ReadUnsignedIntegerFromMemory (ivar_offset_address,
+                                                                    4,
+                                                                    LLDB_INVALID_IVAR_OFFSET,
+                                                                    error);
+    }
+    return ivar_offset;
+}
+
+// tagged pointers are special not-a-real-pointer values that contain both type and value information
+// this routine attempts to check with as little computational effort as possible whether something
+// could possibly be a tagged pointer - false positives are possible but false negatives shouldn't
+bool
+AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr)
+{
+    if (!m_tagged_pointer_vendor_ap)
+        return false;
+    return m_tagged_pointer_vendor_ap->IsPossibleTaggedPointer(ptr);
+}
+
+class RemoteNXMapTable
+{
+public:
+    RemoteNXMapTable () :
+        m_count (0),
+        m_num_buckets_minus_one (0),
+        m_buckets_ptr (LLDB_INVALID_ADDRESS),
+        m_process (NULL),
+        m_end_iterator (*this, -1),
+        m_load_addr (LLDB_INVALID_ADDRESS),
+        m_map_pair_size (0),
+        m_invalid_key (0)
+    {
+    }
+    
+    void
+    Dump ()
+    {
+        printf ("RemoteNXMapTable.m_load_addr = 0x%" PRIx64 "\n", m_load_addr);
+        printf ("RemoteNXMapTable.m_count = %u\n", m_count);
+        printf ("RemoteNXMapTable.m_num_buckets_minus_one = %u\n", m_num_buckets_minus_one);
+        printf ("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64 "\n", m_buckets_ptr);
+    }
+    
+    bool
+    ParseHeader (Process* process, lldb::addr_t load_addr)
+    {
+        m_process = process;
+        m_load_addr = load_addr;
+        m_map_pair_size = m_process->GetAddressByteSize() * 2;
+        m_invalid_key = m_process->GetAddressByteSize() == 8 ? UINT64_MAX : UINT32_MAX;
+        Error err;
+        
+        // This currently holds true for all platforms we support, but we might
+        // need to change this to use get the actually byte size of "unsigned"
+        // from the target AST...
+        const uint32_t unsigned_byte_size = sizeof(uint32_t);
+        // Skip the prototype as we don't need it (const struct +NXMapTablePrototype *prototype)
+        
+        bool success = true;
+        if (load_addr == LLDB_INVALID_ADDRESS)
+            success = false;
+        else
+        {
+            lldb::addr_t cursor = load_addr + m_process->GetAddressByteSize();
+                    
+            // unsigned count;
+            m_count = m_process->ReadUnsignedIntegerFromMemory(cursor, unsigned_byte_size, 0, err);
+            if (m_count)
+            {
+                cursor += unsigned_byte_size;
+            
+                // unsigned nbBucketsMinusOne;
+                m_num_buckets_minus_one = m_process->ReadUnsignedIntegerFromMemory(cursor, unsigned_byte_size, 0, err);
+                cursor += unsigned_byte_size;
+            
+                // void *buckets;
+                m_buckets_ptr = m_process->ReadPointerFromMemory(cursor, err);
+                
+                success = m_count > 0 && m_buckets_ptr != LLDB_INVALID_ADDRESS;
+            }
+        }
+        
+        if (!success)
+        {
+            m_count = 0;
+            m_num_buckets_minus_one = 0;
+            m_buckets_ptr = LLDB_INVALID_ADDRESS;
+        }
+        return success;
+    }
+    
+    // const_iterator mimics NXMapState and its code comes from NXInitMapState and NXNextMapState.
+    typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element;
+
+    friend class const_iterator;
+    class const_iterator
+    {
+    public:
+        const_iterator (RemoteNXMapTable &parent, int index) : m_parent(parent), m_index(index)
+        {
+            AdvanceToValidIndex();
+        }
+        
+        const_iterator (const const_iterator &rhs) : m_parent(rhs.m_parent), m_index(rhs.m_index)
+        {
+            // AdvanceToValidIndex() has been called by rhs already.
+        }
+        
+        const_iterator &operator=(const const_iterator &rhs)
+        {
+            // AdvanceToValidIndex() has been called by rhs already.
+            assert (&m_parent == &rhs.m_parent);
+            m_index = rhs.m_index;
+            return *this;
+        }
+        
+        bool operator==(const const_iterator &rhs) const
+        {
+            if (&m_parent != &rhs.m_parent)
+                return false;
+            if (m_index != rhs.m_index)
+                return false;
+            
+            return true;
+        }
+        
+        bool operator!=(const const_iterator &rhs) const
+        {
+            return !(operator==(rhs));
+        }
+        
+        const_iterator &operator++()
+        {
+            AdvanceToValidIndex();
+            return *this;
+        }
+        
+        const element operator*() const
+        {
+            if (m_index == -1)
+            {
+                // TODO find a way to make this an error, but not an assert
+                return element();
+            }
+         
+            lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
+            size_t map_pair_size = m_parent.m_map_pair_size;
+            lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
+            
+            Error err;
+            
+            lldb::addr_t key = m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
+            if (!err.Success())
+                return element();
+            lldb::addr_t value = m_parent.m_process->ReadPointerFromMemory(pair_ptr + m_parent.m_process->GetAddressByteSize(), err);
+            if (!err.Success())
+                return element();
+            
+            std::string key_string;
+            
+            m_parent.m_process->ReadCStringFromMemory(key, key_string, err);
+            if (!err.Success())
+                return element();
+            
+            return element(ConstString(key_string.c_str()), (ObjCLanguageRuntime::ObjCISA)value);
+        }
+
+    private:
+        void AdvanceToValidIndex ()
+        {
+            if (m_index == -1)
+                return;
+            
+            const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
+            const size_t map_pair_size = m_parent.m_map_pair_size;
+            const lldb::addr_t invalid_key = m_parent.m_invalid_key;
+            Error err;
+
+            while (m_index--)
+            {
+                lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
+                lldb::addr_t key = m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
+                
+                if (!err.Success())
+                {
+                    m_index = -1;
+                    return;
+                }
+                
+                if (key != invalid_key)
+                    return;
+            }
+        }
+        RemoteNXMapTable   &m_parent;
+        int                 m_index;
+    };
+    
+    const_iterator begin ()
+    {
+        return const_iterator(*this, m_num_buckets_minus_one + 1);
+    }
+    
+    const_iterator end ()
+    {
+        return m_end_iterator;
+    }
+    
+    uint32_t
+    GetCount () const
+    {
+        return m_count;
+    }
+    
+    uint32_t
+    GetBucketCount () const
+    {
+        return m_num_buckets_minus_one;
+    }
+    
+    lldb::addr_t
+    GetBucketDataPointer () const
+    {
+        return m_buckets_ptr;
+    }
+    
+    lldb::addr_t
+    GetTableLoadAddress() const
+    {
+        return m_load_addr;
+    }
+
+private:
+    // contents of _NXMapTable struct
+    uint32_t m_count;
+    uint32_t m_num_buckets_minus_one;
+    lldb::addr_t m_buckets_ptr;
+    lldb_private::Process *m_process;
+    const_iterator m_end_iterator;
+    lldb::addr_t m_load_addr;
+    size_t m_map_pair_size;
+    lldb::addr_t m_invalid_key;
+};
+
+AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() :
+    m_count (0),
+    m_num_buckets (0),
+    m_buckets_ptr (0)
+{
+}
+
+void
+AppleObjCRuntimeV2::HashTableSignature::UpdateSignature (const RemoteNXMapTable &hash_table)
+{
+    m_count = hash_table.GetCount();
+    m_num_buckets = hash_table.GetBucketCount();
+    m_buckets_ptr = hash_table.GetBucketDataPointer();
+}
+
+bool
+AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate (Process *process, AppleObjCRuntimeV2 *runtime, RemoteNXMapTable &hash_table)
+{
+    if (!hash_table.ParseHeader(process, runtime->GetISAHashTablePointer ()))
+    {
+        return false; // Failed to parse the header, no need to update anything
+    }
+
+    // Check with out current signature and return true if the count,
+    // number of buckets or the hash table address changes.
+    if (m_count == hash_table.GetCount() &&
+        m_num_buckets == hash_table.GetBucketCount() &&
+        m_buckets_ptr == hash_table.GetBucketDataPointer())
+    {
+        // Hash table hasn't changed
+        return false;
+    }
+    // Hash table data has changed, we need to update
+    return true;
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+AppleObjCRuntimeV2::GetClassDescriptorFromISA (ObjCISA isa)
+{
+    ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp;
+    if (m_non_pointer_isa_cache_ap.get())
+        class_descriptor_sp = m_non_pointer_isa_cache_ap->GetClassDescriptor(isa);
+    if (!class_descriptor_sp)
+        class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa);
+    return class_descriptor_sp;
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+AppleObjCRuntimeV2::GetClassDescriptor (ValueObject& valobj)
+{
+    ClassDescriptorSP objc_class_sp;
+    if (valobj.IsBaseClass())
+    {
+        ValueObject *parent = valobj.GetParent();
+        // if I am my own parent, bail out of here fast..
+        if (parent && parent != &valobj)
+        {
+            ClassDescriptorSP parent_descriptor_sp = GetClassDescriptor(*parent);
+            if (parent_descriptor_sp)
+                return parent_descriptor_sp->GetSuperclass();
+        }
+        return nullptr;
+    }
+    // if we get an invalid VO (which might still happen when playing around
+    // with pointers returned by the expression parser, don't consider this
+    // a valid ObjC object)
+    if (valobj.GetCompilerType().IsValid())
+    {
+        addr_t isa_pointer = valobj.GetPointerValue();
+        
+        // tagged pointer
+        if (IsTaggedPointer(isa_pointer))
+        {
+            return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer);
+        }
+        else
+        {
+            ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
+            
+            Process *process = exe_ctx.GetProcessPtr();
+            if (process)
+            {
+                Error error;
+                ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
+                if (isa != LLDB_INVALID_ADDRESS)
+                {
+                    objc_class_sp = GetClassDescriptorFromISA (isa);
+                    if (isa && !objc_class_sp)
+                    {
+                        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+                        if (log)
+                            log->Printf("0x%" PRIx64 ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was not in class descriptor cache 0x%" PRIx64,
+                                        isa_pointer,
+                                        isa);
+                    }
+                }
+            }
+        }
+    }
+    return objc_class_sp;
+}
+
+lldb::addr_t
+AppleObjCRuntimeV2::GetISAHashTablePointer ()
+{
+    if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS)
+    {
+        Process *process = GetProcess();
+
+        ModuleSP objc_module_sp(GetObjCModule());
+        
+        if (!objc_module_sp)
+            return LLDB_INVALID_ADDRESS;
+
+        static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes");
+        
+        const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_objc_realized_classes, lldb::eSymbolTypeAny);
+        if (symbol)
+        {
+            lldb::addr_t gdb_objc_realized_classes_ptr = symbol->GetLoadAddress(&process->GetTarget());
+            
+            if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS)
+            {
+                Error error;
+                m_isa_hash_table_ptr = process->ReadPointerFromMemory(gdb_objc_realized_classes_ptr, error);
+            }
+        }
+    }
+    return m_isa_hash_table_ptr;
+}
+
+bool
+AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(RemoteNXMapTable &hash_table)
+{
+    Process *process = GetProcess();
+    
+    if (process == NULL)
+        return false;
+    
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    
+    ExecutionContext exe_ctx;
+    
+    ThreadSP thread_sp = process->GetThreadList().GetSelectedThread();
+    
+    if (!thread_sp)
+        return false;
+    
+    thread_sp->CalculateExecutionContext(exe_ctx);
+    ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
+    
+    if (!ast)
+        return false;
+    
+    Address function_address;
+    
+    StreamString errors;
+    
+    const uint32_t addr_size = process->GetAddressByteSize();
+    
+    Error err;
+    
+    // Read the total number of classes from the hash table
+    const uint32_t num_classes = hash_table.GetCount();
+    if (num_classes == 0)
+    {
+        if (log)
+            log->Printf ("No dynamic classes found in gdb_objc_realized_classes.");
+        return false;
+    }
+    
+    // Make some types for our arguments
+    CompilerType clang_uint32_t_type = ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
+    CompilerType clang_void_pointer_type = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+    
+    ValueList arguments;
+    FunctionCaller *get_class_info_function = nullptr;
+
+    if (!m_get_class_info_code.get())
+    {
+        Error error;
+        m_get_class_info_code.reset (GetTargetRef().GetUtilityFunctionForLanguage (g_get_dynamic_class_info_body,
+                                                                                   eLanguageTypeObjC,
+                                                                                   g_get_dynamic_class_info_name,
+                                                                                   error));
+        if (error.Fail())
+        {
+            if (log)
+                log->Printf ("Failed to get Utility Function for implementation lookup: %s", error.AsCString());
+            m_get_class_info_code.reset();
+        }
+        else
+        {
+            errors.Clear();
+            
+            if (!m_get_class_info_code->Install(errors, exe_ctx))
+            {
+                if (log)
+                    log->Printf ("Failed to install implementation lookup: %s.", errors.GetData());
+                m_get_class_info_code.reset();
+            }
+        }
+        if (!m_get_class_info_code.get())
+            return false;
+        
+        // Next make the runner function for our implementation utility function.
+        Value value;
+        value.SetValueType (Value::eValueTypeScalar);
+        value.SetCompilerType (clang_void_pointer_type);
+        arguments.PushValue (value);
+        arguments.PushValue (value);
+        
+        value.SetValueType (Value::eValueTypeScalar);
+        value.SetCompilerType (clang_uint32_t_type);
+        arguments.PushValue (value);
+        
+        get_class_info_function = m_get_class_info_code->MakeFunctionCaller(clang_uint32_t_type,
+                                                                            arguments,
+                                                                            error);
+        
+        if (error.Fail())
+        {
+            if (log)
+                log->Printf("Failed to make function caller for implementation lookup: %s.", error.AsCString());
+            return false;
+        }
+    }
+    else
+    {
+        get_class_info_function = m_get_class_info_code->GetFunctionCaller();
+        if (!get_class_info_function)
+        {
+            if (log)
+                log->Printf ("Failed to get implementation lookup function caller: %s.", errors.GetData());
+            return false;
+        }
+        arguments = get_class_info_function->GetArgumentValues();
+    }
+
+    errors.Clear();
+    
+    const uint32_t class_info_byte_size = addr_size + 4;
+    const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
+    lldb::addr_t class_infos_addr = process->AllocateMemory(class_infos_byte_size,
+                                                            ePermissionsReadable | ePermissionsWritable,
+                                                            err);
+    
+    if (class_infos_addr == LLDB_INVALID_ADDRESS)
+        return false;
+    
+    Mutex::Locker locker(m_get_class_info_args_mutex);
+    
+    // Fill in our function argument values
+    arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress();
+    arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
+    arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
+    
+    bool success = false;
+    
+    errors.Clear();
+    
+    // Write our function arguments into the process so we can run our function
+    if (get_class_info_function->WriteFunctionArguments (exe_ctx,
+                                                           m_get_class_info_args,
+                                                           arguments,
+                                                           errors))
+    {
+        EvaluateExpressionOptions options;
+        options.SetUnwindOnError(true);
+        options.SetTryAllThreads(false);
+        options.SetStopOthers(true);
+        options.SetIgnoreBreakpoints(true);
+        options.SetTimeoutUsec(UTILITY_FUNCTION_TIMEOUT_USEC);
+        
+        Value return_value;
+        return_value.SetValueType (Value::eValueTypeScalar);
+        //return_value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
+        return_value.SetCompilerType (clang_uint32_t_type);
+        return_value.GetScalar() = 0;
+        
+        errors.Clear();
+        
+        // Run the function
+        ExpressionResults results = get_class_info_function->ExecuteFunction (exe_ctx,
+                                                                              &m_get_class_info_args,
+                                                                              options,
+                                                                              errors,
+                                                                              return_value);
+        
+        if (results == eExpressionCompleted)
+        {
+            // The result is the number of ClassInfo structures that were filled in
+            uint32_t num_class_infos = return_value.GetScalar().ULong();
+            if (log)
+                log->Printf("Discovered %u ObjC classes\n",num_class_infos);
+            if (num_class_infos > 0)
+            {
+                // Read the ClassInfo structures
+                DataBufferHeap buffer (num_class_infos * class_info_byte_size, 0);
+                if (process->ReadMemory(class_infos_addr, buffer.GetBytes(), buffer.GetByteSize(), err) == buffer.GetByteSize())
+                {
+                    DataExtractor class_infos_data (buffer.GetBytes(),
+                                                    buffer.GetByteSize(),
+                                                    process->GetByteOrder(),
+                                                    addr_size);
+                    ParseClassInfoArray (class_infos_data, num_class_infos);
+                }
+            }
+            success = true;
+        }
+        else
+        {
+            if (log)
+                log->Printf("Error evaluating our find class name function: %s.\n", errors.GetData());
+        }
+    }
+    else
+    {
+        if (log)
+            log->Printf ("Error writing function arguments: \"%s\".", errors.GetData());
+    }
+    
+    // Deallocate the memory we allocated for the ClassInfo array
+    process->DeallocateMemory(class_infos_addr);
+    
+    return success;
+}
+
+uint32_t
+AppleObjCRuntimeV2::ParseClassInfoArray (const DataExtractor &data, uint32_t num_class_infos)
+{
+    // Parses an array of "num_class_infos" packed ClassInfo structures:
+    //
+    //    struct ClassInfo
+    //    {
+    //        Class isa;
+    //        uint32_t hash;
+    //    } __attribute__((__packed__));
+
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    
+    uint32_t num_parsed = 0;
+
+    // Iterate through all ClassInfo structures
+    lldb::offset_t offset = 0;
+    for (uint32_t i=0; i<num_class_infos; ++i)
+    {
+        ObjCISA isa = data.GetPointer(&offset);
+        
+        if (isa == 0)
+        {
+            if (log)
+                log->Printf("AppleObjCRuntimeV2 found NULL isa, ignoring this class info");
+            continue;
+        }
+        // Check if we already know about this ISA, if we do, the info will
+        // never change, so we can just skip it.
+        if (ISAIsCached(isa))
+        {
+            offset += 4;
+        }
+        else
+        {
+            // Read the 32 bit hash for the class name
+            const uint32_t name_hash = data.GetU32(&offset);
+            ClassDescriptorSP descriptor_sp (new ClassDescriptorV2(*this, isa, NULL));
+            AddClass (isa, descriptor_sp, name_hash);
+            num_parsed++;
+            if (log && log->GetVerbose())
+                log->Printf("AppleObjCRuntimeV2 added isa=0x%" PRIx64 ", hash=0x%8.8x, name=%s", isa, name_hash,descriptor_sp->GetClassName().AsCString("<unknown>"));
+        }
+    }
+    return num_parsed;
+}
+
+AppleObjCRuntimeV2::DescriptorMapUpdateResult
+AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache()
+{
+    Process *process = GetProcess();
+    
+    if (process == NULL)
+        return DescriptorMapUpdateResult::Fail();
+    
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    
+    ExecutionContext exe_ctx;
+    
+    ThreadSP thread_sp = process->GetThreadList().GetSelectedThread();
+    
+    if (!thread_sp)
+        return DescriptorMapUpdateResult::Fail();
+    
+    thread_sp->CalculateExecutionContext(exe_ctx);
+    ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
+    
+    if (!ast)
+        return DescriptorMapUpdateResult::Fail();
+    
+    Address function_address;
+    
+    StreamString errors;
+    
+    const uint32_t addr_size = process->GetAddressByteSize();
+    
+    Error err;
+    
+    const lldb::addr_t objc_opt_ptr = GetSharedCacheReadOnlyAddress();
+    
+    if (objc_opt_ptr == LLDB_INVALID_ADDRESS)
+        return DescriptorMapUpdateResult::Fail();
+    
+    // Read the total number of classes from the hash table
+    const uint32_t num_classes = 128*1024;
+    if (num_classes == 0)
+    {
+        if (log)
+            log->Printf ("No dynamic classes found in gdb_objc_realized_classes_addr.");
+        return DescriptorMapUpdateResult::Fail();
+    }
+    
+    // Make some types for our arguments
+    CompilerType clang_uint32_t_type = ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
+    CompilerType clang_void_pointer_type = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+    
+    ValueList arguments;
+    FunctionCaller *get_shared_cache_class_info_function = nullptr;
+    
+    if (!m_get_shared_cache_class_info_code.get())
+    {
+        Error error;
+        m_get_shared_cache_class_info_code.reset (GetTargetRef().GetUtilityFunctionForLanguage (g_get_shared_cache_class_info_body,
+                                                                                                eLanguageTypeObjC,
+                                                                                                g_get_shared_cache_class_info_name,
+                                                                                                error));
+        if (error.Fail())
+        {
+            if (log)
+                log->Printf ("Failed to get Utility function for implementation lookup: %s.", error.AsCString());
+            m_get_shared_cache_class_info_code.reset();
+        }
+        else
+        {
+            errors.Clear();
+            
+            if (!m_get_shared_cache_class_info_code->Install(errors, exe_ctx))
+            {
+                if (log)
+                    log->Printf ("Failed to install implementation lookup: %s.", errors.GetData());
+                m_get_shared_cache_class_info_code.reset();
+            }
+        }
+        
+        if (!m_get_shared_cache_class_info_code.get())
+            return DescriptorMapUpdateResult::Fail();
+    
+        // Next make the function caller for our implementation utility function.
+        Value value;
+        value.SetValueType (Value::eValueTypeScalar);
+        //value.SetContext (Value::eContextTypeClangType, clang_void_pointer_type);
+        value.SetCompilerType (clang_void_pointer_type);
+        arguments.PushValue (value);
+        arguments.PushValue (value);
+        
+        value.SetValueType (Value::eValueTypeScalar);
+        //value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
+        value.SetCompilerType (clang_uint32_t_type);
+        arguments.PushValue (value);
+        
+        get_shared_cache_class_info_function = m_get_shared_cache_class_info_code->MakeFunctionCaller(clang_uint32_t_type,
+                                                                                                      arguments,
+                                                                                                      error);
+        
+        if (get_shared_cache_class_info_function == nullptr)
+            return DescriptorMapUpdateResult::Fail();
+    
+    }
+    else
+    {
+        get_shared_cache_class_info_function = m_get_shared_cache_class_info_code->GetFunctionCaller();
+        if (get_shared_cache_class_info_function == nullptr)
+            return DescriptorMapUpdateResult::Fail();
+        arguments = get_shared_cache_class_info_function->GetArgumentValues();
+    }
+    
+    errors.Clear();
+    
+    const uint32_t class_info_byte_size = addr_size + 4;
+    const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
+    lldb::addr_t class_infos_addr = process->AllocateMemory (class_infos_byte_size,
+                                                             ePermissionsReadable | ePermissionsWritable,
+                                                             err);
+    
+    if (class_infos_addr == LLDB_INVALID_ADDRESS)
+        return DescriptorMapUpdateResult::Fail();
+    
+    Mutex::Locker locker(m_get_shared_cache_class_info_args_mutex);
+    
+    // Fill in our function argument values
+    arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
+    arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
+    arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
+    
+    bool success = false;
+    bool any_found = false;
+    
+    errors.Clear();
+    
+    // Write our function arguments into the process so we can run our function
+    if (get_shared_cache_class_info_function->WriteFunctionArguments (exe_ctx,
+                                                                      m_get_shared_cache_class_info_args,
+                                                                      arguments,
+                                                                      errors))
+    {
+        EvaluateExpressionOptions options;
+        options.SetUnwindOnError(true);
+        options.SetTryAllThreads(false);
+        options.SetStopOthers(true);
+        options.SetIgnoreBreakpoints(true);
+        options.SetTimeoutUsec(UTILITY_FUNCTION_TIMEOUT_USEC);
+        
+        Value return_value;
+        return_value.SetValueType (Value::eValueTypeScalar);
+        //return_value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
+        return_value.SetCompilerType (clang_uint32_t_type);
+        return_value.GetScalar() = 0;
+        
+        errors.Clear();
+        
+        // Run the function
+        ExpressionResults results = get_shared_cache_class_info_function->ExecuteFunction (exe_ctx,
+                                                                                           &m_get_shared_cache_class_info_args,
+                                                                                           options,
+                                                                                           errors,
+                                                                                           return_value);
+        
+        if (results == eExpressionCompleted)
+        {
+            // The result is the number of ClassInfo structures that were filled in
+            uint32_t num_class_infos = return_value.GetScalar().ULong();
+            if (log)
+                log->Printf("Discovered %u ObjC classes in shared cache\n",num_class_infos);
+#ifdef LLDB_CONFIGURATION_DEBUG
+            assert (num_class_infos <= num_classes);
+#endif
+            if (num_class_infos > 0)
+            {
+                if (num_class_infos > num_classes)
+                {
+                    num_class_infos = num_classes;
+                    
+                    success = false;
+                }
+                else
+                {
+                    success = true;
+                }
+                
+                // Read the ClassInfo structures
+                DataBufferHeap buffer (num_class_infos * class_info_byte_size, 0);
+                if (process->ReadMemory(class_infos_addr,
+                                        buffer.GetBytes(),
+                                        buffer.GetByteSize(),
+                                        err) == buffer.GetByteSize())
+                {
+                    DataExtractor class_infos_data (buffer.GetBytes(),
+                                                    buffer.GetByteSize(),
+                                                    process->GetByteOrder(),
+                                                    addr_size);
+
+                    any_found = (ParseClassInfoArray (class_infos_data, num_class_infos) > 0);
+                }
+            }
+            else
+            {
+                success = true;
+            }
+        }
+        else
+        {
+            if (log)
+                log->Printf("Error evaluating our find class name function: %s.\n", errors.GetData());
+        }
+    }
+    else
+    {
+        if (log)
+            log->Printf ("Error writing function arguments: \"%s\".", errors.GetData());
+    }
+    
+    // Deallocate the memory we allocated for the ClassInfo array
+    process->DeallocateMemory(class_infos_addr);
+    
+    return DescriptorMapUpdateResult(success, any_found);
+}
+
+bool
+AppleObjCRuntimeV2::UpdateISAToDescriptorMapFromMemory (RemoteNXMapTable &hash_table)
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+    
+    Process *process = GetProcess();
+
+    if (process == NULL)
+        return false;
+    
+    uint32_t num_map_table_isas = 0;
+    
+    ModuleSP objc_module_sp(GetObjCModule());
+    
+    if (objc_module_sp)
+    {
+        for (RemoteNXMapTable::element elt : hash_table)
+        {
+            ++num_map_table_isas;
+            
+            if (ISAIsCached(elt.second))
+                continue;
+            
+            ClassDescriptorSP descriptor_sp = ClassDescriptorSP(new ClassDescriptorV2(*this, elt.second, elt.first.AsCString()));
+            
+            if (log && log->GetVerbose())
+                log->Printf("AppleObjCRuntimeV2 added (ObjCISA)0x%" PRIx64 " (%s) from dynamic table to isa->descriptor cache", elt.second, elt.first.AsCString());
+            
+            AddClass (elt.second, descriptor_sp, elt.first.AsCString());
+        }
+    }
+    
+    return num_map_table_isas > 0;
+}
+
+lldb::addr_t
+AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress()
+{
+    Process *process = GetProcess();
+    
+    if (process)
+    {
+        ModuleSP objc_module_sp(GetObjCModule());
+        
+        if (objc_module_sp)
+        {
+            ObjectFile *objc_object = objc_module_sp->GetObjectFile();
+            
+            if (objc_object)
+            {
+                SectionList *section_list = objc_module_sp->GetSectionList();
+                
+                if (section_list)
+                {
+                    SectionSP text_segment_sp (section_list->FindSectionByName(ConstString("__TEXT")));
+                    
+                    if (text_segment_sp)
+                    {
+                        SectionSP objc_opt_section_sp (text_segment_sp->GetChildren().FindSectionByName(ConstString("__objc_opt_ro")));
+                        
+                        if (objc_opt_section_sp)
+                        {
+                            return objc_opt_section_sp->GetLoadBaseAddress(&process->GetTarget());
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return LLDB_INVALID_ADDRESS;
+}
+
+void
+AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded()
+{
+    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
+    
+    // Else we need to check with our process to see when the map was updated.
+    Process *process = GetProcess();
+
+    if (process)
+    {
+        RemoteNXMapTable hash_table;
+        
+        // Update the process stop ID that indicates the last time we updated the
+        // map, whether it was successful or not.
+        m_isa_to_descriptor_stop_id = process->GetStopID();
+        
+        if (!m_hash_signature.NeedsUpdate(process, this, hash_table))
+            return;
+        
+        m_hash_signature.UpdateSignature (hash_table);
+
+        // Grab the dynamically loaded objc classes from the hash table in memory
+        UpdateISAToDescriptorMapDynamic(hash_table);
+
+        // Now get the objc classes that are baked into the Objective C runtime
+        // in the shared cache, but only once per process as this data never
+        // changes
+        if (!m_loaded_objc_opt)
+        {
+            DescriptorMapUpdateResult shared_cache_update_result = UpdateISAToDescriptorMapSharedCache();
+            if (!shared_cache_update_result.any_found)
+                WarnIfNoClassesCached ();
+            else
+                m_loaded_objc_opt = true;
+        }
+    }
+    else
+    {
+        m_isa_to_descriptor_stop_id = UINT32_MAX;
+    }
+}
+
+void
+AppleObjCRuntimeV2::WarnIfNoClassesCached ()
+{
+    if (m_noclasses_warning_emitted)
+        return;
+
+#if defined(__APPLE__)
+    if (m_process &&
+        m_process->GetTarget().GetPlatform() &&
+        m_process->GetTarget().GetPlatform()->GetPluginName() == PlatformiOSSimulator::GetPluginNameStatic())
+    {
+        // the iOS simulator does not have the objc_opt_ro class table
+        // so don't actually complain to the user
+        m_noclasses_warning_emitted = true;
+        return;
+    }
+#endif
+
+    Debugger &debugger(GetProcess()->GetTarget().GetDebugger());
+    
+    if (debugger.GetAsyncOutputStream())
+    {
+        debugger.GetAsyncOutputStream()->PutCString("warning: could not load any Objective-C class information from the dyld shared cache. This will significantly reduce the quality of type information available.\n");
+        m_noclasses_warning_emitted = true;
+    }
+}
+
+// TODO: should we have a transparent_kvo parameter here to say if we
+// want to replace the KVO swizzled class with the actual user-level type?
+ConstString
+AppleObjCRuntimeV2::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa)
+{
+    if (isa == g_objc_Tagged_ISA)
+    {
+        static const ConstString g_objc_tagged_isa_name ("_lldb_Tagged_ObjC_ISA");
+        return g_objc_tagged_isa_name;
+    }
+    if (isa == g_objc_Tagged_ISA_NSAtom)
+    {
+        static const ConstString g_objc_tagged_isa_nsatom_name ("NSAtom");
+        return g_objc_tagged_isa_nsatom_name;
+    }
+    if (isa == g_objc_Tagged_ISA_NSNumber)
+    {
+        static const ConstString g_objc_tagged_isa_nsnumber_name ("NSNumber");
+        return g_objc_tagged_isa_nsnumber_name;
+    }
+    if (isa == g_objc_Tagged_ISA_NSDateTS)
+    {
+        static const ConstString g_objc_tagged_isa_nsdatets_name ("NSDateTS");
+        return g_objc_tagged_isa_nsdatets_name;
+    }
+    if (isa == g_objc_Tagged_ISA_NSManagedObject)
+    {
+        static const ConstString g_objc_tagged_isa_nsmanagedobject_name ("NSManagedObject");
+        return g_objc_tagged_isa_nsmanagedobject_name;
+    }
+    if (isa == g_objc_Tagged_ISA_NSDate)
+    {
+        static const ConstString g_objc_tagged_isa_nsdate_name ("NSDate");
+        return g_objc_tagged_isa_nsdate_name;
+    }
+    return ObjCLanguageRuntime::GetActualTypeName(isa);
+}
+
+DeclVendor *
+AppleObjCRuntimeV2::GetDeclVendor()
+{
+    if (!m_decl_vendor_ap.get())
+        m_decl_vendor_ap.reset(new AppleObjCDeclVendor(*this));
+    
+    return m_decl_vendor_ap.get();
+}
+
+lldb::addr_t
+AppleObjCRuntimeV2::LookupRuntimeSymbol (const ConstString &name)
+{
+    lldb::addr_t ret = LLDB_INVALID_ADDRESS;
+
+    const char *name_cstr = name.AsCString();    
+    
+    if (name_cstr)
+    {
+        llvm::StringRef name_strref(name_cstr);
+        
+        static const llvm::StringRef ivar_prefix("OBJC_IVAR_$_");
+        static const llvm::StringRef class_prefix("OBJC_CLASS_$_");
+        
+        if (name_strref.startswith(ivar_prefix))
+        {
+            llvm::StringRef ivar_skipped_prefix = name_strref.substr(ivar_prefix.size());
+            std::pair<llvm::StringRef, llvm::StringRef> class_and_ivar = ivar_skipped_prefix.split('.');
+            
+            if (class_and_ivar.first.size() && class_and_ivar.second.size())
+            {
+                const ConstString class_name_cs(class_and_ivar.first);
+                ClassDescriptorSP descriptor = ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs);
+                                
+                if (descriptor)
+                {
+                    const ConstString ivar_name_cs(class_and_ivar.second);
+                    const char *ivar_name_cstr = ivar_name_cs.AsCString();
+                    
+                    auto ivar_func = [&ret, ivar_name_cstr](const char *name, const char *type, lldb::addr_t offset_addr, uint64_t size) -> lldb::addr_t
+                    {
+                        if (!strcmp(name, ivar_name_cstr))
+                        {
+                            ret = offset_addr;
+                            return true;
+                        }
+                        return false;
+                    };
+
+                    descriptor->Describe(std::function<void (ObjCISA)>(nullptr),
+                                         std::function<bool (const char *, const char *)>(nullptr),
+                                         std::function<bool (const char *, const char *)>(nullptr),
+                                         ivar_func);
+                }
+            }
+        }
+        else if (name_strref.startswith(class_prefix))
+        {
+            llvm::StringRef class_skipped_prefix = name_strref.substr(class_prefix.size());
+            const ConstString class_name_cs(class_skipped_prefix);
+            ClassDescriptorSP descriptor = GetClassDescriptorFromClassName(class_name_cs);
+            
+            if (descriptor)
+                ret = descriptor->GetISA();
+        }
+    }
+    
+    return ret;
+}
+
+AppleObjCRuntimeV2::NonPointerISACache*
+AppleObjCRuntimeV2::NonPointerISACache::CreateInstance (AppleObjCRuntimeV2& runtime, const lldb::ModuleSP& objc_module_sp)
+{
+    Process* process(runtime.GetProcess());
+    
+    Error error;
+    
+    auto objc_debug_isa_magic_mask = ExtractRuntimeGlobalSymbol(process,
+                                                                ConstString("objc_debug_isa_magic_mask"),
+                                                                objc_module_sp,
+                                                                error);
+    if (error.Fail())
+        return NULL;
+
+    auto objc_debug_isa_magic_value = ExtractRuntimeGlobalSymbol(process,
+                                                                 ConstString("objc_debug_isa_magic_value"),
+                                                                 objc_module_sp,
+                                                                 error);
+    if (error.Fail())
+        return NULL;
+
+    auto objc_debug_isa_class_mask = ExtractRuntimeGlobalSymbol(process,
+                                                                ConstString("objc_debug_isa_class_mask"),
+                                                                objc_module_sp,
+                                                                error);
+    if (error.Fail())
+        return NULL;
+
+    // we might want to have some rules to outlaw these other values (e.g if the mask is zero but the value is non-zero, ...)
+    
+    return new NonPointerISACache(runtime,
+                                  objc_debug_isa_class_mask,
+                                  objc_debug_isa_magic_mask,
+                                  objc_debug_isa_magic_value);
+}
+
+AppleObjCRuntimeV2::TaggedPointerVendorV2*
+AppleObjCRuntimeV2::TaggedPointerVendorV2::CreateInstance (AppleObjCRuntimeV2& runtime, const lldb::ModuleSP& objc_module_sp)
+{
+    Process* process(runtime.GetProcess());
+    
+    Error error;
+    
+    auto objc_debug_taggedpointer_mask = ExtractRuntimeGlobalSymbol(process,
+                                                                    ConstString("objc_debug_taggedpointer_mask"),
+                                                                    objc_module_sp,
+                                                                    error);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+    
+    auto objc_debug_taggedpointer_slot_shift = ExtractRuntimeGlobalSymbol(process,
+                                                                          ConstString("objc_debug_taggedpointer_slot_shift"),
+                                                                          objc_module_sp,
+                                                                          error,
+                                                                          true,
+                                                                          4);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+    
+    auto objc_debug_taggedpointer_slot_mask = ExtractRuntimeGlobalSymbol(process,
+                                                                          ConstString("objc_debug_taggedpointer_slot_mask"),
+                                                                          objc_module_sp,
+                                                                          error,
+                                                                          true,
+                                                                          4);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+
+    auto objc_debug_taggedpointer_payload_lshift = ExtractRuntimeGlobalSymbol(process,
+                                                                              ConstString("objc_debug_taggedpointer_payload_lshift"),
+                                                                              objc_module_sp,
+                                                                              error,
+                                                                              true,
+                                                                              4);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+    
+    auto objc_debug_taggedpointer_payload_rshift = ExtractRuntimeGlobalSymbol(process,
+                                                                              ConstString("objc_debug_taggedpointer_payload_rshift"),
+                                                                              objc_module_sp,
+                                                                              error,
+                                                                              true,
+                                                                              4);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+    
+    auto objc_debug_taggedpointer_classes = ExtractRuntimeGlobalSymbol(process,
+                                                                       ConstString("objc_debug_taggedpointer_classes"),
+                                                                       objc_module_sp,
+                                                                       error,
+                                                                       false);
+    if (error.Fail())
+        return new TaggedPointerVendorLegacy(runtime);
+
+    
+    // we might want to have some rules to outlaw these values (e.g if the table's address is zero)
+    
+    return new TaggedPointerVendorRuntimeAssisted(runtime,
+                                                  objc_debug_taggedpointer_mask,
+                                                  objc_debug_taggedpointer_slot_shift,
+                                                  objc_debug_taggedpointer_slot_mask,
+                                                  objc_debug_taggedpointer_payload_lshift,
+                                                  objc_debug_taggedpointer_payload_rshift,
+                                                  objc_debug_taggedpointer_classes);
+}
+
+bool
+AppleObjCRuntimeV2::TaggedPointerVendorLegacy::IsPossibleTaggedPointer (lldb::addr_t ptr)
+{
+    return (ptr & 1);
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+AppleObjCRuntimeV2::TaggedPointerVendorLegacy::GetClassDescriptor (lldb::addr_t ptr)
+{
+    if (!IsPossibleTaggedPointer(ptr))
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+
+    uint32_t foundation_version = m_runtime.GetFoundationVersion();
+    
+    if (foundation_version == LLDB_INVALID_MODULE_VERSION)
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    uint64_t class_bits = (ptr & 0xE) >> 1;
+    ConstString name;
+    
+    // TODO: make a table
+    if (foundation_version >= 900)
+    {
+        switch (class_bits)
+        {
+            case 0:
+                name = ConstString("NSAtom");
+                break;
+            case 3:
+                name = ConstString("NSNumber");
+                break;
+            case 4:
+                name = ConstString("NSDateTS");
+                break;
+            case 5:
+                name = ConstString("NSManagedObject");
+                break;
+            case 6:
+                name = ConstString("NSDate");
+                break;
+            default:
+                return ObjCLanguageRuntime::ClassDescriptorSP();
+        }
+    }
+    else
+    {
+        switch (class_bits)
+        {
+            case 1:
+                name = ConstString("NSNumber");
+                break;
+            case 5:
+                name = ConstString("NSManagedObject");
+                break;
+            case 6:
+                name = ConstString("NSDate");
+                break;
+            case 7:
+                name = ConstString("NSDateTS");
+                break;
+            default:
+                return ObjCLanguageRuntime::ClassDescriptorSP();
+        }
+    }
+    return ClassDescriptorSP(new ClassDescriptorV2Tagged(name,ptr));
+}
+
+AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::TaggedPointerVendorRuntimeAssisted (AppleObjCRuntimeV2& runtime,
+                                                                                            uint64_t objc_debug_taggedpointer_mask,
+                                                                                            uint32_t objc_debug_taggedpointer_slot_shift,
+                                                                                            uint32_t objc_debug_taggedpointer_slot_mask,
+                                                                                            uint32_t objc_debug_taggedpointer_payload_lshift,
+                                                                                            uint32_t objc_debug_taggedpointer_payload_rshift,
+                                                                                            lldb::addr_t objc_debug_taggedpointer_classes) :
+TaggedPointerVendorV2(runtime),
+m_cache(),
+m_objc_debug_taggedpointer_mask(objc_debug_taggedpointer_mask),
+m_objc_debug_taggedpointer_slot_shift(objc_debug_taggedpointer_slot_shift),
+m_objc_debug_taggedpointer_slot_mask(objc_debug_taggedpointer_slot_mask),
+m_objc_debug_taggedpointer_payload_lshift(objc_debug_taggedpointer_payload_lshift),
+m_objc_debug_taggedpointer_payload_rshift(objc_debug_taggedpointer_payload_rshift),
+m_objc_debug_taggedpointer_classes(objc_debug_taggedpointer_classes)
+{
+}
+
+bool
+AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::IsPossibleTaggedPointer (lldb::addr_t ptr)
+{
+    return (ptr & m_objc_debug_taggedpointer_mask) != 0;
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor (lldb::addr_t ptr)
+{
+    ClassDescriptorSP actual_class_descriptor_sp;
+    uint64_t data_payload;
+
+    if (!IsPossibleTaggedPointer(ptr))
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    
+    uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) & m_objc_debug_taggedpointer_slot_mask;
+    
+    CacheIterator iterator = m_cache.find(slot),
+    end = m_cache.end();
+    if (iterator != end)
+    {
+        actual_class_descriptor_sp = iterator->second;
+    }
+    else
+    {
+        Process* process(m_runtime.GetProcess());
+        uintptr_t slot_ptr = slot*process->GetAddressByteSize()+m_objc_debug_taggedpointer_classes;
+        Error error;
+        uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
+        if (error.Fail() || slot_data == 0 || slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
+            return nullptr;
+        actual_class_descriptor_sp = m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
+        if (!actual_class_descriptor_sp)
+            return ObjCLanguageRuntime::ClassDescriptorSP();
+        m_cache[slot] = actual_class_descriptor_sp;
+    }
+    
+    data_payload = (((uint64_t)ptr << m_objc_debug_taggedpointer_payload_lshift) >> m_objc_debug_taggedpointer_payload_rshift);
+    
+    return ClassDescriptorSP(new ClassDescriptorV2Tagged(actual_class_descriptor_sp,data_payload));
+}
+
+AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache (AppleObjCRuntimeV2& runtime,
+                                                            uint64_t objc_debug_isa_class_mask,
+                                                            uint64_t objc_debug_isa_magic_mask,
+                                                            uint64_t objc_debug_isa_magic_value) :
+m_runtime(runtime),
+m_cache(),
+m_objc_debug_isa_class_mask(objc_debug_isa_class_mask),
+m_objc_debug_isa_magic_mask(objc_debug_isa_magic_mask),
+m_objc_debug_isa_magic_value(objc_debug_isa_magic_value)
+{
+}
+
+ObjCLanguageRuntime::ClassDescriptorSP
+AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor (ObjCISA isa)
+{
+    ObjCISA real_isa = 0;
+    if (EvaluateNonPointerISA(isa, real_isa) == false)
+        return ObjCLanguageRuntime::ClassDescriptorSP();
+    auto cache_iter = m_cache.find(real_isa);
+    if (cache_iter != m_cache.end())
+        return cache_iter->second;
+    auto descriptor_sp = m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(real_isa);
+    if (descriptor_sp) // cache only positive matches since the table might grow
+        m_cache[real_isa] = descriptor_sp;
+    return descriptor_sp;
+}
+
+bool
+AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA (ObjCISA isa, ObjCISA& ret_isa)
+{
+    if ( (isa & ~m_objc_debug_isa_class_mask) == 0)
+        return false;
+    if ( (isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value)
+    {
+        ret_isa = isa & m_objc_debug_isa_class_mask;
+        return (ret_isa != 0); // this is a pointer so 0 is not a valid value
+    }
+    return false;
+}
+
+ObjCLanguageRuntime::EncodingToTypeSP
+AppleObjCRuntimeV2::GetEncodingToType ()
+{
+    if (!m_encoding_to_type_sp)
+        m_encoding_to_type_sp.reset(new AppleObjCTypeEncodingParser(*this));
+    return m_encoding_to_type_sp;
+}
+
+lldb_private::AppleObjCRuntime::ObjCISA
+AppleObjCRuntimeV2::GetPointerISA (ObjCISA isa)
+{
+    ObjCISA ret = isa;
+    
+    if (m_non_pointer_isa_cache_ap)
+        m_non_pointer_isa_cache_ap->EvaluateNonPointerISA(isa, ret);
+    
+    return ret;
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h
new file mode 100644
index 000000000000..96b47e8770f9
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h
@@ -0,0 +1,336 @@
+//===-- AppleObjCRuntimeV2.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCRuntimeV2_h_
+#define liblldb_AppleObjCRuntimeV2_h_
+
+// C Includes
+// C++ Includes
+#include <map>
+#include <memory>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "AppleObjCRuntime.h"
+
+class RemoteNXMapTable;
+
+namespace lldb_private {
+
+class AppleObjCRuntimeV2 :
+        public AppleObjCRuntime
+{
+public:
+    ~AppleObjCRuntimeV2() override = default;
+
+    //------------------------------------------------------------------
+    // Static Functions
+    //------------------------------------------------------------------
+    static void
+    Initialize();
+    
+    static void
+    Terminate();
+    
+    static lldb_private::LanguageRuntime *
+    CreateInstance (Process *process, lldb::LanguageType language);
+    
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+
+    static bool classof(const ObjCLanguageRuntime* runtime)
+    {
+        switch (runtime->GetRuntimeVersion())
+        {
+            case ObjCRuntimeVersions::eAppleObjC_V2:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    // These are generic runtime functions:
+    bool
+    GetDynamicTypeAndAddress(ValueObject &in_value,
+                             lldb::DynamicValueType use_dynamic,
+                             TypeAndOrName &class_type_or_name,
+                             Address &address,
+                             Value::ValueType &value_type) override;
+    
+    UtilityFunction *
+    CreateObjectChecker(const char *) override;
+
+    //------------------------------------------------------------------
+    // PluginInterface protocol
+    //------------------------------------------------------------------
+    ConstString
+    GetPluginName() override;
+    
+    uint32_t
+    GetPluginVersion() override;
+    
+    ObjCRuntimeVersions
+    GetRuntimeVersion() const override
+    {
+        return ObjCRuntimeVersions::eAppleObjC_V2;
+    }
+
+    size_t
+    GetByteOffsetForIvar(CompilerType &parent_qual_type, const char *ivar_name) override;
+
+    void
+    UpdateISAToDescriptorMapIfNeeded() override;
+    
+    ConstString
+    GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) override;
+    
+    ClassDescriptorSP
+    GetClassDescriptor(ValueObject& in_value) override;
+    
+    ClassDescriptorSP
+    GetClassDescriptorFromISA(ObjCISA isa) override;
+    
+    DeclVendor *
+    GetDeclVendor() override;
+    
+    lldb::addr_t
+    LookupRuntimeSymbol(const ConstString &name) override;
+    
+    EncodingToTypeSP
+    GetEncodingToType() override;
+    
+    TaggedPointerVendor*
+    GetTaggedPointerVendor() override
+    {
+        return m_tagged_pointer_vendor_ap.get();
+    }
+    
+    // none of these are valid ISAs - we use them to infer the type
+    // of tagged pointers - if we have something meaningful to say
+    // we report an actual type - otherwise, we just say tagged
+    // there is no connection between the values here and the tagged pointers map
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA = 1;
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSAtom = 2;
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSNumber = 3;
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDateTS = 4;
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSManagedObject = 5;
+    static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDate = 6;
+
+protected:
+    lldb::BreakpointResolverSP
+    CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) override;
+
+private:
+    class HashTableSignature
+    {
+    public:
+        HashTableSignature ();
+
+        bool
+        NeedsUpdate (Process *process,
+                     AppleObjCRuntimeV2 *runtime,
+                     RemoteNXMapTable &hash_table);
+        
+        void
+        UpdateSignature (const RemoteNXMapTable &hash_table);
+
+    protected:
+        uint32_t m_count;
+        uint32_t m_num_buckets;
+        lldb::addr_t m_buckets_ptr;
+    };
+
+    class NonPointerISACache
+    {
+    public:
+        static NonPointerISACache*
+        CreateInstance (AppleObjCRuntimeV2& runtime,
+                        const lldb::ModuleSP& objc_module_sp);
+        
+
+        ObjCLanguageRuntime::ClassDescriptorSP
+        GetClassDescriptor (ObjCISA isa);
+
+    private:
+        NonPointerISACache (AppleObjCRuntimeV2& runtime,
+                            uint64_t objc_debug_isa_class_mask,
+                            uint64_t objc_debug_isa_magic_mask,
+                            uint64_t objc_debug_isa_magic_value);
+        
+        bool
+        EvaluateNonPointerISA (ObjCISA isa, ObjCISA& ret_isa);
+        
+        AppleObjCRuntimeV2&                                         m_runtime;
+        std::map<ObjCISA,ObjCLanguageRuntime::ClassDescriptorSP>    m_cache;
+        uint64_t                                                    m_objc_debug_isa_class_mask;
+        uint64_t                                                    m_objc_debug_isa_magic_mask;
+        uint64_t                                                    m_objc_debug_isa_magic_value;
+
+        friend class AppleObjCRuntimeV2;
+        
+        DISALLOW_COPY_AND_ASSIGN(NonPointerISACache);
+    };
+    
+    class TaggedPointerVendorV2 : public ObjCLanguageRuntime::TaggedPointerVendor
+    {
+    public:
+        ~TaggedPointerVendorV2() override = default;
+
+        static TaggedPointerVendorV2*
+        CreateInstance (AppleObjCRuntimeV2& runtime,
+                        const lldb::ModuleSP& objc_module_sp);
+
+    protected:
+        AppleObjCRuntimeV2&                                         m_runtime;
+        
+        TaggedPointerVendorV2 (AppleObjCRuntimeV2& runtime) :
+        TaggedPointerVendor(),
+        m_runtime(runtime)
+        {
+        }
+
+    private:
+        DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorV2);
+    };
+    
+    class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2
+    {
+    public:
+        bool
+        IsPossibleTaggedPointer(lldb::addr_t ptr) override;
+        
+        ObjCLanguageRuntime::ClassDescriptorSP
+        GetClassDescriptor(lldb::addr_t ptr) override;
+
+    protected:
+        TaggedPointerVendorRuntimeAssisted (AppleObjCRuntimeV2& runtime,
+                                             uint64_t objc_debug_taggedpointer_mask,
+                                             uint32_t objc_debug_taggedpointer_slot_shift,
+                                             uint32_t objc_debug_taggedpointer_slot_mask,
+                                             uint32_t objc_debug_taggedpointer_payload_lshift,
+                                             uint32_t objc_debug_taggedpointer_payload_rshift,
+                                             lldb::addr_t objc_debug_taggedpointer_classes);
+        
+        typedef std::map<uint8_t,ObjCLanguageRuntime::ClassDescriptorSP> Cache;
+        typedef Cache::iterator CacheIterator;
+        Cache                                                       m_cache;
+        uint64_t                                                    m_objc_debug_taggedpointer_mask;
+        uint32_t                                                    m_objc_debug_taggedpointer_slot_shift;
+        uint32_t                                                    m_objc_debug_taggedpointer_slot_mask;
+        uint32_t                                                    m_objc_debug_taggedpointer_payload_lshift;
+        uint32_t                                                    m_objc_debug_taggedpointer_payload_rshift;
+        lldb::addr_t                                                m_objc_debug_taggedpointer_classes;
+        
+        friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
+        
+        DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorRuntimeAssisted);
+    };
+    
+    class TaggedPointerVendorLegacy : public TaggedPointerVendorV2
+    {
+    public:
+        bool
+        IsPossibleTaggedPointer(lldb::addr_t ptr) override;
+        
+        ObjCLanguageRuntime::ClassDescriptorSP
+        GetClassDescriptor (lldb::addr_t ptr) override;
+
+    protected:
+        TaggedPointerVendorLegacy (AppleObjCRuntimeV2& runtime) :
+        TaggedPointerVendorV2 (runtime)
+        {
+        }
+        
+        friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
+        
+        DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorLegacy);
+    };
+    
+    struct DescriptorMapUpdateResult
+    {
+        bool update_ran;
+        bool any_found;
+        
+        DescriptorMapUpdateResult (bool ran,
+                                   bool found)
+        {
+            update_ran = ran;
+            any_found = found;
+        }
+        
+        static DescriptorMapUpdateResult
+        Fail ()
+        {
+            return {false, false};
+        }
+        
+        static DescriptorMapUpdateResult
+        Success ()
+        {
+            return {true, true};
+        }
+    };
+    
+    AppleObjCRuntimeV2 (Process *process,
+                        const lldb::ModuleSP &objc_module_sp);
+    
+    ObjCISA
+    GetPointerISA (ObjCISA isa);
+    
+    bool
+    IsTaggedPointer(lldb::addr_t ptr);
+    
+    lldb::addr_t
+    GetISAHashTablePointer ();
+
+    bool
+    UpdateISAToDescriptorMapFromMemory (RemoteNXMapTable &hash_table);
+    
+    bool
+    UpdateISAToDescriptorMapDynamic(RemoteNXMapTable &hash_table);
+    
+    uint32_t
+    ParseClassInfoArray (const lldb_private::DataExtractor &data,
+                         uint32_t num_class_infos);
+    
+    DescriptorMapUpdateResult
+    UpdateISAToDescriptorMapSharedCache ();
+    
+    void
+    WarnIfNoClassesCached ();
+
+    lldb::addr_t
+    GetSharedCacheReadOnlyAddress();
+    
+    friend class ClassDescriptorV2;
+
+    std::unique_ptr<UtilityFunction>        m_get_class_info_code;
+    lldb::addr_t                            m_get_class_info_args;
+    Mutex                                   m_get_class_info_args_mutex;
+
+    std::unique_ptr<UtilityFunction>        m_get_shared_cache_class_info_code;
+    lldb::addr_t                            m_get_shared_cache_class_info_args;
+    Mutex                                   m_get_shared_cache_class_info_args_mutex;
+
+    std::unique_ptr<DeclVendor>             m_decl_vendor_ap;
+    lldb::addr_t                            m_isa_hash_table_ptr;
+    HashTableSignature                      m_hash_signature;
+    bool                                    m_has_object_getClass;
+    bool                                    m_loaded_objc_opt;
+    std::unique_ptr<NonPointerISACache>     m_non_pointer_isa_cache_ap;
+    std::unique_ptr<TaggedPointerVendor>    m_tagged_pointer_vendor_ap;
+    EncodingToTypeSP                        m_encoding_to_type_sp;
+    bool                                    m_noclasses_warning_emitted;
+};
+    
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCRuntimeV2_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
new file mode 100644
index 000000000000..d38a076ad5d7
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
@@ -0,0 +1,1144 @@
+//===-- AppleObjCTrampolineHandler.cpp ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCTrampolineHandler.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "AppleThreadPlanStepThroughObjCTrampoline.h"
+
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Expression/UserExpression.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Host/FileSpec.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/ThreadPlanRunToAddress.h"
+
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name = "__lldb_objc_find_implementation_for_selector";
+const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_code = NULL;
+const char *AppleObjCTrampolineHandler::g_lookup_implementation_with_stret_function_code = "                               \n\
+extern \"C\"                                                                                                    \n\
+{                                                                                                               \n\
+    extern void *class_getMethodImplementation(void *objc_class, void *sel);                                    \n\
+    extern void *class_getMethodImplementation_stret(void *objc_class, void *sel);                              \n\
+    extern void * object_getClass (id object);                                                                  \n\
+    extern void * sel_getUid(char *name);                                                                       \n\
+    extern int printf(const char *format, ...);                                                                 \n\
+}                                                                                                               \n\
+extern \"C\" void * __lldb_objc_find_implementation_for_selector (void *object,                                 \n\
+                                                    void *sel,                                                  \n\
+                                                    int is_stret,                                               \n\
+                                                    int is_super,                                               \n\
+                                                    int is_super2,                                              \n\
+                                                    int is_fixup,                                               \n\
+                                                    int is_fixed,                                               \n\
+                                                    int debug)                                                  \n\
+{                                                                                                               \n\
+    struct __lldb_imp_return_struct                                                                             \n\
+    {                                                                                                           \n\
+        void *class_addr;                                                                                       \n\
+        void *sel_addr;                                                                                         \n\
+        void *impl_addr;                                                                                        \n\
+    };                                                                                                          \n\
+                                                                                                                \n\
+    struct __lldb_objc_class {                                                                                  \n\
+        void *isa;                                                                                              \n\
+        void *super_ptr;                                                                                        \n\
+    };                                                                                                          \n\
+    struct __lldb_objc_super {                                                                                  \n\
+        void *reciever;                                                                                         \n\
+        struct __lldb_objc_class *class_ptr;                                                                    \n\
+    };                                                                                                          \n\
+    struct __lldb_msg_ref {                                                                                     \n\
+        void *dont_know;                                                                                        \n\
+        void *sel;                                                                                              \n\
+    };                                                                                                          \n\
+                                                                                                                \n\
+    struct __lldb_imp_return_struct return_struct;                                                              \n\
+                                                                                                                \n\
+    if (debug)                                                                                                  \n\
+        printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \"                          \n\
+                \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\",                                               \n\
+                 object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed);                               \n\
+    if (is_super)                                                                                               \n\
+    {                                                                                                           \n\
+        if (is_super2)                                                                                          \n\
+        {                                                                                                       \n\
+            return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr;                    \n\
+        }                                                                                                       \n\
+        else                                                                                                    \n\
+        {                                                                                                       \n\
+            return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;                               \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+    else                                                                                                        \n\
+    {                                                                                                           \n\
+        // This code seems a little funny, but has its reasons...                                               \n\
+        // The call to [object class] is here because if this is a class, and has not been called into          \n\
+        // yet, we need to do something to force the class to initialize itself.                                \n\
+        // Then the call to object_getClass will actually return the correct class, either the class            \n\
+        // if object is a class instance, or the meta-class if it is a class pointer.                           \n\
+        void *class_ptr = (void *) [(id) object class];                                                         \n\
+        return_struct.class_addr = (id)  object_getClass((id) object);                                          \n\
+        if (debug)                                                                                              \n\
+        {                                                                                                       \n\
+            if (class_ptr == object)                                                                            \n\
+            {                                                                                                   \n\
+                printf (\"Found a class object, need to use the meta class %p -> %p\\n\",                       \n\
+                        class_ptr, return_struct.class_addr);                                                   \n\
+            }                                                                                                   \n\
+            else                                                                                                \n\
+            {                                                                                                   \n\
+                 printf (\"[object class] returned: %p object_getClass: %p.\\n\",                               \n\
+                 class_ptr, return_struct.class_addr);                                                          \n\
+            }                                                                                                   \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+                                                                                                                \n\
+    if (is_fixup)                                                                                               \n\
+    {                                                                                                           \n\
+        if (is_fixed)                                                                                           \n\
+        {                                                                                                       \n\
+            return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel;                                             \n\
+        }                                                                                                       \n\
+        else                                                                                                    \n\
+        {                                                                                                       \n\
+            char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel;                                            \n\
+            return_struct.sel_addr = sel_getUid (sel_name);                                                     \n\
+            if (debug)                                                                                          \n\
+                printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",                                   \n\
+                        return_struct.sel_addr, sel_name);                                                      \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+    else                                                                                                        \n\
+    {                                                                                                           \n\
+        return_struct.sel_addr = sel;                                                                           \n\
+    }                                                                                                           \n\
+                                                                                                                \n\
+    if (is_stret)                                                                                               \n\
+    {                                                                                                           \n\
+        return_struct.impl_addr = class_getMethodImplementation_stret (return_struct.class_addr,                \n\
+                                                                       return_struct.sel_addr);                 \n\
+    }                                                                                                           \n\
+    else                                                                                                        \n\
+    {                                                                                                           \n\
+        return_struct.impl_addr = class_getMethodImplementation (return_struct.class_addr,                      \n\
+                                                                       return_struct.sel_addr);                 \n\
+    }                                                                                                           \n\
+    if (debug)                                                                                                  \n\
+        printf (\"\\n*** Returning implementation: %p.\\n\", return_struct.impl_addr);                          \n\
+                                                                                                                \n\
+    return return_struct.impl_addr;                                                                             \n\
+}                                                                                                               \n\
+";
+const char *AppleObjCTrampolineHandler::g_lookup_implementation_no_stret_function_code = "                      \n\
+extern \"C\"                                                                                                    \n\
+{                                                                                                               \n\
+    extern void *class_getMethodImplementation(void *objc_class, void *sel);                                    \n\
+    extern void * object_getClass (id object);                                                                  \n\
+    extern void * sel_getUid(char *name);                                                                       \n\
+    extern int printf(const char *format, ...);                                                                 \n\
+}                                                                                                               \n\
+extern \"C\" void * __lldb_objc_find_implementation_for_selector (void *object,                                 \n\
+                                                    void *sel,                                                  \n\
+                                                    int is_stret,                                               \n\
+                                                    int is_super,                                               \n\
+                                                    int is_super2,                                              \n\
+                                                    int is_fixup,                                               \n\
+                                                    int is_fixed,                                               \n\
+                                                    int debug)                                                  \n\
+{                                                                                                               \n\
+    struct __lldb_imp_return_struct                                                                             \n\
+    {                                                                                                           \n\
+        void *class_addr;                                                                                       \n\
+        void *sel_addr;                                                                                         \n\
+        void *impl_addr;                                                                                        \n\
+    };                                                                                                          \n\
+                                                                                                                \n\
+    struct __lldb_objc_class {                                                                                  \n\
+        void *isa;                                                                                              \n\
+        void *super_ptr;                                                                                        \n\
+    };                                                                                                          \n\
+    struct __lldb_objc_super {                                                                                  \n\
+        void *reciever;                                                                                         \n\
+        struct __lldb_objc_class *class_ptr;                                                                    \n\
+    };                                                                                                          \n\
+    struct __lldb_msg_ref {                                                                                     \n\
+        void *dont_know;                                                                                        \n\
+        void *sel;                                                                                              \n\
+    };                                                                                                          \n\
+                                                                                                                \n\
+    struct __lldb_imp_return_struct return_struct;                                                              \n\
+                                                                                                                \n\
+    if (debug)                                                                                                  \n\
+        printf (\"\\n*** Called with obj: 0x%p sel: 0x%p is_stret: %d is_super: %d, \"                          \n\
+                \"is_super2: %d, is_fixup: %d, is_fixed: %d\\n\",                                               \n\
+                 object, sel, is_stret, is_super, is_super2, is_fixup, is_fixed);                               \n\
+    if (is_super)                                                                                               \n\
+    {                                                                                                           \n\
+        if (is_super2)                                                                                          \n\
+        {                                                                                                       \n\
+            return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr->super_ptr;                    \n\
+        }                                                                                                       \n\
+        else                                                                                                    \n\
+        {                                                                                                       \n\
+            return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;                               \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+    else                                                                                                        \n\
+    {                                                                                                           \n\
+        // This code seems a little funny, but has its reasons...                                               \n\
+        // The call to [object class] is here because if this is a class, and has not been called into          \n\
+        // yet, we need to do something to force the class to initialize itself.                                \n\
+        // Then the call to object_getClass will actually return the correct class, either the class            \n\
+        // if object is a class instance, or the meta-class if it is a class pointer.                           \n\
+        void *class_ptr = (void *) [(id) object class];                                                         \n\
+        return_struct.class_addr = (id)  object_getClass((id) object);                                          \n\
+        if (debug)                                                                                              \n\
+        {                                                                                                       \n\
+            if (class_ptr == object)                                                                            \n\
+            {                                                                                                   \n\
+                printf (\"Found a class object, need to return the meta class %p -> %p\\n\",                    \n\
+                        class_ptr, return_struct.class_addr);                                                   \n\
+            }                                                                                                   \n\
+            else                                                                                                \n\
+            {                                                                                                   \n\
+                 printf (\"[object class] returned: %p object_getClass: %p.\\n\",                               \n\
+                 class_ptr, return_struct.class_addr);                                                          \n\
+            }                                                                                                   \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+                                                                                                                \n\
+    if (is_fixup)                                                                                               \n\
+    {                                                                                                           \n\
+        if (is_fixed)                                                                                           \n\
+        {                                                                                                       \n\
+            return_struct.sel_addr = ((__lldb_msg_ref *) sel)->sel;                                             \n\
+        }                                                                                                       \n\
+        else                                                                                                    \n\
+        {                                                                                                       \n\
+            char *sel_name = (char *) ((__lldb_msg_ref *) sel)->sel;                                            \n\
+            return_struct.sel_addr = sel_getUid (sel_name);                                                     \n\
+            if (debug)                                                                                          \n\
+                printf (\"\\n*** Got fixed up selector: %p for name %s.\\n\",                                   \n\
+                        return_struct.sel_addr, sel_name);                                                      \n\
+        }                                                                                                       \n\
+    }                                                                                                           \n\
+    else                                                                                                        \n\
+    {                                                                                                           \n\
+        return_struct.sel_addr = sel;                                                                           \n\
+    }                                                                                                           \n\
+                                                                                                                \n\
+    return_struct.impl_addr = class_getMethodImplementation (return_struct.class_addr,                          \n\
+                                                             return_struct.sel_addr);                           \n\
+    if (debug)                                                                                                  \n\
+        printf (\"\\n*** Returning implementation: 0x%p.\\n\", return_struct.impl_addr);                        \n\
+                                                                                                                \n\
+    return return_struct.impl_addr;                                                                             \n\
+}                                                                                                               \n\
+";
+
+AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr) :
+    m_valid (true),
+    m_owner(owner),
+    m_header_addr (header_addr),
+    m_code_start_addr(0),
+    m_code_end_addr (0),
+    m_next_region (0)
+{
+    SetUpRegion ();
+}
+
+AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler()
+{
+}
+
+void
+AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion()
+{
+    // The header looks like:
+    //
+    //   uint16_t headerSize
+    //   uint16_t descSize
+    //   uint32_t descCount
+    //   void * next
+    //
+    // First read in the header:
+    
+    char memory_buffer[16];
+    ProcessSP process_sp = m_owner->GetProcessSP();
+    if (!process_sp)
+        return;
+    DataExtractor data(memory_buffer, sizeof(memory_buffer), 
+                       process_sp->GetByteOrder(),
+                       process_sp->GetAddressByteSize());
+    size_t actual_size = 8 + process_sp->GetAddressByteSize();
+    Error error;
+    size_t bytes_read = process_sp->ReadMemory (m_header_addr, memory_buffer, actual_size, error);
+    if (bytes_read != actual_size)
+    {
+        m_valid = false;
+        return;
+    }
+    
+    lldb::offset_t offset = 0;
+    const uint16_t header_size = data.GetU16(&offset);
+    const uint16_t descriptor_size = data.GetU16(&offset);
+    const size_t num_descriptors = data.GetU32(&offset);
+    
+    m_next_region = data.GetPointer(&offset);
+    
+    // If the header size is 0, that means we've come in too early before this data is set up.
+    // Set ourselves as not valid, and continue.
+    if (header_size == 0 || num_descriptors == 0)
+    {
+        m_valid = false;
+        return;
+    }
+    
+    // Now read in all the descriptors:
+    // The descriptor looks like:
+    //
+    // uint32_t offset
+    // uint32_t flags
+    //
+    // Where offset is either 0 - in which case it is unused, or
+    // it is the offset of the vtable code from the beginning of the descriptor record.
+    // Below, we'll convert that into an absolute code address, since I don't want to have
+    // to compute it over and over.
+    
+    // Ingest the whole descriptor array:
+    const lldb::addr_t desc_ptr = m_header_addr + header_size;
+    const size_t desc_array_size = num_descriptors * descriptor_size;
+    DataBufferSP data_sp(new DataBufferHeap (desc_array_size, '\0'));
+    uint8_t* dst = (uint8_t*)data_sp->GetBytes();
+
+    DataExtractor desc_extractor (dst, desc_array_size,
+                                  process_sp->GetByteOrder(),
+                                  process_sp->GetAddressByteSize());
+    bytes_read = process_sp->ReadMemory(desc_ptr, dst, desc_array_size, error);
+    if (bytes_read != desc_array_size)
+    {
+        m_valid = false;
+        return;
+    }
+    
+    // The actual code for the vtables will be laid out consecutively, so I also
+    // compute the start and end of the whole code block.
+
+    offset = 0;
+    m_code_start_addr = 0;
+    m_code_end_addr = 0;
+
+    for (size_t i = 0; i < num_descriptors; i++)
+    {
+        lldb::addr_t start_offset = offset;
+        uint32_t voffset = desc_extractor.GetU32 (&offset);
+        uint32_t flags  = desc_extractor.GetU32 (&offset);
+        lldb::addr_t code_addr = desc_ptr + start_offset + voffset;
+        m_descriptors.push_back (VTableDescriptor(flags, code_addr));
+        
+        if (m_code_start_addr == 0 || code_addr < m_code_start_addr)
+            m_code_start_addr = code_addr;
+        if (code_addr > m_code_end_addr)
+            m_code_end_addr = code_addr;
+            
+        offset = start_offset + descriptor_size;
+    }
+    // Finally, a little bird told me that all the vtable code blocks are the same size.  
+    // Let's compute the blocks and if they are all the same add the size to the code end address:
+    lldb::addr_t code_size = 0;
+    bool all_the_same = true;
+    for (size_t i = 0; i < num_descriptors - 1; i++)
+    {
+        lldb::addr_t this_size = m_descriptors[i + 1].code_start - m_descriptors[i].code_start;
+        if (code_size == 0)
+            code_size = this_size;
+        else
+        {
+            if (this_size != code_size)
+                all_the_same = false;
+            if (this_size > code_size)
+                code_size = this_size;
+        }
+    }
+    if (all_the_same)
+        m_code_end_addr += code_size;
+}
+
+bool 
+AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::AddressInRegion (lldb::addr_t addr, uint32_t &flags)
+{
+    if (!IsValid())
+        return false;
+        
+    if (addr < m_code_start_addr || addr > m_code_end_addr)
+        return false;
+        
+    std::vector<VTableDescriptor>::iterator pos, end = m_descriptors.end();
+    for (pos = m_descriptors.begin(); pos != end; pos++)
+    {
+        if (addr <= (*pos).code_start)
+        {
+            flags = (*pos).flags;
+            return true;
+        }
+    }
+    return false;
+}
+
+void
+AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::Dump (Stream &s)
+{
+    s.Printf ("Header addr: 0x%" PRIx64 " Code start: 0x%" PRIx64 " Code End: 0x%" PRIx64 " Next: 0x%" PRIx64 "\n",
+              m_header_addr, m_code_start_addr, m_code_end_addr, m_next_region);
+    size_t num_elements = m_descriptors.size();
+    for (size_t i = 0; i < num_elements; i++)
+    {
+        s.Indent();
+        s.Printf ("Code start: 0x%" PRIx64 " Flags: %d\n", m_descriptors[i].code_start, m_descriptors[i].flags);
+    }
+}
+        
+AppleObjCTrampolineHandler::AppleObjCVTables::AppleObjCVTables (const ProcessSP &process_sp, 
+                                                                const ModuleSP &objc_module_sp) :
+    m_process_wp (),
+    m_trampoline_header (LLDB_INVALID_ADDRESS),
+    m_trampolines_changed_bp_id (LLDB_INVALID_BREAK_ID),
+    m_objc_module_sp (objc_module_sp)
+{
+    if (process_sp)
+        m_process_wp = process_sp;
+}
+
+AppleObjCTrampolineHandler::AppleObjCVTables::~AppleObjCVTables()
+{
+    ProcessSP process_sp = GetProcessSP ();
+    if (process_sp)
+    {
+        if (m_trampolines_changed_bp_id != LLDB_INVALID_BREAK_ID)
+            process_sp->GetTarget().RemoveBreakpointByID (m_trampolines_changed_bp_id);
+    }
+}
+
+bool
+AppleObjCTrampolineHandler::AppleObjCVTables::InitializeVTableSymbols ()
+{
+    if (m_trampoline_header != LLDB_INVALID_ADDRESS)
+        return true;
+
+    ProcessSP process_sp = GetProcessSP ();
+    if (process_sp)
+    {
+        Target &target = process_sp->GetTarget();
+        
+        const ModuleList &target_modules = target.GetImages();
+        Mutex::Locker modules_locker(target_modules.GetMutex());
+        size_t num_modules = target_modules.GetSize();
+        if (!m_objc_module_sp)
+        {
+            for (size_t i = 0; i < num_modules; i++)
+            {
+                if (process_sp->GetObjCLanguageRuntime()->IsModuleObjCLibrary (target_modules.GetModuleAtIndexUnlocked(i)))
+                {
+                    m_objc_module_sp = target_modules.GetModuleAtIndexUnlocked(i);
+                    break;
+                }
+            }
+        }
+        
+        if (m_objc_module_sp)
+        {
+            ConstString trampoline_name ("gdb_objc_trampolines");
+            const Symbol *trampoline_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (trampoline_name, 
+                                                                                                eSymbolTypeData);
+            if (trampoline_symbol != NULL)
+            {
+                m_trampoline_header = trampoline_symbol->GetLoadAddress(&target);
+                if (m_trampoline_header == LLDB_INVALID_ADDRESS)
+                    return false;
+                
+                // Next look up the "changed" symbol and set a breakpoint on that...
+                ConstString changed_name ("gdb_objc_trampolines_changed");
+                const Symbol *changed_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (changed_name, 
+                                                                                                 eSymbolTypeCode);
+                if (changed_symbol != NULL)
+                {
+                    const Address changed_symbol_addr = changed_symbol->GetAddress();
+                    if (!changed_symbol_addr.IsValid())
+                        return false;
+                        
+                    lldb::addr_t changed_addr = changed_symbol_addr.GetOpcodeLoadAddress (&target);
+                    if (changed_addr != LLDB_INVALID_ADDRESS)
+                    {
+                        BreakpointSP trampolines_changed_bp_sp = target.CreateBreakpoint (changed_addr, true, false);
+                        if (trampolines_changed_bp_sp)
+                        {
+                            m_trampolines_changed_bp_id = trampolines_changed_bp_sp->GetID();
+                            trampolines_changed_bp_sp->SetCallback (RefreshTrampolines, this, true);
+                            trampolines_changed_bp_sp->SetBreakpointKind ("objc-trampolines-changed");
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+    
+bool 
+AppleObjCTrampolineHandler::AppleObjCVTables::RefreshTrampolines (void *baton, 
+                                                                  StoppointCallbackContext *context, 
+                                                                  lldb::user_id_t break_id, 
+                                                                  lldb::user_id_t break_loc_id)
+{
+    AppleObjCVTables *vtable_handler = (AppleObjCVTables *) baton;
+    if (vtable_handler->InitializeVTableSymbols())
+    {
+        // The Update function is called with the address of an added region.  So we grab that address, and
+        // feed it into ReadRegions.  Of course, our friend the ABI will get the values for us.
+        ExecutionContext exe_ctx (context->exe_ctx_ref);
+        Process *process = exe_ctx.GetProcessPtr();
+        const ABI *abi = process->GetABI().get();
+        
+        ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
+        ValueList argument_values;
+        Value input_value;
+        CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+
+        input_value.SetValueType (Value::eValueTypeScalar);
+        //input_value.SetContext (Value::eContextTypeClangType, clang_void_ptr_type);
+        input_value.SetCompilerType (clang_void_ptr_type);
+        argument_values.PushValue(input_value);
+        
+        bool success = abi->GetArgumentValues (exe_ctx.GetThreadRef(), argument_values);
+        if (!success)
+            return false;
+            
+        // Now get a pointer value from the zeroth argument.
+        Error error;
+        DataExtractor data;
+        error = argument_values.GetValueAtIndex(0)->GetValueAsData (&exe_ctx, 
+                                                                    data, 
+                                                                    0,
+                                                                    NULL);
+        lldb::offset_t offset = 0;
+        lldb::addr_t region_addr = data.GetPointer(&offset);
+        
+        if (region_addr != 0)
+            vtable_handler->ReadRegions(region_addr);
+    }
+    return false;
+}
+
+bool
+AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions ()
+{
+    // The no argument version reads the start region from the value of the gdb_regions_header, and 
+    // gets started from there.
+    
+    m_regions.clear();
+    if (!InitializeVTableSymbols())
+        return false;
+    Error error;
+    ProcessSP process_sp = GetProcessSP ();
+    if (process_sp)
+    {
+        lldb::addr_t region_addr = process_sp->ReadPointerFromMemory (m_trampoline_header, error);
+        if (error.Success())
+            return ReadRegions (region_addr);
+    }
+    return false;
+}
+
+bool
+AppleObjCTrampolineHandler::AppleObjCVTables::ReadRegions (lldb::addr_t region_addr)
+{
+    ProcessSP process_sp = GetProcessSP ();
+    if (!process_sp)
+        return false;
+        
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+    
+    // We aren't starting at the trampoline symbol.
+    InitializeVTableSymbols ();
+    lldb::addr_t next_region = region_addr;
+    
+    // Read in the sizes of the headers.
+    while (next_region != 0) 
+    {
+        m_regions.push_back (VTableRegion(this, next_region));
+        if (!m_regions.back().IsValid())
+        {
+            m_regions.clear();
+            return false;
+        }
+        if (log)
+        {
+            StreamString s;
+            m_regions.back().Dump(s);
+            log->Printf("Read vtable region: \n%s", s.GetData());
+        }
+        
+        next_region = m_regions.back().GetNextRegionAddr();
+    }
+    
+    return true;
+}
+    
+bool
+AppleObjCTrampolineHandler::AppleObjCVTables::IsAddressInVTables (lldb::addr_t addr, uint32_t &flags)
+{
+    region_collection::iterator pos, end = m_regions.end();
+    for (pos = m_regions.begin(); pos != end; pos++)
+    {
+        if ((*pos).AddressInRegion (addr, flags))
+            return true;
+    }
+    return false;
+}
+
+const AppleObjCTrampolineHandler::DispatchFunction
+AppleObjCTrampolineHandler::g_dispatch_functions[] =
+{
+    // NAME                              STRET  SUPER  SUPER2  FIXUP TYPE
+    {"objc_msgSend",                     false, false, false, DispatchFunction::eFixUpNone    },
+    {"objc_msgSend_fixup",               false, false, false, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSend_fixedup",             false, false, false, DispatchFunction::eFixUpFixed   },
+    {"objc_msgSend_stret",               true,  false, false, DispatchFunction::eFixUpNone    },
+    {"objc_msgSend_stret_fixup",         true,  false, false, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSend_stret_fixedup",       true,  false, false, DispatchFunction::eFixUpFixed   },
+    {"objc_msgSend_fpret",               false, false, false, DispatchFunction::eFixUpNone    },
+    {"objc_msgSend_fpret_fixup",         false, false, false, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSend_fpret_fixedup",       false, false, false, DispatchFunction::eFixUpFixed   },
+    {"objc_msgSend_fp2ret",              false, false,  true, DispatchFunction::eFixUpNone    },
+    {"objc_msgSend_fp2ret_fixup",        false, false,  true, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSend_fp2ret_fixedup",      false, false,  true, DispatchFunction::eFixUpFixed   },
+    {"objc_msgSendSuper",                false, true,  false, DispatchFunction::eFixUpNone    },
+    {"objc_msgSendSuper_stret",          true,  true,  false, DispatchFunction::eFixUpNone    },
+    {"objc_msgSendSuper2",               false, true,   true, DispatchFunction::eFixUpNone    },
+    {"objc_msgSendSuper2_fixup",         false, true,   true, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSendSuper2_fixedup",       false, true,   true, DispatchFunction::eFixUpFixed   },
+    {"objc_msgSendSuper2_stret",         true,  true,   true, DispatchFunction::eFixUpNone    },
+    {"objc_msgSendSuper2_stret_fixup",   true,  true,   true, DispatchFunction::eFixUpToFix   },
+    {"objc_msgSendSuper2_stret_fixedup", true,  true,   true, DispatchFunction::eFixUpFixed   },
+};
+
+AppleObjCTrampolineHandler::AppleObjCTrampolineHandler (const ProcessSP &process_sp, 
+                                                        const ModuleSP &objc_module_sp) :
+    m_process_wp (),
+    m_objc_module_sp (objc_module_sp),
+    m_impl_fn_addr (LLDB_INVALID_ADDRESS),
+    m_impl_stret_fn_addr (LLDB_INVALID_ADDRESS),
+    m_msg_forward_addr (LLDB_INVALID_ADDRESS)
+{
+    if (process_sp)
+        m_process_wp = process_sp;
+    // Look up the known resolution functions:
+    
+    ConstString get_impl_name("class_getMethodImplementation");
+    ConstString get_impl_stret_name("class_getMethodImplementation_stret");
+    ConstString msg_forward_name("_objc_msgForward");
+    ConstString msg_forward_stret_name("_objc_msgForward_stret");
+    
+    Target *target = process_sp ? &process_sp->GetTarget() : NULL;
+    const Symbol *class_getMethodImplementation = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_name, eSymbolTypeCode);
+    const Symbol *class_getMethodImplementation_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (get_impl_stret_name, eSymbolTypeCode);
+    const Symbol *msg_forward = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_name, eSymbolTypeCode);
+    const Symbol *msg_forward_stret = m_objc_module_sp->FindFirstSymbolWithNameAndType (msg_forward_stret_name, eSymbolTypeCode);
+    
+    if (class_getMethodImplementation)
+        m_impl_fn_addr = class_getMethodImplementation->GetAddress().GetOpcodeLoadAddress (target);
+    if  (class_getMethodImplementation_stret)
+        m_impl_stret_fn_addr = class_getMethodImplementation_stret->GetAddress().GetOpcodeLoadAddress (target);
+    if (msg_forward)
+        m_msg_forward_addr = msg_forward->GetAddress().GetOpcodeLoadAddress(target);
+    if  (msg_forward_stret)
+        m_msg_forward_stret_addr = msg_forward_stret->GetAddress().GetOpcodeLoadAddress(target);
+    
+    // FIXME: Do some kind of logging here.
+    if (m_impl_fn_addr == LLDB_INVALID_ADDRESS)
+    {
+        // If we can't even find the ordinary get method implementation function, then we aren't going to be able to
+        // step through any method dispatches.  Warn to that effect and get out of here.
+        if (process_sp->CanJIT())
+        {
+            process_sp->GetTarget().GetDebugger().GetErrorFile()->Printf ("Could not find implementation lookup function \"%s\""
+                                                                          " step in through ObjC method dispatch will not work.\n",
+                                                                          get_impl_name.AsCString());
+        }
+        return;
+    }
+    else if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS)
+    {
+        // It there is no stret return lookup function, assume that it is the same as the straight lookup:
+        m_impl_stret_fn_addr = m_impl_fn_addr;
+        // Also we will use the version of the lookup code that doesn't rely on the stret version of the function.
+        g_lookup_implementation_function_code = g_lookup_implementation_no_stret_function_code;
+    }
+    else
+    {
+        g_lookup_implementation_function_code = g_lookup_implementation_with_stret_function_code;
+    }
+        
+    // Look up the addresses for the objc dispatch functions and cache them.  For now I'm inspecting the symbol
+    // names dynamically to figure out how to dispatch to them.  If it becomes more complicated than this we can 
+    // turn the g_dispatch_functions char * array into a template table, and populate the DispatchFunction map
+    // from there.
+
+    for (size_t i = 0; i != llvm::array_lengthof(g_dispatch_functions); i++)
+    {
+        ConstString name_const_str(g_dispatch_functions[i].name);
+        const Symbol *msgSend_symbol = m_objc_module_sp->FindFirstSymbolWithNameAndType (name_const_str, eSymbolTypeCode);
+        if (msgSend_symbol && msgSend_symbol->ValueIsAddress())
+        {
+            // FixMe: Make g_dispatch_functions static table of DispatchFunctions, and have the map be address->index.
+            // Problem is we also need to lookup the dispatch function.  For now we could have a side table of stret & non-stret
+            // dispatch functions.  If that's as complex as it gets, we're fine.
+            
+            lldb::addr_t sym_addr = msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
+            
+            m_msgSend_map.insert(std::pair<lldb::addr_t, int>(sym_addr, i));
+        }
+    }
+    
+    // Build our vtable dispatch handler here:
+    m_vtables_ap.reset(new AppleObjCVTables(process_sp, m_objc_module_sp));
+    if (m_vtables_ap.get())
+        m_vtables_ap->ReadRegions();        
+}
+
+lldb::addr_t
+AppleObjCTrampolineHandler::SetupDispatchFunction (Thread &thread, ValueList &dispatch_values)
+{
+    ExecutionContext exe_ctx (thread.shared_from_this());
+    StreamString errors;
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+    lldb::addr_t args_addr = LLDB_INVALID_ADDRESS;
+    FunctionCaller *impl_function_caller = nullptr;
+
+    // Scope for mutex locker:
+    {
+        Mutex::Locker locker(m_impl_function_mutex);
+        
+        // First stage is to make the ClangUtility to hold our injected function:
+
+        if (!m_impl_code.get())
+        {
+            if (g_lookup_implementation_function_code != NULL)
+            {
+                Error error;
+                m_impl_code.reset (exe_ctx.GetTargetRef().GetUtilityFunctionForLanguage (g_lookup_implementation_function_code,
+                                                                                         eLanguageTypeObjC,
+                                                                                         g_lookup_implementation_function_name,
+                                                                                         error));
+                if (error.Fail())
+                {
+                    if (log)
+                        log->Printf ("Failed to get Utility Function for implementation lookup: %s.", error.AsCString());
+                    m_impl_code.reset();
+                    return args_addr;
+                }
+                
+                if (!m_impl_code->Install(errors, exe_ctx))
+                {
+                    if (log)
+                        log->Printf ("Failed to install implementation lookup: %s.", errors.GetData());
+                    m_impl_code.reset();
+                    return args_addr;
+                }
+            }
+            else
+            {
+                if (log)
+                    log->Printf("No method lookup implementation code.");
+                errors.Printf ("No method lookup implementation code found.");
+                return LLDB_INVALID_ADDRESS;
+            }
+            
+
+            // Next make the runner function for our implementation utility function.
+            ClangASTContext *clang_ast_context = thread.GetProcess()->GetTarget().GetScratchClangASTContext();
+            CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+            Error error;
+            
+            impl_function_caller = m_impl_code->MakeFunctionCaller(clang_void_ptr_type,
+                                                                   dispatch_values,
+                                                                   error);
+            if (error.Fail())
+            {
+                if (log)
+                    log->Printf ("Error getting function caller for dispatch lookup: \"%s\".", error.AsCString());
+                return args_addr;
+            }
+        }
+        else
+        {
+            impl_function_caller = m_impl_code->GetFunctionCaller();
+        }
+    }
+    
+    errors.Clear();
+    
+    // Now write down the argument values for this particular call.  This looks like it might be a race condition
+    // if other threads were calling into here, but actually it isn't because we allocate a new args structure for
+    // this call by passing args_addr = LLDB_INVALID_ADDRESS...
+
+    if (impl_function_caller->WriteFunctionArguments (exe_ctx, args_addr, dispatch_values, errors))
+    {
+        if (log)
+            log->Printf ("Error writing function arguments: \"%s\".", errors.GetData());
+        return args_addr;
+    }
+        
+    return args_addr;
+}
+
+ThreadPlanSP
+AppleObjCTrampolineHandler::GetStepThroughDispatchPlan (Thread &thread, bool stop_others)
+{
+    ThreadPlanSP ret_plan_sp;
+    lldb::addr_t curr_pc = thread.GetRegisterContext()->GetPC();
+    
+    DispatchFunction this_dispatch;
+    bool found_it = false;
+    
+    // First step is to look and see if we are in one of the known ObjC dispatch functions.  We've already compiled
+    // a table of same, so consult it.
+    
+    MsgsendMap::iterator pos;
+    pos = m_msgSend_map.find (curr_pc);
+    if (pos != m_msgSend_map.end())
+    {
+        this_dispatch = g_dispatch_functions[(*pos).second];
+        found_it = true;
+    }
+    
+    // Next check to see if we are in a vtable region:
+    
+    if (!found_it)
+    {
+        uint32_t flags;
+        if (m_vtables_ap.get())
+        {
+            found_it = m_vtables_ap->IsAddressInVTables (curr_pc, flags);
+            if (found_it)
+            {
+                this_dispatch.name = "vtable";
+                this_dispatch.stret_return 
+                        = (flags & AppleObjCVTables::eOBJC_TRAMPOLINE_STRET) == AppleObjCVTables::eOBJC_TRAMPOLINE_STRET;
+                this_dispatch.is_super = false;
+                this_dispatch.is_super2 = false;
+                this_dispatch.fixedup = DispatchFunction::eFixUpFixed;
+            }
+        }
+    }
+    
+    if (found_it)
+    {
+        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+
+        // We are decoding a method dispatch.  
+        // First job is to pull the arguments out:
+        
+        lldb::StackFrameSP thread_cur_frame = thread.GetStackFrameAtIndex(0);
+        
+        const ABI *abi = NULL;
+        ProcessSP process_sp (thread.CalculateProcess());
+        if (process_sp)
+            abi = process_sp->GetABI().get();
+        if (abi == NULL)
+            return ret_plan_sp;
+            
+        TargetSP target_sp (thread.CalculateTarget());
+        
+        ClangASTContext *clang_ast_context = target_sp->GetScratchClangASTContext();
+        ValueList argument_values;
+        Value void_ptr_value;
+        CompilerType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+        void_ptr_value.SetValueType (Value::eValueTypeScalar);
+        //void_ptr_value.SetContext (Value::eContextTypeClangType, clang_void_ptr_type);
+        void_ptr_value.SetCompilerType (clang_void_ptr_type);
+        
+        int obj_index;
+        int sel_index;
+        
+        // If this is a struct return dispatch, then the first argument is the
+        // return struct pointer, and the object is the second, and the selector is the third.
+        // Otherwise the object is the first and the selector the second.
+        if (this_dispatch.stret_return)
+        {
+            obj_index = 1;
+            sel_index = 2;
+            argument_values.PushValue(void_ptr_value);
+            argument_values.PushValue(void_ptr_value);
+            argument_values.PushValue(void_ptr_value);
+        }
+        else
+        {
+            obj_index = 0;
+            sel_index = 1;
+            argument_values.PushValue(void_ptr_value);
+            argument_values.PushValue(void_ptr_value);
+        }
+
+        
+        bool success = abi->GetArgumentValues (thread, argument_values);
+        if (!success)
+            return ret_plan_sp;
+        
+        lldb::addr_t obj_addr = argument_values.GetValueAtIndex(obj_index)->GetScalar().ULongLong();
+        if (obj_addr == 0x0)
+        {
+            if (log)
+                log->Printf("Asked to step to dispatch to nil object, returning empty plan.");
+            return ret_plan_sp;
+        }
+        
+        ExecutionContext exe_ctx (thread.shared_from_this());
+        Process *process = exe_ctx.GetProcessPtr();
+        // isa_addr will store the class pointer that the method is being dispatched to - so either the class
+        // directly or the super class if this is one of the objc_msgSendSuper flavors.  That's mostly used to
+        // look up the class/selector pair in our cache.
+        
+        lldb::addr_t isa_addr = LLDB_INVALID_ADDRESS;
+        lldb::addr_t sel_addr = argument_values.GetValueAtIndex(sel_index)->GetScalar().ULongLong();
+         
+        // Figure out the class this is being dispatched to and see if we've already cached this method call,
+        // If so we can push a run-to-address plan directly.  Otherwise we have to figure out where
+        // the implementation lives.
+
+        if (this_dispatch.is_super)
+        {
+            if (this_dispatch.is_super2)
+            {
+               // In the objc_msgSendSuper2 case, we don't get the object directly, we get a structure containing
+               // the object and the class to which the super message is being sent.  So we need to dig the super
+               // out of the class and use that.
+               
+                Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
+                super_value.GetScalar() += process->GetAddressByteSize();
+                super_value.ResolveValue (&exe_ctx);
+                
+                if (super_value.GetScalar().IsValid())
+                {
+                
+                    // isa_value now holds the class pointer.  The second word of the class pointer is the super-class pointer:
+                    super_value.GetScalar() += process->GetAddressByteSize();
+                    super_value.ResolveValue (&exe_ctx);
+                    if (super_value.GetScalar().IsValid())
+                        isa_addr = super_value.GetScalar().ULongLong();
+                    else
+                    {
+                       if (log)
+                        log->Printf("Failed to extract the super class value from the class in objc_super.");
+                    }
+                }
+                else
+                {
+                   if (log)
+                    log->Printf("Failed to extract the class value from objc_super.");
+                }
+            }
+            else
+            {
+               // In the objc_msgSendSuper case, we don't get the object directly, we get a two element structure containing
+               // the object and the super class to which the super message is being sent.  So the class we want is
+               // the second element of this structure.
+               
+                Value super_value(*(argument_values.GetValueAtIndex(obj_index)));
+                super_value.GetScalar() += process->GetAddressByteSize();
+                super_value.ResolveValue (&exe_ctx);
+                
+                if (super_value.GetScalar().IsValid())
+                {
+                    isa_addr = super_value.GetScalar().ULongLong();
+                }
+                else
+                {
+                   if (log)
+                    log->Printf("Failed to extract the class value from objc_super.");
+                }
+            }
+        }
+        else
+        {
+            // In the direct dispatch case, the object->isa is the class pointer we want.
+            
+            // This is a little cheesy, but since object->isa is the first field,
+            // making the object value a load address value and resolving it will get
+            // the pointer sized data pointed to by that value...
+            
+            // Note, it isn't a fatal error not to be able to get the address from the object, since this might
+            // be a "tagged pointer" which isn't a real object, but rather some word length encoded dingus.
+            
+            Value isa_value(*(argument_values.GetValueAtIndex(obj_index)));
+
+            isa_value.SetValueType(Value::eValueTypeLoadAddress);
+            isa_value.ResolveValue(&exe_ctx);
+            if (isa_value.GetScalar().IsValid())
+            {
+                isa_addr = isa_value.GetScalar().ULongLong();
+            }
+            else
+            {
+               if (log)
+                log->Printf("Failed to extract the isa value from object.");
+            }
+
+        } 
+        
+        // Okay, we've got the address of the class for which we're resolving this, let's see if it's in our cache:
+        lldb::addr_t impl_addr = LLDB_INVALID_ADDRESS;
+        
+        if (isa_addr != LLDB_INVALID_ADDRESS)
+        {
+            if (log)
+            {
+                log->Printf("Resolving call for class - 0x%" PRIx64 " and selector - 0x%" PRIx64,
+                            isa_addr, sel_addr);
+            }
+            ObjCLanguageRuntime *objc_runtime = thread.GetProcess()->GetObjCLanguageRuntime ();
+            assert(objc_runtime != NULL);
+            
+            impl_addr = objc_runtime->LookupInMethodCache (isa_addr, sel_addr);
+        }                                      
+                                                                                                                          
+        if (impl_addr != LLDB_INVALID_ADDRESS)
+        {
+            // Yup, it was in the cache, so we can run to that address directly.
+            
+            if (log)
+                log->Printf ("Found implementation address in cache: 0x%" PRIx64, impl_addr);
+                 
+            ret_plan_sp.reset (new ThreadPlanRunToAddress (thread, impl_addr, stop_others));
+        }
+        else
+        {
+            // We haven't seen this class/selector pair yet.  Look it up.
+            StreamString errors;
+            Address impl_code_address;
+            
+            ValueList dispatch_values;
+            
+            // We've will inject a little function in the target that takes the object, selector and some flags,
+            // and figures out the implementation.  Looks like:
+            //      void *__lldb_objc_find_implementation_for_selector (void *object, 
+            //                                                          void *sel, 
+            //                                                          int is_stret, 
+            //                                                          int is_super, 
+            //                                                          int is_super2, 
+            //                                                          int is_fixup, 
+            //                                                          int is_fixed,
+            //                                                          int debug)
+            // So set up the arguments for that call.
+            
+            dispatch_values.PushValue (*(argument_values.GetValueAtIndex(obj_index)));
+            dispatch_values.PushValue (*(argument_values.GetValueAtIndex(sel_index)));
+            
+            Value flag_value;
+            CompilerType clang_int_type = clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(lldb::eEncodingSint, 32);
+            flag_value.SetValueType (Value::eValueTypeScalar);
+            //flag_value.SetContext (Value::eContextTypeClangType, clang_int_type);
+            flag_value.SetCompilerType (clang_int_type);
+            
+            if (this_dispatch.stret_return)
+                flag_value.GetScalar() = 1;
+            else
+                flag_value.GetScalar() = 0;
+            dispatch_values.PushValue (flag_value);
+                    
+            if (this_dispatch.is_super)
+                flag_value.GetScalar() = 1;
+            else
+                flag_value.GetScalar() = 0;
+            dispatch_values.PushValue (flag_value);
+                    
+            if (this_dispatch.is_super2)
+                flag_value.GetScalar() = 1;
+            else
+                flag_value.GetScalar() = 0;
+            dispatch_values.PushValue (flag_value);
+                    
+            switch (this_dispatch.fixedup)
+            {
+              case DispatchFunction::eFixUpNone:
+                 flag_value.GetScalar() = 0;
+                 dispatch_values.PushValue (flag_value);
+                 dispatch_values.PushValue (flag_value);
+                 break;
+              case DispatchFunction::eFixUpFixed:
+                 flag_value.GetScalar() = 1;
+                 dispatch_values.PushValue (flag_value);
+                 flag_value.GetScalar() = 1;
+                 dispatch_values.PushValue (flag_value);
+                 break;
+              case DispatchFunction::eFixUpToFix:
+                 flag_value.GetScalar() = 1;
+                 dispatch_values.PushValue (flag_value);
+                 flag_value.GetScalar() = 0;
+                 dispatch_values.PushValue (flag_value);
+                 break;
+            }
+            if (log && log->GetVerbose())
+                flag_value.GetScalar() = 1;
+            else
+                flag_value.GetScalar() = 0;  // FIXME - Set to 0 when debugging is done.
+            dispatch_values.PushValue (flag_value);
+            
+            
+            // The step through code might have to fill in the cache, so it is not safe to run only one thread.
+            // So we override the stop_others value passed in to us here:
+            const bool trampoline_stop_others = false;
+            ret_plan_sp.reset (new AppleThreadPlanStepThroughObjCTrampoline (thread,
+                                                                             this,
+                                                                             dispatch_values,
+                                                                             isa_addr,
+                                                                             sel_addr,
+                                                                             trampoline_stop_others));
+            if (log)
+            {
+                StreamString s;
+                ret_plan_sp->GetDescription(&s, eDescriptionLevelFull);
+                log->Printf("Using ObjC step plan: %s.\n", s.GetData());
+            }
+        }
+    }
+    
+    return ret_plan_sp;
+}
+
+FunctionCaller *
+AppleObjCTrampolineHandler::GetLookupImplementationFunctionCaller ()
+{
+    return m_impl_code->GetFunctionCaller();
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h
new file mode 100644
index 000000000000..42d3461ddfa5
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h
@@ -0,0 +1,209 @@
+//===-- AppleObjCTrampolineHandler.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_AppleObjCTrampolineHandler_h_
+#define lldb_AppleObjCTrampolineHandler_h_
+
+// C Includes
+// C++ Includes
+#include <map>
+#include <vector>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-public.h"
+#include "lldb/Host/Mutex.h"
+#include "lldb/Expression/UtilityFunction.h"
+
+namespace lldb_private
+{
+  
+class AppleObjCTrampolineHandler {
+public:
+    AppleObjCTrampolineHandler (const lldb::ProcessSP &process_sp, 
+                                const lldb::ModuleSP &objc_module_sp);
+    
+    ~AppleObjCTrampolineHandler();
+            
+    lldb::ThreadPlanSP
+    GetStepThroughDispatchPlan (Thread &thread, 
+                                bool stop_others);
+    
+    FunctionCaller *
+    GetLookupImplementationFunctionCaller ();
+    
+    bool 
+    AddrIsMsgForward (lldb::addr_t addr) const
+    {
+        return (addr == m_msg_forward_addr || addr == m_msg_forward_stret_addr);
+    }
+
+    struct DispatchFunction {
+    public:
+        typedef enum 
+        {
+            eFixUpNone,
+            eFixUpFixed,
+            eFixUpToFix
+        } FixUpState;
+                
+        const char *name;
+        bool stret_return;
+        bool is_super;
+        bool is_super2;
+        FixUpState fixedup;
+    };
+
+    lldb::addr_t
+    SetupDispatchFunction (Thread &thread, ValueList &dispatch_values);
+
+private:
+    static const char *g_lookup_implementation_function_name;
+    static const char *g_lookup_implementation_function_code;
+    static const char *g_lookup_implementation_with_stret_function_code;
+    static const char *g_lookup_implementation_no_stret_function_code;
+
+    class AppleObjCVTables
+    {
+    public:
+        // These come from objc-gdb.h.
+        enum VTableFlags
+        {
+             eOBJC_TRAMPOLINE_MESSAGE = (1<<0),   // trampoline acts like objc_msgSend                                                           
+             eOBJC_TRAMPOLINE_STRET   = (1<<1),   // trampoline is struct-returning                                                              
+             eOBJC_TRAMPOLINE_VTABLE  = (1<<2)    // trampoline is vtable dispatcher                                                             
+        };
+            
+    private:
+        struct VTableDescriptor 
+        {
+            VTableDescriptor(uint32_t in_flags, lldb::addr_t in_code_start) :
+                flags(in_flags),
+                code_start(in_code_start) {}
+            
+            uint32_t flags;
+            lldb::addr_t code_start;
+        };
+
+        class VTableRegion 
+        {
+        public:
+            VTableRegion() :
+                    m_valid (false),
+                    m_owner (NULL),
+                    m_header_addr (LLDB_INVALID_ADDRESS),
+                    m_code_start_addr(0),
+                    m_code_end_addr (0),
+                    m_next_region (0)
+            {}
+            
+            VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr);
+            
+            void SetUpRegion();
+                        
+            lldb::addr_t GetNextRegionAddr ()
+            {
+                return m_next_region;
+            }
+            
+            lldb::addr_t
+            GetCodeStart ()
+            {
+                return m_code_start_addr;
+            }
+            
+            lldb::addr_t
+            GetCodeEnd ()
+            {
+                return m_code_end_addr;
+            }
+            
+            uint32_t
+            GetFlagsForVTableAtAddress (lldb::addr_t address)
+            {
+                return 0;
+            }
+            
+            bool
+            IsValid ()
+            {
+                return m_valid;
+            }
+            
+            bool 
+            AddressInRegion (lldb::addr_t addr, uint32_t &flags);
+            
+            void
+            Dump (Stream &s);
+            
+        public:
+            bool m_valid;
+            AppleObjCVTables *m_owner;
+            lldb::addr_t m_header_addr;
+            lldb::addr_t m_code_start_addr;
+            lldb::addr_t m_code_end_addr;
+            std::vector<VTableDescriptor> m_descriptors;
+            lldb::addr_t m_next_region;
+        };
+        
+    public:
+        AppleObjCVTables(const lldb::ProcessSP &process_sp, 
+                         const lldb::ModuleSP &objc_module_sp);
+        
+        ~AppleObjCVTables();
+                
+        bool
+        InitializeVTableSymbols ();
+                
+        static bool RefreshTrampolines (void *baton, 
+                                        StoppointCallbackContext *context, 
+                                        lldb::user_id_t break_id, 
+                                        lldb::user_id_t break_loc_id);
+        bool
+        ReadRegions ();
+        
+        bool
+        ReadRegions (lldb::addr_t region_addr);
+                
+        bool
+        IsAddressInVTables (lldb::addr_t addr, uint32_t &flags);
+                
+        lldb::ProcessSP
+        GetProcessSP ()
+        {   
+            return m_process_wp.lock();
+        }
+        
+    private:
+        lldb::ProcessWP m_process_wp;
+        typedef std::vector<VTableRegion> region_collection;
+        lldb::addr_t m_trampoline_header;
+        lldb::break_id_t m_trampolines_changed_bp_id;
+        region_collection m_regions;
+        lldb::ModuleSP m_objc_module_sp;
+    };
+    
+    static const DispatchFunction g_dispatch_functions[];
+    
+    typedef std::map<lldb::addr_t, int> MsgsendMap; // This table maps an dispatch fn address to the index in g_dispatch_functions
+    MsgsendMap m_msgSend_map;
+    lldb::ProcessWP m_process_wp;
+    lldb::ModuleSP m_objc_module_sp;
+    std::unique_ptr<UtilityFunction> m_impl_code;
+    Mutex m_impl_function_mutex;
+    lldb::addr_t m_impl_fn_addr;
+    lldb::addr_t m_impl_stret_fn_addr;
+    lldb::addr_t m_msg_forward_addr;
+    lldb::addr_t m_msg_forward_stret_addr;
+    std::unique_ptr<AppleObjCVTables> m_vtables_ap;
+};
+
+} // namespace lldb_private
+
+#endif // lldb_AppleObjCTrampolineHandler_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp
new file mode 100644
index 000000000000..9308c7a668d2
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp
@@ -0,0 +1,398 @@
+//===-- AppleObjCTypeEncodingParser.cpp -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AppleObjCTypeEncodingParser.h"
+
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/CompilerType.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/StringLexer.h"
+
+#include <vector>
+
+using namespace lldb_private;
+using namespace lldb_utility;
+
+AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser (ObjCLanguageRuntime& runtime) :
+    ObjCLanguageRuntime::EncodingToType(),
+    m_runtime(runtime)
+{
+    if (!m_scratch_ast_ctx_ap)
+        m_scratch_ast_ctx_ap.reset(new ClangASTContext(runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple().str().c_str()));
+}
+
+std::string
+AppleObjCTypeEncodingParser::ReadStructName(lldb_utility::StringLexer& type)
+{
+    StreamString buffer;
+    while (type.HasAtLeast(1) && type.Peek() != '=')
+        buffer.Printf("%c",type.Next());
+    return buffer.GetString();
+}
+
+std::string
+AppleObjCTypeEncodingParser::ReadQuotedString(lldb_utility::StringLexer& type)
+{
+    StreamString buffer;
+    while (type.HasAtLeast(1) && type.Peek() != '"')
+        buffer.Printf("%c",type.Next());
+    StringLexer::Character next = type.Next();
+    UNUSED_IF_ASSERT_DISABLED(next);
+    assert (next == '"');
+    return buffer.GetString();
+}
+
+uint32_t
+AppleObjCTypeEncodingParser::ReadNumber (lldb_utility::StringLexer& type)
+{
+    uint32_t total = 0;
+    while (type.HasAtLeast(1) && isdigit(type.Peek()))
+           total = 10*total + (type.Next() - '0');
+    return total;
+}
+
+// as an extension to the published grammar recent runtimes emit structs like this:
+// "{CGRect=\"origin\"{CGPoint=\"x\"d\"y\"d}\"size\"{CGSize=\"width\"d\"height\"d}}"
+
+AppleObjCTypeEncodingParser::StructElement::StructElement() :
+name(""),
+type(clang::QualType()),
+bitfield(0)
+{}
+
+AppleObjCTypeEncodingParser::StructElement
+AppleObjCTypeEncodingParser::ReadStructElement (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
+{
+    StructElement retval;
+    if (type.NextIf('"'))
+        retval.name = ReadQuotedString(type);
+    if (!type.NextIf('"'))
+        return retval;
+    uint32_t bitfield_size = 0;
+    retval.type = BuildType(ast_ctx, type, for_expression, &bitfield_size);
+    retval.bitfield = bitfield_size;
+    return retval;
+}
+
+clang::QualType
+AppleObjCTypeEncodingParser::BuildStruct (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
+{
+    return BuildAggregate(ast_ctx, type, for_expression, '{', '}', clang::TTK_Struct);
+}
+
+clang::QualType
+AppleObjCTypeEncodingParser::BuildUnion (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
+{
+    return BuildAggregate(ast_ctx, type, for_expression, '(', ')', clang::TTK_Union);
+}
+
+clang::QualType
+AppleObjCTypeEncodingParser::BuildAggregate (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression, char opener, char closer, uint32_t kind)
+{
+    if (!type.NextIf(opener))
+        return clang::QualType();
+    std::string name(ReadStructName(type));
+    
+    // We do not handle templated classes/structs at the moment.
+    // If the name has a < in it, we are going to abandon this.
+    // We're still obliged to parse it, so we just set a flag that
+    // means "Don't actually build anything."
+    
+    const bool is_templated = name.find('<') != std::string::npos;
+    
+    if (!type.NextIf('='))
+        return clang::QualType();
+    bool in_union = true;
+    std::vector<StructElement> elements;
+    while (in_union && type.HasAtLeast(1))
+    {
+        if (type.NextIf(closer))
+        {
+            in_union = false;
+            break;
+        }
+        else
+        {
+            auto element = ReadStructElement(ast_ctx, type, for_expression);
+            if (element.type.isNull())
+                break;
+            else
+                elements.push_back(element);
+        }
+    }
+    if (in_union)
+        return clang::QualType();
+    
+    if (is_templated)
+        return clang::QualType(); // This is where we bail out.  Sorry!
+    
+    ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx);
+    if (!lldb_ctx)
+        return clang::QualType();
+    CompilerType union_type(lldb_ctx->CreateRecordType(nullptr, lldb::eAccessPublic, name.c_str(), kind, lldb::eLanguageTypeC));
+    if (union_type)
+    {
+        ClangASTContext::StartTagDeclarationDefinition(union_type);
+        
+        unsigned int count = 0;
+        for (auto element: elements)
+        {
+            if (element.name.empty())
+            {
+                StreamString elem_name;
+                elem_name.Printf("__unnamed_%u",count);
+                element.name = std::string(elem_name.GetData());
+            }
+            ClangASTContext::AddFieldToRecordType(union_type, element.name.c_str(), CompilerType(&ast_ctx, element.type), lldb::eAccessPublic, element.bitfield);
+            ++count;
+        }
+        ClangASTContext::CompleteTagDeclarationDefinition(union_type);
+    }
+    return ClangASTContext::GetQualType(union_type);
+}
+
+clang::QualType
+AppleObjCTypeEncodingParser::BuildArray (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
+{
+    if (!type.NextIf('['))
+        return clang::QualType();
+    uint32_t size = ReadNumber(type);
+    clang::QualType element_type(BuildType(ast_ctx, type, for_expression));
+    if (!type.NextIf(']'))
+        return clang::QualType();
+    ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx);
+    if (!lldb_ctx)
+        return clang::QualType();
+    CompilerType array_type(lldb_ctx->CreateArrayType(CompilerType(&ast_ctx, element_type), size, false));
+    return ClangASTContext::GetQualType(array_type);
+}
+
+// the runtime can emit these in the form of @"SomeType", giving more specifics
+// this would be interesting for expression parser interop, but since we actually try
+// to avoid exposing the ivar info to the expression evaluator, consume but ignore the type info
+// and always return an 'id'; if anything, dynamic typing will resolve things for us anyway
+clang::QualType
+AppleObjCTypeEncodingParser::BuildObjCObjectPointerType (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
+{
+    if (!type.NextIf('@'))
+        return clang::QualType();
+    
+    std::string name;
+    
+    if (type.NextIf('"'))
+    {
+        // We have to be careful here.  We're used to seeing
+        //   @"NSString"
+        // but in records it is possible that the string following an @ is the name of the next field and @ means "id".
+        // This is the case if anything unquoted except for "}", the end of the type, or another name follows the quoted string.
+        //
+        // E.g.
+        // - @"NSString"@ means "id, followed by a field named NSString of type id"
+        // - @"NSString"} means "a pointer to NSString and the end of the struct"
+        // - @"NSString""nextField" means "a pointer to NSString and a field named nextField"
+        // - @"NSString" followed by the end of the string means "a pointer to NSString"
+        //
+        // As a result, the rule is: If we see @ followed by a quoted string, we peek.
+        // - If we see }, ), ], the end of the string, or a quote ("), the quoted string is a class name.
+        // - If we see anything else, the quoted string is a field name and we push it back onto type.
+
+        name = ReadQuotedString(type);
+        
+        if (type.HasAtLeast(1))
+        {
+            switch (type.Peek())
+            {
+            default:
+                // roll back
+                type.PutBack(name.length() + 2); // undo our consumption of the string and of the quotes
+                name.clear();
+                break;
+            case '}':
+            case ')':
+            case ']':
+            case '"':
+                // the quoted string is a class name – see the rule
+                break;
+            }
+        }
+        else
+        {
+            // the quoted string is a class name – see the rule
+        }
+    }
+    
+    if (for_expression && !name.empty())
+    {
+        size_t less_than_pos = name.find('<');
+        
+        if (less_than_pos != std::string::npos)
+        {
+            if (less_than_pos == 0)
+                return ast_ctx.getObjCIdType();
+            else
+                name.erase(less_than_pos);
+        }
+        
+        DeclVendor *decl_vendor = m_runtime.GetDeclVendor();
+        
+        assert (decl_vendor); // how are we parsing type encodings for expressions if a type vendor isn't in play?
+        
+        const bool append = false;
+        const uint32_t max_matches = 1;
+        std::vector<clang::NamedDecl *> decls;
+        
+        uint32_t num_types = decl_vendor->FindDecls(ConstString(name),
+                                                    append,
+                                                    max_matches,
+                                                    decls);
+
+        // The user can forward-declare something that has no definition.  The runtime doesn't prohibit this at all.
+        // This is a rare and very weird case.  We keep this assert in debug builds so we catch other weird cases.
+#ifdef LLDB_CONFIGURATION_DEBUG
+        assert(num_types);
+#else
+        if (!num_types)
+            return ast_ctx.getObjCIdType();
+#endif
+        
+        return ClangASTContext::GetQualType(ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
+    }
+    else
+    {
+        // We're going to resolve this dynamically anyway, so just smile and wave.
+        return ast_ctx.getObjCIdType();
+    }
+}
+
+clang::QualType
+AppleObjCTypeEncodingParser::BuildType (clang::ASTContext &ast_ctx, StringLexer& type, bool for_expression, uint32_t *bitfield_bit_size)
+{
+    if (!type.HasAtLeast(1))
+        return clang::QualType();
+    
+    switch (type.Peek())
+    {
+    default:
+        break;
+    case '{':
+        return BuildStruct(ast_ctx, type, for_expression);
+    case '[':
+        return BuildArray(ast_ctx, type, for_expression);
+    case '(':
+        return BuildUnion(ast_ctx, type, for_expression);
+    case '@':
+        return BuildObjCObjectPointerType(ast_ctx, type, for_expression);
+    }
+    
+    switch (type.Next())
+    {
+    default:
+        type.PutBack(1);
+        return clang::QualType();
+    case 'c':
+        return ast_ctx.CharTy;
+    case 'i':
+        return ast_ctx.IntTy;
+    case 's':
+        return ast_ctx.ShortTy;
+    case 'l':
+        return ast_ctx.getIntTypeForBitwidth(32, true);
+        // this used to be done like this:
+        //   ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx);
+        //   if (!lldb_ctx)
+        //      return clang::QualType();
+        //   return lldb_ctx->GetIntTypeFromBitSize(32, true).GetQualType();
+        // which uses one of the constants if one is available, but we don't think all this work is necessary.
+    case 'q':
+        return ast_ctx.LongLongTy;
+    case 'C':
+        return ast_ctx.UnsignedCharTy;
+    case 'I':
+        return ast_ctx.UnsignedIntTy;
+    case 'S':
+        return ast_ctx.UnsignedShortTy;
+    case 'L':
+        return ast_ctx.getIntTypeForBitwidth(32, false);
+        // see note for 'l'
+    case 'Q':
+        return ast_ctx.UnsignedLongLongTy;
+    case 'f':
+        return ast_ctx.FloatTy;
+    case 'd':
+        return ast_ctx.DoubleTy;
+    case 'B':
+        return ast_ctx.BoolTy;
+    case 'v':
+        return ast_ctx.VoidTy;
+    case '*':
+        return ast_ctx.getPointerType(ast_ctx.CharTy);
+    case '#':
+        return ast_ctx.getObjCClassType();
+    case ':':
+        return ast_ctx.getObjCSelType();
+    case 'b':
+        {
+            uint32_t size = ReadNumber(type);
+            if (bitfield_bit_size)
+            {
+                *bitfield_bit_size = size;
+                return ast_ctx.UnsignedIntTy; // FIXME: the spec is fairly vague here.
+            }
+            else
+                return clang::QualType();
+        }
+    case 'r':
+        {
+            clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
+            if (target_type.isNull())
+                return clang::QualType();
+            else if (target_type == ast_ctx.UnknownAnyTy)
+                return ast_ctx.UnknownAnyTy;
+            else
+                return ast_ctx.getConstType(target_type);
+        }
+    case '^':
+        {
+            if (!for_expression && type.NextIf('?'))
+            {
+                // if we are not supporting the concept of unknownAny, but what is being created here is an unknownAny*, then
+                // we can just get away with a void*
+                // this is theoretically wrong (in the same sense as 'theoretically nothing exists') but is way better than outright failure
+                // in many practical cases
+                return ast_ctx.VoidPtrTy;
+            }
+            else
+            {
+                clang::QualType target_type = BuildType(ast_ctx, type, for_expression);
+                if (target_type.isNull())
+                    return clang::QualType();
+                else if (target_type == ast_ctx.UnknownAnyTy)
+                    return ast_ctx.UnknownAnyTy;
+                else
+                    return ast_ctx.getPointerType(target_type);
+            }
+        }
+    case '?':
+        return for_expression ? ast_ctx.UnknownAnyTy : clang::QualType();
+    }
+}
+
+CompilerType
+AppleObjCTypeEncodingParser::RealizeType (clang::ASTContext &ast_ctx, const char* name, bool for_expression)
+{
+    if (name && name[0])
+    {
+        StringLexer lexer(name);
+        clang::QualType qual_type = BuildType(ast_ctx, lexer, for_expression);
+        return CompilerType(&ast_ctx, qual_type);
+    }
+    return CompilerType();
+}
+
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h
new file mode 100644
index 000000000000..87c49cbc05b9
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h
@@ -0,0 +1,81 @@
+//===-- AppleObjCTypeEncodingParser.h ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AppleObjCTypeEncodingParser_h_
+#define liblldb_AppleObjCTypeEncodingParser_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "clang/AST/ASTContext.h"
+
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+
+namespace lldb_utility {
+    class StringLexer;
+}
+
+namespace lldb_private {
+
+    class AppleObjCTypeEncodingParser : public ObjCLanguageRuntime::EncodingToType
+    {
+    public:
+        AppleObjCTypeEncodingParser (ObjCLanguageRuntime& runtime);
+        ~AppleObjCTypeEncodingParser() override = default;
+        
+        CompilerType RealizeType(clang::ASTContext &ast_ctx, const char* name, bool for_expression) override;
+
+    private:
+        struct StructElement {
+            std::string name;
+            clang::QualType type;
+            uint32_t bitfield;
+            
+            StructElement ();
+            ~StructElement () = default;
+        };
+        
+        clang::QualType
+        BuildType (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression, uint32_t *bitfield_bit_size = nullptr);
+
+        clang::QualType
+        BuildStruct (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression);
+        
+        clang::QualType
+        BuildAggregate (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression, char opener, char closer, uint32_t kind);
+        
+        clang::QualType
+        BuildUnion (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression);
+        
+        clang::QualType
+        BuildArray (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression);
+        
+        std::string
+        ReadStructName(lldb_utility::StringLexer& type);
+        
+        StructElement
+        ReadStructElement (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression);
+        
+        clang::QualType
+        BuildObjCObjectPointerType (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression);
+        
+        uint32_t
+        ReadNumber (lldb_utility::StringLexer& type);
+        
+        std::string
+        ReadQuotedString(lldb_utility::StringLexer& type);
+        
+        ObjCLanguageRuntime& m_runtime;
+    };
+    
+} // namespace lldb_private
+
+#endif // liblldb_AppleObjCTypeEncodingParser_h_
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
new file mode 100644
index 000000000000..285786a09dbb
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp
@@ -0,0 +1,244 @@
+//===-- AppleThreadPlanStepThroughObjCTrampoline.cpp --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "AppleThreadPlanStepThroughObjCTrampoline.h"
+#include "AppleObjCTrampolineHandler.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/ObjCLanguageRuntime.h"
+#include "lldb/Target/ThreadPlanRunToAddress.h"
+#include "lldb/Target/ThreadPlanStepOut.h"
+#include "lldb/Core/Log.h"
+
+
+using namespace lldb;
+using namespace lldb_private;
+
+//----------------------------------------------------------------------
+// ThreadPlanStepThroughObjCTrampoline constructor
+//----------------------------------------------------------------------
+AppleThreadPlanStepThroughObjCTrampoline::AppleThreadPlanStepThroughObjCTrampoline
+(
+    Thread &thread, 
+    AppleObjCTrampolineHandler *trampoline_handler,
+    ValueList &input_values,
+    lldb::addr_t isa_addr,
+    lldb::addr_t sel_addr,
+    bool stop_others
+) :
+    ThreadPlan (ThreadPlan::eKindGeneric, 
+                "MacOSX Step through ObjC Trampoline", 
+                thread, 
+                eVoteNoOpinion, 
+                eVoteNoOpinion),
+    m_trampoline_handler (trampoline_handler),
+    m_args_addr (LLDB_INVALID_ADDRESS),
+    m_input_values (input_values),
+    m_isa_addr(isa_addr),
+    m_sel_addr(sel_addr),
+    m_impl_function (NULL),
+    m_stop_others (stop_others)
+{
+    
+}
+
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+AppleThreadPlanStepThroughObjCTrampoline::~AppleThreadPlanStepThroughObjCTrampoline()
+{
+}
+
+void
+AppleThreadPlanStepThroughObjCTrampoline::DidPush ()
+{
+    // Setting up the memory space for the called function text might require allocations,
+    // i.e. a nested function call.  This needs to be done as a PreResumeAction.
+    m_thread.GetProcess()->AddPreResumeAction (PreResumeInitializeFunctionCaller, (void *) this);
+}
+
+bool
+AppleThreadPlanStepThroughObjCTrampoline::InitializeFunctionCaller ()
+{
+    if (!m_func_sp)
+    {
+        StreamString errors;
+        m_args_addr = m_trampoline_handler->SetupDispatchFunction(m_thread, m_input_values);
+        
+        if (m_args_addr == LLDB_INVALID_ADDRESS)
+        {
+            return false;
+        }
+        m_impl_function = m_trampoline_handler->GetLookupImplementationFunctionCaller();
+        ExecutionContext exc_ctx;
+        EvaluateExpressionOptions options;
+        options.SetUnwindOnError(true);
+        options.SetIgnoreBreakpoints(true);
+        options.SetStopOthers(m_stop_others);
+        m_thread.CalculateExecutionContext(exc_ctx);
+        m_func_sp = m_impl_function->GetThreadPlanToCallFunction (exc_ctx,
+                                                                  m_args_addr,
+                                                                  options,
+                                                                  errors);
+        m_func_sp->SetOkayToDiscard(true);
+        m_thread.QueueThreadPlan (m_func_sp, false);
+    }
+    return true;
+}
+
+bool
+AppleThreadPlanStepThroughObjCTrampoline::PreResumeInitializeFunctionCaller(void *void_myself)
+{
+    AppleThreadPlanStepThroughObjCTrampoline *myself = static_cast<AppleThreadPlanStepThroughObjCTrampoline *>(void_myself);
+    return myself->InitializeFunctionCaller();
+}
+
+void
+AppleThreadPlanStepThroughObjCTrampoline::GetDescription (Stream *s,
+                                                          lldb::DescriptionLevel level)
+{
+    if (level == lldb::eDescriptionLevelBrief)
+        s->Printf("Step through ObjC trampoline");
+    else
+    {
+        s->Printf ("Stepping to implementation of ObjC method - obj: 0x%llx, isa: 0x%" PRIx64 ", sel: 0x%" PRIx64,
+                   m_input_values.GetValueAtIndex(0)->GetScalar().ULongLong(), m_isa_addr, m_sel_addr);
+    }
+}
+                
+bool
+AppleThreadPlanStepThroughObjCTrampoline::ValidatePlan (Stream *error)
+{
+    return true;
+}
+
+bool
+AppleThreadPlanStepThroughObjCTrampoline::DoPlanExplainsStop (Event *event_ptr)
+{
+    // If we get asked to explain the stop it will be because something went
+    // wrong (like the implementation for selector function crashed...  We're going
+    // to figure out what to do about that, so we do explain the stop.
+    return true;
+}
+
+lldb::StateType
+AppleThreadPlanStepThroughObjCTrampoline::GetPlanRunState ()
+{
+    return eStateRunning;
+}
+
+bool
+AppleThreadPlanStepThroughObjCTrampoline::ShouldStop (Event *event_ptr)
+{
+    // First stage: we are still handling the "call a function to get the target of the dispatch"
+    if (m_func_sp)
+    {
+        if (!m_func_sp->IsPlanComplete())
+        {
+            return false;
+        }
+        else
+        {
+            if (!m_func_sp->PlanSucceeded())
+            {
+                SetPlanComplete(false);
+                return true;
+            }
+            m_func_sp.reset();
+        }
+    }
+    
+    // Second stage, if all went well with the function calling, then fetch the target address, and
+    // queue up a "run to that address" plan.
+    if (!m_run_to_sp) 
+    {
+        Value target_addr_value;
+        ExecutionContext exc_ctx;
+        m_thread.CalculateExecutionContext(exc_ctx);
+        m_impl_function->FetchFunctionResults (exc_ctx, m_args_addr, target_addr_value);
+        m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
+        lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
+        Address target_so_addr;
+        target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
+        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP));
+        if (target_addr == 0)
+        {
+            if (log)
+                log->Printf("Got target implementation of 0x0, stopping.");
+            SetPlanComplete();
+            return true;
+        }
+        if (m_trampoline_handler->AddrIsMsgForward(target_addr))
+        {
+            if (log)
+                log->Printf ("Implementation lookup returned msgForward function: 0x%" PRIx64 ", stopping.", target_addr);
+
+            SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(eSymbolContextEverything);
+            const bool abort_other_plans = false;
+            const bool first_insn = true;
+            const uint32_t frame_idx = 0;
+            m_run_to_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop (abort_other_plans,
+                                           &sc,
+                                           first_insn,
+                                           m_stop_others,
+                                           eVoteNoOpinion,
+                                           eVoteNoOpinion,
+                                           frame_idx);
+            m_run_to_sp->SetPrivate(true);
+            return false;
+        }
+        
+        if (log)
+            log->Printf("Running to ObjC method implementation: 0x%" PRIx64, target_addr);
+        
+        ObjCLanguageRuntime *objc_runtime = GetThread().GetProcess()->GetObjCLanguageRuntime();
+        assert (objc_runtime != NULL);
+        objc_runtime->AddToMethodCache (m_isa_addr, m_sel_addr, target_addr);
+        if (log)
+            log->Printf("Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64 "} = addr=0x%" PRIx64 " to cache.", m_isa_addr, m_sel_addr, target_addr);
+
+        // Extract the target address from the value:
+        
+        m_run_to_sp.reset(new ThreadPlanRunToAddress(m_thread, target_so_addr, m_stop_others));
+        m_thread.QueueThreadPlan(m_run_to_sp, false);
+        m_run_to_sp->SetPrivate(true);
+        return false;
+    }
+    else if (m_thread.IsThreadPlanDone(m_run_to_sp.get()))
+    {
+        // Third stage, work the run to target plan.
+        SetPlanComplete();
+        return true;
+    }
+    return false;
+}
+
+// The base class MischiefManaged does some cleanup - so you have to call it
+// in your MischiefManaged derived class.
+bool
+AppleThreadPlanStepThroughObjCTrampoline::MischiefManaged ()
+{
+    if (IsPlanComplete())
+        return true;
+    else
+        return false;
+}
+
+bool
+AppleThreadPlanStepThroughObjCTrampoline::WillStop()
+{
+    return true;
+}
diff --git a/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
new file mode 100644
index 000000000000..8db9963fa51a
--- /dev/null
+++ b/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h
@@ -0,0 +1,95 @@
+//===-- AppleThreadPlanStepThroughObjCTrampoline.h --------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_AppleThreadPlanStepThroughObjCTrampoline_h_
+#define lldb_AppleThreadPlanStepThroughObjCTrampoline_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-types.h"
+#include "lldb/lldb-enumerations.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Target/ThreadPlan.h"
+#include "AppleObjCTrampolineHandler.h"
+
+namespace lldb_private 
+{
+
+class AppleThreadPlanStepThroughObjCTrampoline : public ThreadPlan
+{
+public:
+    AppleThreadPlanStepThroughObjCTrampoline(Thread &thread, 
+                                             AppleObjCTrampolineHandler *trampoline_handler, 
+                                             ValueList &values,
+                                             lldb::addr_t isa_addr,
+                                             lldb::addr_t sel_addr,
+                                             bool stop_others);
+
+    ~AppleThreadPlanStepThroughObjCTrampoline() override;
+
+    static bool
+    PreResumeInitializeFunctionCaller(void *myself);
+
+    void
+    GetDescription(Stream *s,
+                   lldb::DescriptionLevel level) override;
+                    
+    bool
+    ValidatePlan(Stream *error) override;
+
+    lldb::StateType
+    GetPlanRunState() override;
+
+    bool
+    ShouldStop(Event *event_ptr) override;
+    
+    bool
+    StopOthers() override
+    {
+        return m_stop_others;
+    }
+
+    // The base class MischiefManaged does some cleanup - so you have to call it
+    // in your MischiefManaged derived class.
+    bool
+    MischiefManaged() override;
+    
+    void
+    DidPush() override;
+    
+    bool
+    WillStop() override;
+
+protected:
+    bool
+    DoPlanExplainsStop(Event *event_ptr) override;
+	
+private:
+    bool
+    InitializeFunctionCaller ();
+
+    AppleObjCTrampolineHandler *m_trampoline_handler; // FIXME - ensure this doesn't go away on us?  SP maybe?
+    lldb::addr_t m_args_addr;     // Stores the address for our step through function result structure.
+    //lldb::addr_t m_object_addr;  // This is only for Description.
+    ValueList    m_input_values;
+    lldb::addr_t m_isa_addr;     // isa_addr and sel_addr are the keys we will use to cache the implementation.
+    lldb::addr_t m_sel_addr;
+    lldb::ThreadPlanSP m_func_sp;       // This is the function call plan.  We fill it at start, then set it
+                                        // to NULL when this plan is done.  That way we know to go to:
+    lldb::ThreadPlanSP m_run_to_sp;     // The plan that runs to the target.
+    FunctionCaller *m_impl_function;  // This is a pointer to a impl function that
+                                     // is owned by the client that pushes this plan.
+    bool m_stop_others;
+};
+
+} // namespace lldb_private
+
+#endif // lldb_AppleThreadPlanStepThroughObjCTrampoline_h_