source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp - lldb - Git at Google

 //===-- 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"

 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);

     const size_t buffer_size = 1024;
     size_t count;

     DataBufferHeap string_buf(buffer_size, 0);

     count = process->ReadCStringFromMemory(m_name_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
     m_name.assign((char*)string_buf.GetBytes(), count);

     count = process->ReadCStringFromMemory(m_types_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
     m_types.assign((char*)string_buf.GetBytes(), count);

     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);

     const size_t buffer_size = 1024;
     size_t count;

     DataBufferHeap string_buf(buffer_size, 0);

     count = process->ReadCStringFromMemory(m_name_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
     m_name.assign((char*)string_buf.GetBytes(), count);

     count = process->ReadCStringFromMemory(m_type_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
     m_type.assign((char*)string_buf.GetBytes(), count);

     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);
     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](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;
                  ClangASTType ivar_type = encoding_to_type_sp->RealizeType(type, for_expression);
                  if (ivar_type)
                  {
                      Scalar offset_scalar;
                      Error error;
                      size_t read = process->ReadScalarIntegerFromMemory(offset_ptr, 4, true, offset_scalar, error);
                      if (error.Success() && 4 == read)
                          m_ivars.push_back({ ConstString(name), ivar_type, size, offset_scalar.SInt() });
                  }
                  return stop_loop;
              });
 }

 void
 ClassDescriptorV2::GetIVarInformation ()
 {
     m_ivars_storage.fill(m_runtime, *this);
 }
	//===-- 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"

	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);

	const size_t buffer_size = 1024;
	size_t count;

	DataBufferHeap string_buf(buffer_size, 0);

	count = process->ReadCStringFromMemory(m_name_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
	m_name.assign((char*)string_buf.GetBytes(), count);

	count = process->ReadCStringFromMemory(m_types_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
	m_types.assign((char*)string_buf.GetBytes(), count);

	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);

	const size_t buffer_size = 1024;
	size_t count;

	DataBufferHeap string_buf(buffer_size, 0);

	count = process->ReadCStringFromMemory(m_name_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
	m_name.assign((char*)string_buf.GetBytes(), count);

	count = process->ReadCStringFromMemory(m_type_ptr, (char*)string_buf.GetBytes(), buffer_size, error);
	m_type.assign((char*)string_buf.GetBytes(), count);

	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);
	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](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;
	ClangASTType ivar_type = encoding_to_type_sp->RealizeType(type, for_expression);
	if (ivar_type)
	{
	Scalar offset_scalar;
	Error error;
	size_t read = process->ReadScalarIntegerFromMemory(offset_ptr, 4, true, offset_scalar, error);
	if (error.Success() && 4 == read)
	m_ivars.push_back({ ConstString(name), ivar_type, size, offset_scalar.SInt() });
	}
	return stop_loop;
	});
	}

	void
	ClassDescriptorV2::GetIVarInformation ()
	{
	m_ivars_storage.fill(m_runtime, *this);
	}