Index: projects/clang350-import/contrib/llvm/tools/lldb/source/DataFormatters/NSArray.cpp
===================================================================
--- projects/clang350-import/contrib/llvm/tools/lldb/source/DataFormatters/NSArray.cpp	(revision 275134)
+++ projects/clang350-import/contrib/llvm/tools/lldb/source/DataFormatters/NSArray.cpp	(revision 275135)
@@ -1,708 +1,707 @@
 //===-- NSArray.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-python.h"
 
 #include "lldb/DataFormatters/CXXFormatterFunctions.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
-#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 #include "lldb/Target/Target.h"
 
 #include "clang/AST/ASTContext.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace  lldb_private {
     namespace formatters {
         class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
             virtual size_t
             CalculateNumChildren ();
             
             virtual lldb::ValueObjectSP
             GetChildAtIndex (size_t idx);
             
             virtual bool
             Update() = 0;
             
             virtual bool
             MightHaveChildren ();
             
             virtual size_t
             GetIndexOfChildWithName (const ConstString &name);
             
             virtual
             ~NSArrayMSyntheticFrontEnd () {}
             
         protected:
             virtual lldb::addr_t
             GetDataAddress () = 0;
             
             virtual uint64_t
             GetUsedCount () = 0;
             
             virtual uint64_t
             GetOffset () = 0;
             
             virtual uint64_t
             GetSize () = 0;
             
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             ClangASTType m_id_type;
             std::vector<lldb::ValueObjectSP> m_children;
         };
         
         class NSArrayMSyntheticFrontEnd_109 : public NSArrayMSyntheticFrontEnd
         {
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used;
                 uint32_t _priv1 : 2 ;
                 uint32_t _size : 30;
                 uint32_t _priv2 : 2;
                 uint32_t _offset : 30;
                 uint32_t _priv3;
                 uint32_t _data;
             };
             struct DataDescriptor_64
             {
                 uint64_t _used;
                 uint64_t _priv1 : 2 ;
                 uint64_t _size : 62;
                 uint64_t _priv2 : 2;
                 uint64_t _offset : 62;
                 uint32_t _priv3;
                 uint64_t _data;
             };
         public:
             NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp);
             
             virtual bool
             Update();
             
             virtual
             ~NSArrayMSyntheticFrontEnd_109 ();
             
         protected:
             virtual lldb::addr_t
             GetDataAddress ();
             
             virtual uint64_t
             GetUsedCount ();
             
             virtual uint64_t
             GetOffset ();
             
             virtual uint64_t
             GetSize ();
             
         private:
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
         };
         
         class NSArrayMSyntheticFrontEnd_1010 : public NSArrayMSyntheticFrontEnd
         {
         private:
             struct DataDescriptor_32
             {
                 uint32_t _used;
                 uint32_t _offset;
                 uint32_t _size : 28;
                 uint64_t _priv1 : 4;
                 uint32_t _priv2;
                 uint32_t _data;
             };
             struct DataDescriptor_64
             {
                 uint64_t _used;
                 uint64_t _offset;
                 uint64_t _size : 60;
                 uint64_t _priv1 : 4;
                 uint32_t _priv2;
                 uint64_t _data;
             };
         public:
             NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp);
             
             virtual bool
             Update();
             
             virtual
             ~NSArrayMSyntheticFrontEnd_1010 ();
             
         protected:
             virtual lldb::addr_t
             GetDataAddress ();
             
             virtual uint64_t
             GetUsedCount ();
             
             virtual uint64_t
             GetOffset ();
             
             virtual uint64_t
             GetSize ();
             
         private:
             DataDescriptor_32 *m_data_32;
             DataDescriptor_64 *m_data_64;
         };
         
         class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
             virtual size_t
             CalculateNumChildren ();
             
             virtual lldb::ValueObjectSP
             GetChildAtIndex (size_t idx);
             
             virtual bool
             Update();
             
             virtual bool
             MightHaveChildren ();
             
             virtual size_t
             GetIndexOfChildWithName (const ConstString &name);
             
             virtual
             ~NSArrayISyntheticFrontEnd ();
         private:
             ExecutionContextRef m_exe_ctx_ref;
             uint8_t m_ptr_size;
             uint64_t m_items;
             lldb::addr_t m_data_ptr;
             ClangASTType m_id_type;
             std::vector<lldb::ValueObjectSP> m_children;
         };
         
         class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
         {
         public:
             NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
             
             virtual size_t
             CalculateNumChildren ();
             
             virtual lldb::ValueObjectSP
             GetChildAtIndex (size_t idx);
             
             virtual bool
             Update();
             
             virtual bool
             MightHaveChildren ();
             
             virtual size_t
             GetIndexOfChildWithName (const ConstString &name);
             
             virtual
             ~NSArrayCodeRunningSyntheticFrontEnd ();
         };
     }
 }
 
 bool
 lldb_private::formatters::NSArraySummaryProvider (ValueObject& valobj, Stream& stream)
 {
     ProcessSP process_sp = valobj.GetProcessSP();
     if (!process_sp)
         return false;
     
     ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
     
     if (!runtime)
         return false;
     
     ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
     
     if (!descriptor.get() || !descriptor->IsValid())
         return false;
     
     uint32_t ptr_size = process_sp->GetAddressByteSize();
     
     lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
     
     if (!valobj_addr)
         return false;
     
     uint64_t value = 0;
     
     const char* class_name = descriptor->GetClassName().GetCString();
     
     if (!class_name || !*class_name)
         return false;
     
     if (!strcmp(class_name,"__NSArrayI"))
     {
         Error error;
         value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
         if (error.Fail())
             return false;
     }
     else if (!strcmp(class_name,"__NSArrayM"))
     {
         Error error;
         value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
         if (error.Fail())
             return false;
     }
     else if (!strcmp(class_name,"__NSCFArray"))
     {
         Error error;
         value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + 2 * ptr_size, ptr_size, 0, error);
         if (error.Fail())
             return false;
     }
     else
     {
         if (!ExtractValueFromObjCExpression(valobj, "int", "count", value))
             return false;
     }
     
     stream.Printf("@\"%" PRIu64 " object%s\"",
                   value,
                   value == 1 ? "" : "s");
     return true;
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEnd::NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp),
     m_exe_ctx_ref(),
     m_ptr_size(8),
 m_id_type(),
 m_children()
 {
     if (valobj_sp)
     {
         clang::ASTContext *ast = valobj_sp->GetExecutionContextRef().GetTargetSP()->GetScratchClangASTContext()->getASTContext();
         if (ast)
             m_id_type = ClangASTType(ast, ast->ObjCBuiltinIdTy);
         if (valobj_sp->GetProcessSP())
             m_ptr_size = valobj_sp->GetProcessSP()->GetAddressByteSize();
     }
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::NSArrayMSyntheticFrontEnd_109 (lldb::ValueObjectSP valobj_sp) :
 NSArrayMSyntheticFrontEnd(valobj_sp),
 m_data_32(NULL),
 m_data_64(NULL)
 {
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::NSArrayMSyntheticFrontEnd_1010 (lldb::ValueObjectSP valobj_sp) :
 NSArrayMSyntheticFrontEnd(valobj_sp),
 m_data_32(NULL),
 m_data_64(NULL)
 {
 }
 
 size_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd::CalculateNumChildren ()
 {
     return GetUsedCount();
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetChildAtIndex (size_t idx)
 {
     if (idx >= CalculateNumChildren())
         return lldb::ValueObjectSP();
     lldb::addr_t object_at_idx = GetDataAddress();
     size_t pyhs_idx = idx;
     pyhs_idx += GetOffset();
     if (GetSize() <= pyhs_idx)
         pyhs_idx -= GetSize();
     object_at_idx += (pyhs_idx * m_ptr_size);
     StreamString idx_name;
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     lldb::ValueObjectSP retval_sp = ValueObject::CreateValueObjectFromAddress(idx_name.GetData(),
                                                                               object_at_idx,
                                                                               m_exe_ctx_ref,
                                                                               m_id_type);
     m_children.push_back(retval_sp);
     return retval_sp;
 }
 
 bool
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::Update()
 {
     m_children.clear();
     ValueObjectSP valobj_sp = m_backend.GetSP();
     m_ptr_size = 0;
     delete m_data_32;
     m_data_32 = NULL;
     delete m_data_64;
     m_data_64 = NULL;
     if (!valobj_sp)
         return false;
     m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
     Error error;
     error.Clear();
     lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
     if (!process_sp)
         return false;
     m_ptr_size = process_sp->GetAddressByteSize();
     uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
     if (m_ptr_size == 4)
     {
         m_data_32 = new DataDescriptor_32();
         process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
     }
     else
     {
         m_data_64 = new DataDescriptor_64();
         process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
     }
     if (error.Fail())
         return false;
     return false;
 }
 
 bool
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::Update()
 {
     m_children.clear();
     ValueObjectSP valobj_sp = m_backend.GetSP();
     m_ptr_size = 0;
     delete m_data_32;
     m_data_32 = NULL;
     delete m_data_64;
     m_data_64 = NULL;
     if (!valobj_sp)
         return false;
     m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
     Error error;
     error.Clear();
     lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
     if (!process_sp)
         return false;
     m_ptr_size = process_sp->GetAddressByteSize();
     uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
     if (m_ptr_size == 4)
     {
         m_data_32 = new DataDescriptor_32();
         process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
     }
     else
     {
         m_data_64 = new DataDescriptor_64();
         process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
     }
     if (error.Fail())
         return false;
     return false;
 }
 
 bool
 lldb_private::formatters::NSArrayMSyntheticFrontEnd::MightHaveChildren ()
 {
     return true;
 }
 
 size_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     const char* item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
         return UINT32_MAX;
     return idx;
 }
 
 lldb::addr_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetDataAddress ()
 {
     if (!m_data_32 && !m_data_64)
         return LLDB_INVALID_ADDRESS;
     return m_data_32 ? m_data_32->_data :
     m_data_64->_data;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetUsedCount ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_used :
     m_data_64->_used;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetOffset ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_offset :
     m_data_64->_offset;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::GetSize ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_size :
     m_data_64->_size;
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_109::~NSArrayMSyntheticFrontEnd_109 ()
 {
     delete m_data_32;
     m_data_32 = NULL;
     delete m_data_64;
     m_data_64 = NULL;
 }
 
 lldb::addr_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetDataAddress ()
 {
     if (!m_data_32 && !m_data_64)
         return LLDB_INVALID_ADDRESS;
     return m_data_32 ? m_data_32->_data :
     m_data_64->_data;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetUsedCount ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_used :
     m_data_64->_used;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetOffset ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_offset :
     m_data_64->_offset;
 }
 
 uint64_t
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::GetSize ()
 {
     if (!m_data_32 && !m_data_64)
         return 0;
     return m_data_32 ? m_data_32->_size :
     m_data_64->_size;
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEnd_1010::~NSArrayMSyntheticFrontEnd_1010 ()
 {
     delete m_data_32;
     m_data_32 = NULL;
     delete m_data_64;
     m_data_64 = NULL;
 }
 
 lldb_private::formatters::NSArrayISyntheticFrontEnd::NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
     SyntheticChildrenFrontEnd (*valobj_sp.get()),
     m_exe_ctx_ref (),
     m_ptr_size (8),
     m_items (0),
     m_data_ptr (0)
 {
     if (valobj_sp)
     {
         clang::ASTContext *ast = valobj_sp->GetClangType().GetASTContext();
         if (ast)
             m_id_type = ClangASTType(ast, ast->ObjCBuiltinIdTy);
     }
 }
 
 lldb_private::formatters::NSArrayISyntheticFrontEnd::~NSArrayISyntheticFrontEnd ()
 {
 }
 
 size_t
 lldb_private::formatters::NSArrayISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     const char* item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
         return UINT32_MAX;
     return idx;
 }
 
 size_t
 lldb_private::formatters::NSArrayISyntheticFrontEnd::CalculateNumChildren ()
 {
     return m_items;
 }
 
 bool
 lldb_private::formatters::NSArrayISyntheticFrontEnd::Update()
 {
     m_ptr_size = 0;
     m_items = 0;
     m_data_ptr = 0;
     m_children.clear();
     ValueObjectSP valobj_sp = m_backend.GetSP();
     if (!valobj_sp)
         return false;
     m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
     Error error;
     error.Clear();
     lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
     if (!process_sp)
         return false;
     m_ptr_size = process_sp->GetAddressByteSize();
     uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
     m_items = process_sp->ReadPointerFromMemory(data_location, error);
     if (error.Fail())
         return false;
     m_data_ptr = data_location+m_ptr_size;
     return false;
 }
 
 bool
 lldb_private::formatters::NSArrayISyntheticFrontEnd::MightHaveChildren ()
 {
     return true;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::NSArrayISyntheticFrontEnd::GetChildAtIndex (size_t idx)
 {
     if (idx >= CalculateNumChildren())
         return lldb::ValueObjectSP();
     lldb::addr_t object_at_idx = m_data_ptr;
     object_at_idx += (idx * m_ptr_size);
     ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
     if (!process_sp)
         return lldb::ValueObjectSP();
     Error error;
     if (error.Fail())
         return lldb::ValueObjectSP();
     StreamString idx_name;
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     lldb::ValueObjectSP retval_sp = ValueObject::CreateValueObjectFromAddress(idx_name.GetData(), object_at_idx, m_exe_ctx_ref, m_id_type);
     m_children.push_back(retval_sp);
     return retval_sp;
 }
 
 SyntheticChildrenFrontEnd* lldb_private::formatters::NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
 {
     return nullptr; // Avoid need for AppleObjCRuntime on FreeBSD
 #if 0
     if (!valobj_sp)
         return nullptr;
     
     lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
     if (!process_sp)
         return NULL;
     AppleObjCRuntime *runtime = (AppleObjCRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
     if (!runtime)
         return NULL;
     
     ClangASTType valobj_type(valobj_sp->GetClangType());
     Flags flags(valobj_type.GetTypeInfo());
     
     if (flags.IsClear(ClangASTType::eTypeIsPointer))
     {
         Error error;
         valobj_sp = valobj_sp->AddressOf(error);
         if (error.Fail() || !valobj_sp)
             return NULL;
     }
     
     ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
     
     if (!descriptor.get() || !descriptor->IsValid())
         return NULL;
     
     const char* class_name = descriptor->GetClassName().GetCString();
     
     if (!class_name || !*class_name)
         return NULL;
     
     if (!strcmp(class_name,"__NSArrayI"))
     {
         return (new NSArrayISyntheticFrontEnd(valobj_sp));
     }
     else if (!strcmp(class_name,"__NSArrayM"))
     {
         if (runtime->GetFoundationVersion() >= 1100)
             return (new NSArrayMSyntheticFrontEnd_1010(valobj_sp));
         else
             return (new NSArrayMSyntheticFrontEnd_109(valobj_sp));
     }
     else
     {
         return (new NSArrayCodeRunningSyntheticFrontEnd(valobj_sp));
     }
 #endif
 }
 
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
 SyntheticChildrenFrontEnd(*valobj_sp.get())
 {}
 
 size_t
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::CalculateNumChildren ()
 {
     uint64_t count = 0;
     if (ExtractValueFromObjCExpression(m_backend, "int", "count", count))
         return count;
     return 0;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx)
 {
     StreamString idx_name;
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     lldb::ValueObjectSP valobj_sp = CallSelectorOnObject(m_backend,"id","objectAtIndex:",idx);
     if (valobj_sp)
         valobj_sp->SetName(ConstString(idx_name.GetData()));
     return valobj_sp;
 }
 
 bool
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::Update()
 {
     return false;
 }
 
 bool
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::MightHaveChildren ()
 {
     return true;
 }
 
 size_t
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
 {
     return 0;
 }
 
 lldb_private::formatters::NSArrayCodeRunningSyntheticFrontEnd::~NSArrayCodeRunningSyntheticFrontEnd ()
 {}
Index: projects/clang350-import/contrib/llvm/tools/lldb/source/lldb.cpp
===================================================================
--- projects/clang350-import/contrib/llvm/tools/lldb/source/lldb.cpp	(revision 275134)
+++ projects/clang350-import/contrib/llvm/tools/lldb/source/lldb.cpp	(revision 275135)
@@ -1,439 +1,437 @@
 //===-- lldb.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-python.h"
 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-private-log.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Interpreter/ScriptInterpreterPython.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
 #include "Plugins/Disassembler/llvm/DisassemblerLLVMC.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/Instruction/ARM/EmulateInstructionARM.h"
 #include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
 #include "Plugins/JITLoader/GDB/JITLoaderGDB.h"
 #include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
 #include "Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h"
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
 #include "Plugins/Process/elf-core/ProcessElfCore.h"
 #include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
 #include "Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h"
 #include "Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h"
 
 #ifndef LLDB_DISABLE_PYTHON
 #include "Plugins/OperatingSystem/Python/OperatingSystemPython.h"
 #endif
 #if defined (__APPLE__)
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
 #include "Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.h"
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "Plugins/Process/MacOSX-Kernel/ProcessKDP.h"
 #include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Plugins/Platform/MacOSX/PlatformDarwinKernel.h"
 #include "Plugins/Platform/MacOSX/PlatformiOSSimulator.h"
 #include "Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h"
 #endif
 
 
 #if defined (__linux__)
 #include "Plugins/Process/Linux/ProcessLinux.h"
 #endif
 
 #if defined (_WIN32)
 #include "Plugins/Process/Windows/ProcessWindows.h"
 #endif
 
 #if defined (__FreeBSD__)
 #include "Plugins/Process/POSIX/ProcessPOSIX.h"
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void fatal_error_handler(void *user_data, const std::string& reason,
                                 bool gen_crash_diag) {
     Host::SetCrashDescription(reason.c_str());
     ::abort();
 }
 
 void
 lldb_private::Initialize ()
 {
     // Make sure we inialize only once
     static Mutex g_inited_mutex(Mutex::eMutexTypeRecursive);
     static bool g_inited = false;
 
     Mutex::Locker locker(g_inited_mutex);
     if (!g_inited)
     {
         g_inited = true;
         Log::Initialize();
         HostInfo::Initialize();
         Timer::Initialize ();
         Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
 
         // Initialize LLVM and Clang
         llvm::InitializeAllTargets();
         llvm::InitializeAllAsmPrinters();
         llvm::InitializeAllTargetMCs();
         llvm::InitializeAllDisassemblers();
         llvm::install_fatal_error_handler(fatal_error_handler, 0);
 
         // Initialize plug-ins
         ABISysV_x86_64::Initialize();
         DisassemblerLLVMC::Initialize();
         ObjectContainerBSDArchive::Initialize();
         ObjectFileELF::Initialize();
         SymbolVendorELF::Initialize();
         SymbolFileDWARF::Initialize();
         SymbolFileSymtab::Initialize();
         UnwindAssemblyInstEmulation::Initialize();
         UnwindAssembly_x86::Initialize();
         EmulateInstructionARM::Initialize ();
         EmulateInstructionARM64::Initialize ();
         DynamicLoaderPOSIXDYLD::Initialize ();
         PlatformFreeBSD::Initialize();
-        PlatformKalimba::Initialize();
         SymbolFileDWARFDebugMap::Initialize();
         ItaniumABILanguageRuntime::Initialize();
 #ifndef LLDB_DISABLE_PYTHON
         ScriptInterpreterPython::InitializePrivate();
         OperatingSystemPython::Initialize();
 #endif
         JITLoaderGDB::Initialize();
         ProcessElfCore::Initialize();
         
 #if defined (__APPLE__)
         //----------------------------------------------------------------------
         // Apple/Darwin hosted plugins
         //----------------------------------------------------------------------
         DynamicLoaderMacOSXDYLD::Initialize();
         DynamicLoaderDarwinKernel::Initialize();
         AppleObjCRuntimeV2::Initialize();
         AppleObjCRuntimeV1::Initialize();
         ObjectContainerUniversalMachO::Initialize();
         ObjectFileMachO::Initialize();
         ProcessKDP::Initialize();
         PlatformDarwinKernel::Initialize();
         PlatformRemoteiOS::Initialize();
         PlatformMacOSX::Initialize();
         PlatformiOSSimulator::Initialize();
         SystemRuntimeMacOSX::Initialize();
 #endif
 #if defined (__linux__)
         //----------------------------------------------------------------------
         // Linux hosted plugins
         //----------------------------------------------------------------------
         ProcessLinux::Initialize();
 #endif
 #if defined(_WIN32)
         ProcessWindows::Initialize();
 #endif
 #if defined (__FreeBSD__)
         ProcessFreeBSD::Initialize();
 #endif
 
         //----------------------------------------------------------------------
         // Platform agnostic plugins
         //----------------------------------------------------------------------
         PlatformRemoteGDBServer::Initialize ();
         ProcessGDBRemote::Initialize();
         DynamicLoaderStatic::Initialize();
 
         // Scan for any system or user LLDB plug-ins
         PluginManager::Initialize();
 
         // The process settings need to know about installed plug-ins, so the Settings must be initialized
         // AFTER PluginManager::Initialize is called.
         
         Debugger::SettingsInitialize();
     }
 }
 
 void
 lldb_private::WillTerminate()
 {
     Host::WillTerminate();
 }
 
 void
 lldb_private::Terminate ()
 {
     Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     
     // Terminate and unload and loaded system or user LLDB plug-ins
     PluginManager::Terminate();
     ABISysV_x86_64::Terminate();
     DisassemblerLLVMC::Terminate();
     ObjectContainerBSDArchive::Terminate();
     ObjectFileELF::Terminate();
     SymbolVendorELF::Terminate();
     SymbolFileDWARF::Terminate();
     SymbolFileSymtab::Terminate();
     UnwindAssembly_x86::Terminate();
     UnwindAssemblyInstEmulation::Terminate();
     EmulateInstructionARM::Terminate ();
     EmulateInstructionARM64::Terminate ();
     DynamicLoaderPOSIXDYLD::Terminate ();
     PlatformFreeBSD::Terminate();
-    PlatformKalimba::Terminate();
     SymbolFileDWARFDebugMap::Terminate();
     ItaniumABILanguageRuntime::Terminate();
 #ifndef LLDB_DISABLE_PYTHON
     OperatingSystemPython::Terminate();
 #endif
     JITLoaderGDB::Terminate();
     ProcessElfCore::Terminate();
     
 #if defined (__APPLE__)
     DynamicLoaderMacOSXDYLD::Terminate();
     DynamicLoaderDarwinKernel::Terminate();
     AppleObjCRuntimeV2::Terminate();
     AppleObjCRuntimeV1::Terminate();
     ObjectContainerUniversalMachO::Terminate();
     ObjectFileMachO::Terminate();
     ProcessKDP::Terminate();
     PlatformMacOSX::Terminate();
     PlatformDarwinKernel::Terminate();
     PlatformRemoteiOS::Terminate();
     PlatformiOSSimulator::Terminate();
     SystemRuntimeMacOSX::Terminate();
 #endif
 
     Debugger::SettingsTerminate ();
 
 #if defined (__linux__)
     ProcessLinux::Terminate();
 #endif
 
 #if defined (__FreeBSD__)
     ProcessFreeBSD::Terminate();
 #endif
 
     ProcessGDBRemote::Terminate();
     DynamicLoaderStatic::Terminate();
 
     Log::Terminate();
 }
 
 #if defined (__APPLE__)
 extern "C" const unsigned char liblldb_coreVersionString[];
 #else
 
 #include "clang/Basic/Version.h"
 
 static const char *
 GetLLDBRevision()
 {
 #ifdef LLDB_REVISION
     return LLDB_REVISION;
 #else
     return NULL;
 #endif
 }
 
 static const char *
 GetLLDBRepository()
 {
 #ifdef LLDB_REPOSITORY
     return LLDB_REPOSITORY;
 #else
     return NULL;
 #endif
 }
 
 #endif
 
 const char *
 lldb_private::GetVersion ()
 {
 #if defined (__APPLE__)
     static char g_version_string[32];
     if (g_version_string[0] == '\0')
     {
         const char *version_string = ::strstr ((const char *)liblldb_coreVersionString, "PROJECT:");
         
         if (version_string)
             version_string += sizeof("PROJECT:") - 1;
         else
             version_string = "unknown";
         
         const char *newline_loc = strchr(version_string, '\n');
         
         size_t version_len = sizeof(g_version_string);
         
         if (newline_loc &&
             (newline_loc - version_string < static_cast<ptrdiff_t>(version_len)))
             version_len = newline_loc - version_string;
         
         ::strncpy(g_version_string, version_string, version_len);
     }
 
     return g_version_string;
 #else
     // On Linux/FreeBSD/Windows, report a version number in the same style as the clang tool.
     static std::string g_version_str;
     if (g_version_str.empty())
     {
         g_version_str += "lldb version ";
         g_version_str += CLANG_VERSION_STRING;
         const char * lldb_repo = GetLLDBRepository();
         if (lldb_repo)
         {
             g_version_str += " (";
             g_version_str += lldb_repo;
         }
 
         const char *lldb_rev = GetLLDBRevision();
         if (lldb_rev)
         {
             g_version_str += " revision ";
             g_version_str += lldb_rev;
         }
         std::string clang_rev (clang::getClangRevision());
         if (clang_rev.length() > 0)
         {
             g_version_str += " clang revision ";
             g_version_str += clang_rev;
         }
         std::string llvm_rev (clang::getLLVMRevision());
         if (llvm_rev.length() > 0)
         {
             g_version_str += " llvm revision ";
             g_version_str += llvm_rev;
         }
 
         if (lldb_repo)
             g_version_str += ")";
     }
     return g_version_str.c_str();
 #endif
 }
 
 const char *
 lldb_private::GetVoteAsCString (Vote vote)
 {
     switch (vote)
     {
     case eVoteNo:           return "no";
     case eVoteNoOpinion:    return "no opinion";
     case eVoteYes:          return "yes";
     }
     return "invalid";
 }
 
 
 const char *
 lldb_private::GetSectionTypeAsCString (SectionType sect_type)
 {
     switch (sect_type)
     {
     case eSectionTypeInvalid: return "invalid";
     case eSectionTypeCode: return "code";
     case eSectionTypeContainer: return "container";
     case eSectionTypeData: return "data";
     case eSectionTypeDataCString: return "data-cstr";
     case eSectionTypeDataCStringPointers: return "data-cstr-ptr";
     case eSectionTypeDataSymbolAddress: return "data-symbol-addr";
     case eSectionTypeData4: return "data-4-byte";
     case eSectionTypeData8: return "data-8-byte";
     case eSectionTypeData16: return "data-16-byte";
     case eSectionTypeDataPointers: return "data-ptrs";
     case eSectionTypeDebug: return "debug";
     case eSectionTypeZeroFill: return "zero-fill";
     case eSectionTypeDataObjCMessageRefs: return "objc-message-refs";
     case eSectionTypeDataObjCCFStrings: return "objc-cfstrings";
     case eSectionTypeDWARFDebugAbbrev: return "dwarf-abbrev";
     case eSectionTypeDWARFDebugAranges: return "dwarf-aranges";
     case eSectionTypeDWARFDebugFrame: return "dwarf-frame";
     case eSectionTypeDWARFDebugInfo: return "dwarf-info";
     case eSectionTypeDWARFDebugLine: return "dwarf-line";
     case eSectionTypeDWARFDebugLoc: return "dwarf-loc";
     case eSectionTypeDWARFDebugMacInfo: return "dwarf-macinfo";
     case eSectionTypeDWARFDebugPubNames: return "dwarf-pubnames";
     case eSectionTypeDWARFDebugPubTypes: return "dwarf-pubtypes";
     case eSectionTypeDWARFDebugRanges: return "dwarf-ranges";
     case eSectionTypeDWARFDebugStr: return "dwarf-str";
     case eSectionTypeELFSymbolTable: return "elf-symbol-table";
     case eSectionTypeELFDynamicSymbols: return "elf-dynamic-symbols";
     case eSectionTypeELFRelocationEntries: return "elf-relocation-entries";
     case eSectionTypeELFDynamicLinkInfo: return "elf-dynamic-link-info";
     case eSectionTypeDWARFAppleNames: return "apple-names";
     case eSectionTypeDWARFAppleTypes: return "apple-types";
     case eSectionTypeDWARFAppleNamespaces: return "apple-namespaces";
     case eSectionTypeDWARFAppleObjC: return "apple-objc";
     case eSectionTypeEHFrame: return "eh-frame";
     case eSectionTypeOther: return "regular";
     }
     return "unknown";
 
 }
 
 bool
 lldb_private::NameMatches (const char *name, 
                            NameMatchType match_type, 
                            const char *match)
 {
     if (match_type == eNameMatchIgnore)
         return true;
 
     if (name == match)
         return true;
 
     if (name && match)
     {
         llvm::StringRef name_sref(name);
         llvm::StringRef match_sref(match);
         switch (match_type)
         {
         case eNameMatchIgnore: // This case cannot occur: tested before
             return true;
         case eNameMatchEquals:      return name_sref == match_sref;
         case eNameMatchContains:    return name_sref.find (match_sref) != llvm::StringRef::npos;
         case eNameMatchStartsWith:  return name_sref.startswith (match_sref);
         case eNameMatchEndsWith:    return name_sref.endswith (match_sref);
         case eNameMatchRegularExpression:
             {
                 RegularExpression regex (match);
                 return regex.Execute (name);
             }
             break;
         }
     }
     return false;
 }