[LanguageRuntime] Move ObjCLanguageRuntime into a plugin

[xiaobai]

Summary

Following up to my CPPLanguageRuntime change, I'm moving
ObjCLanguageRuntime into a plugin as well.

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/ABI.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "DynamicLoaderDarwin.h"
 #include "DynamicLoaderMacOSXDYLD.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TaggedASTType.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include <memory>
 #include <vector>
 
 using namespace clang;
 using namespace lldb_private;
 
 // Scoped class that will remove an active lexical decl from the set when it
 // goes out of scope.

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
 namespace {
 const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 } // anonymous namespace

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include <cctype>
 #include <memory>
 
 using namespace clang;
 using namespace llvm;
 using namespace lldb_private;
 
 //===----------------------------------------------------------------------===//

source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "IRDynamicChecks.h"
 
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 using namespace llvm;
 using namespace lldb_private;
 
 static char ID;
 
 #define VALID_POINTER_CHECK_NAME "_$__lldb_valid_pointer_check"
 #define VALID_OBJC_OBJECT_CHECK_NAME "$__lldb_objc_object_check"
 

source/Plugins/Language/ObjC/CF.cpp

 //===-- CF.cpp ----------------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CF.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 bool lldb_private::formatters::CFAbsoluteTimeSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   time_t epoch = GetOSXEpoch();
   epoch = epoch + (time_t)valobj.GetValueAsUnsigned(0);

source/Plugins/Language/ObjC/Cocoa.h

 //===-- Cocoa.h ---------------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Cocoa_h_
 #define liblldb_Cocoa_h_
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Utility/Stream.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 namespace formatters {
 bool NSIndexSetSummaryProvider(ValueObject &valobj, Stream &stream,
                                const TypeSummaryOptions &options);
 
 bool NSArraySummaryProvider(ValueObject &valobj, Stream &stream,
                             const TypeSummaryOptions &options);
 

source/Plugins/Language/ObjC/Cocoa.cpp

 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/Host/Time.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 

source/Plugins/Language/ObjC/NSArray.cpp

 //===-- NSArray.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 
 #include "Cocoa.h"
 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
+
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

source/Plugins/Language/ObjC/NSDictionary.cpp

 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;

source/Plugins/Language/ObjC/NSError.cpp

 //===-- NSError.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/DeclCXX.h"
 
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 #include "Plugins/Language/ObjC/NSString.h"
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 static lldb::addr_t DerefToNSErrorPointer(ValueObject &valobj) {
   CompilerType valobj_type(valobj.GetCompilerType());
   Flags type_flags(valobj_type.GetTypeInfo());

source/Plugins/Language/ObjC/NSException.cpp

 //===-- NSException.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/DeclCXX.h"
 
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 #include "Plugins/Language/ObjC/NSString.h"
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 static bool ExtractFields(ValueObject &valobj, ValueObjectSP *name_sp,
                           ValueObjectSP *reason_sp, ValueObjectSP *userinfo_sp,
                           ValueObjectSP *reserved_sp) {

source/Plugins/Language/ObjC/NSIndexPath.cpp

 //===-- NSIndexPath.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Cocoa.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 static constexpr size_t PACKED_INDEX_SHIFT_64(size_t i) {
   return (60 - (13 * (4 - i)));
 }
 

source/Plugins/Language/ObjC/NSSet.cpp

 //===-- NSSet.cpp -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "NSSet.h"
 
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

source/Plugins/Language/ObjC/NSString.h

 //===-- NSString.h ---------------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NSString_h_
 #define liblldb_NSString_h_
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/TypeSummary.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Utility/Stream.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 namespace formatters {
 bool NSStringSummaryProvider(ValueObject &valobj, Stream &stream,
                              const TypeSummaryOptions &options);
 
 bool NSTaggedString_SummaryProvider(
     ValueObject &valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor,
     Stream &stream, const TypeSummaryOptions &summary_options);

source/Plugins/Language/ObjC/ObjCLanguage.cpp

 #include "ObjCLanguage.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompilerType.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/Threading.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include "CF.h"
 #include "Cocoa.h"
 #include "CoreMedia.h"
 #include "NSDictionary.h"
 #include "NSSet.h"
 #include "NSString.h"
 
 using namespace lldb;

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h

 //===-- AppleObjCClassDescriptorV2.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCClassDescriptorV2_h_
 #define liblldb_AppleObjCClassDescriptorV2_h_
 
 #include <mutex>
 
 #include "AppleObjCRuntimeV2.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 
 class ClassDescriptorV2 : public ObjCLanguageRuntime::ClassDescriptor {
 public:
   friend class lldb_private::AppleObjCRuntimeV2;
 
   ~ClassDescriptorV2() override = default;
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

 //===-- AppleObjCDeclVendor.h -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCDeclVendor_h_
 #define liblldb_AppleObjCDeclVendor_h_
 
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/DeclVendor.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 
 class AppleObjCExternalASTSource;
 
 class AppleObjCDeclVendor : public DeclVendor {
 public:
   AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

 //===-- AppleObjCDeclVendor.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleObjCDeclVendor.h"
 
 #include "Plugins/ExpressionParser/Clang/ASTDumper.h"
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.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) {}
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h

 //===-- AppleObjCRuntime.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCRuntime_h_
 #define liblldb_AppleObjCRuntime_h_
 
 #include "llvm/ADT/Optional.h"
 
 #include "AppleObjCTrampolineHandler.h"
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
 #include "lldb/Target/LanguageRuntime.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 
 class AppleObjCRuntime : public lldb_private::ObjCLanguageRuntime {
 public:
   ~AppleObjCRuntime() override;
 
   // Static Functions
   // Note there is no CreateInstance, Initialize & Terminate functions here,

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h

 //===-- AppleObjCRuntimeV1.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCRuntimeV1_h_
 #define liblldb_AppleObjCRuntimeV1_h_
 
 #include "AppleObjCRuntime.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_private {
 
 class AppleObjCRuntimeV1 : public AppleObjCRuntime {
 public:
   ~AppleObjCRuntimeV1() override = default;
 
   // Static Functions
   static void Initialize();

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

 //===-- AppleObjCRuntimeV2.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCRuntimeV2_h_
 #define liblldb_AppleObjCRuntimeV2_h_
 
 #include <map>
 #include <memory>
 #include <mutex>
 
 #include "AppleObjCRuntime.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 class RemoteNXMapTable;
 
 namespace lldb_private {
 
 class AppleObjCRuntimeV2 : public AppleObjCRuntime {
 public:
   ~AppleObjCRuntimeV2() override = default;
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 #include "lldb/Interpreter/OptionValueBoolean.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/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
 #include "AppleObjCClassDescriptorV2.h"
 #include "AppleObjCDeclVendor.h"
 #include "AppleObjCRuntimeV2.h"
 #include "AppleObjCTrampolineHandler.h"
 #include "AppleObjCTypeEncodingParser.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 char AppleObjCRuntimeV2::ID = 0;
 
 static const char *g_get_dynamic_class_info_name =

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.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/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/STLExtras.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name =
     "__lldb_objc_find_implementation_for_selector";
 const char *AppleObjCTrampolineHandler::

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.h

 //===-- AppleObjCTypeEncodingParser.h ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_AppleObjCTypeEncodingParser_h_
 #define liblldb_AppleObjCTypeEncodingParser_h_
 
 #include "clang/AST/ASTContext.h"
 
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 namespace lldb_utility {
 class StringLexer;
 }
 
 namespace lldb_private {
 
 class AppleObjCTypeEncodingParser : public ObjCLanguageRuntime::EncodingToType {
 public:

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

 //===-- AppleThreadPlanStepThroughObjCTrampoline.cpp
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
 
 #include "AppleObjCTrampolineHandler.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Utility/Log.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
+
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // ThreadPlanStepThroughObjCTrampoline constructor
 AppleThreadPlanStepThroughObjCTrampoline::
     AppleThreadPlanStepThroughObjCTrampoline(

source/Plugins/LanguageRuntime/ObjC/CMakeLists.txt

+add_lldb_library(lldbPluginObjCRuntime PLUGIN
+  ObjCLanguageRuntime.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbSymbol
+    lldbTarget
+    lldbUtility
+)
 add_subdirectory(AppleObjCRuntime)

source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

 //===-- ObjCLanguageRuntime.h -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ObjCLanguageRuntime_h_
 #define liblldb_ObjCLanguageRuntime_h_
 
 #include <functional>
 #include <map>
 #include <memory>
 #include <unordered_set>
 
 #include "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;
 
 namespace lldb_private {
 
 class UtilityFunction;
 
 class ObjCLanguageRuntime : public LanguageRuntime {
 public:
   enum class ObjCRuntimeVersions {
     eObjC_VersionUnknown = 0,
     eAppleObjC_V1 = 1,
     eAppleObjC_V2 = 2
   };
 
   typedef lldb::addr_t ObjCISA;
 
   class ClassDescriptor;
   typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP;
 
   // the information that we want to support retrieving from an ObjC class this
   // needs to be pure virtual since there are at least 2 different
   // implementations of the runtime, and more might come
   class ClassDescriptor {
   public:
     ClassDescriptor()
         : m_is_kvo(eLazyBoolCalculate), m_is_cf(eLazyBoolCalculate),
           m_type_wp() {}
 
     virtual ~ClassDescriptor() = default;
 
     virtual ConstString GetClassName() = 0;
 
     virtual ClassDescriptorSP GetSuperclass() = 0;
 
     virtual ClassDescriptorSP GetMetaclass() const = 0;
 
     // virtual if any implementation has some other version-specific rules but
     // for the known v1/v2 this is all that needs to be done
     virtual bool IsKVO() {
       if (m_is_kvo == eLazyBoolCalculate) {
         const char *class_name = GetClassName().AsCString();
         if (class_name && *class_name)
           m_is_kvo =
               (LazyBool)(strstr(class_name, "NSKVONotifying_") == class_name);
       }
       return (m_is_kvo == eLazyBoolYes);
     }
 
     // virtual if any implementation has some other version-specific rules but
     // for the known v1/v2 this is all that needs to be done
     virtual bool IsCFType() {
       if (m_is_cf == eLazyBoolCalculate) {
         const char *class_name = GetClassName().AsCString();
         if (class_name && *class_name)
           m_is_cf = (LazyBool)(strcmp(class_name, "__NSCFType") == 0 ||
                                strcmp(class_name, "NSCFType") == 0);
       }
       return (m_is_cf == eLazyBoolYes);
     }
 
     virtual bool IsValid() = 0;
 
     virtual bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr,
                                       uint64_t *value_bits = nullptr,
                                       uint64_t *payload = nullptr) = 0;
 
     virtual uint64_t GetInstanceSize() = 0;
 
     // use to implement version-specific additional constraints on pointers
     virtual bool CheckPointer(lldb::addr_t value, uint32_t ptr_size) const {
       return true;
     }
 
     virtual ObjCISA GetISA() = 0;
 
     // This should return true iff the interface could be completed
     virtual bool
     Describe(std::function<void(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::TypeSP GetType() { return m_type_wp.lock(); }
 
     void SetType(const lldb::TypeSP &type_sp) { m_type_wp = type_sp; }
 
     struct iVarDescriptor {
       ConstString m_name;
       CompilerType m_type;
       uint64_t m_size;
       int32_t m_offset;
     };
 
     virtual size_t GetNumIVars() { return 0; }
 
     virtual iVarDescriptor GetIVarAtIndex(size_t idx) {
       return iVarDescriptor();
     }
 
   protected:
     bool IsPointerValid(lldb::addr_t value, uint32_t ptr_size,
                         bool allow_NULLs = false, bool allow_tagged = false,
                         bool check_version_specific = false) const;
 
   private:
     LazyBool m_is_kvo;
     LazyBool m_is_cf;
     lldb::TypeWP m_type_wp;
   };
 
   class EncodingToType {
   public:
     virtual ~EncodingToType();
 
     virtual CompilerType RealizeType(ClangASTContext &ast_ctx, const char *name,
                                      bool for_expression);
     virtual CompilerType RealizeType(const char *name, bool for_expression);
 
     virtual CompilerType RealizeType(clang::ASTContext &ast_ctx,
                                      const char *name, bool for_expression) = 0;
 
   protected:
     std::unique_ptr<ClangASTContext> m_scratch_ast_ctx_up;
   };
 
   class ObjCExceptionPrecondition : public BreakpointPrecondition {
   public:
     ObjCExceptionPrecondition();
 
     ~ObjCExceptionPrecondition() override = default;
 
     bool EvaluatePrecondition(StoppointCallbackContext &context) override;
     void GetDescription(Stream &stream, lldb::DescriptionLevel level) override;
     Status ConfigurePrecondition(Args &args) override;
 
   protected:
     void AddClassName(const char *class_name);
 
   private:
     std::unordered_set<std::string> m_class_names;
   };
 
   static lldb::BreakpointPreconditionSP
   GetBreakpointExceptionPrecondition(lldb::LanguageType language,
                                      bool throw_bp);
 
   class TaggedPointerVendor {
   public:
     virtual ~TaggedPointerVendor() = default;
 
     virtual bool IsPossibleTaggedPointer(lldb::addr_t ptr) = 0;
 
     virtual ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) = 0;
 
   protected:
     TaggedPointerVendor() = default;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendor);
   };
 
   ~ObjCLanguageRuntime() override;
 
   static char ID;
 
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || LanguageRuntime::isA(ClassID);
   }
 
   static bool classof(const LanguageRuntime *runtime) {
     return runtime->isA(&ID);
   }
 
   static ObjCLanguageRuntime *Get(Process &process) {
     return llvm::cast_or_null<ObjCLanguageRuntime>(
         process.GetLanguageRuntime(lldb::eLanguageTypeObjC));
   }
 
   virtual TaggedPointerVendor *GetTaggedPointerVendor() { return nullptr; }
 
   typedef std::shared_ptr<EncodingToType> EncodingToTypeSP;
 
   virtual EncodingToTypeSP GetEncodingToType();
 
   virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value);
 
   ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value);
 
   virtual ClassDescriptorSP
   GetClassDescriptorFromClassName(ConstString class_name);
 
   virtual ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa);
 
   ClassDescriptorSP GetNonKVOClassDescriptor(ObjCISA isa);
 
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeObjC;
   }
 
   virtual bool IsModuleObjCLibrary(const lldb::ModuleSP &module_sp) = 0;
 
   virtual bool ReadObjCLibrary(const lldb::ModuleSP &module_sp) = 0;
 
   virtual bool HasReadObjCLibrary() = 0;
 
   lldb::addr_t LookupInMethodCache(lldb::addr_t class_addr, lldb::addr_t sel);
 
   void AddToMethodCache(lldb::addr_t class_addr, lldb::addr_t sel,
                         lldb::addr_t impl_addr);
 
   TypeAndOrName LookupInClassNameCache(lldb::addr_t class_addr);
 
   void AddToClassNameCache(lldb::addr_t class_addr, const char *name,
                            lldb::TypeSP type_sp);
 
   void AddToClassNameCache(lldb::addr_t class_addr,
                            const TypeAndOrName &class_or_type_name);
 
   lldb::TypeSP LookupInCompleteClassCache(ConstString &name);
 
   llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) override;
 
   virtual UtilityFunction *CreateObjectChecker(const char *) = 0;
 
   virtual ObjCRuntimeVersions GetRuntimeVersion() const {
     return ObjCRuntimeVersions::eObjC_VersionUnknown;
   }
 
   bool IsValidISA(ObjCISA isa) {
     UpdateISAToDescriptorMap();
     return m_isa_to_descriptor.count(isa) > 0;
   }
 
   virtual void UpdateISAToDescriptorMapIfNeeded() = 0;
 
   void UpdateISAToDescriptorMap() {
     if (m_process && m_process->GetStopID() != m_isa_to_descriptor_stop_id) {
       UpdateISAToDescriptorMapIfNeeded();
     }
   }
 
   virtual ObjCISA GetISA(ConstString name);
 
   virtual ConstString GetActualTypeName(ObjCISA isa);
 
   virtual ObjCISA GetParentClass(ObjCISA isa);
 
   // Finds the byte offset of the child_type ivar in parent_type.  If it can't
   // find the offset, returns LLDB_INVALID_IVAR_OFFSET.
 
   virtual size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,
                                       const char *ivar_name);
 
   bool HasNewLiteralsAndIndexing() {
     if (m_has_new_literals_and_indexing == eLazyBoolCalculate) {
       if (CalculateHasNewLiteralsAndIndexing())
         m_has_new_literals_and_indexing = eLazyBoolYes;
       else
         m_has_new_literals_and_indexing = eLazyBoolNo;
     }
 
     return (m_has_new_literals_and_indexing == eLazyBoolYes);
   }
 
   void SymbolsDidLoad(const ModuleList &module_list) override {
     m_negative_complete_class_cache.clear();
   }
 
   bool GetTypeBitSize(const CompilerType &compiler_type,
                       uint64_t &size) override;
 
   /// Check whether the name is "self" or "_cmd" and should show up in
   /// "frame variable".
   bool IsWhitelistedRuntimeValue(ConstString name) override;
 
 protected:
   // Classes that inherit from ObjCLanguageRuntime can see and modify these
   ObjCLanguageRuntime(Process *process);
 
   virtual bool CalculateHasNewLiteralsAndIndexing() { return false; }
 
   bool ISAIsCached(ObjCISA isa) const {
     return m_isa_to_descriptor.find(isa) != m_isa_to_descriptor.end();
   }
 
   bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp) {
     if (isa != 0) {
       m_isa_to_descriptor[isa] = descriptor_sp;
       return true;
     }
     return false;
   }
 
   bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp,
                 const char *class_name);
 
   bool AddClass(ObjCISA isa, const ClassDescriptorSP &descriptor_sp,
                 uint32_t class_name_hash) {
     if (isa != 0) {
       m_isa_to_descriptor[isa] = descriptor_sp;
       m_hash_to_isa_map.insert(std::make_pair(class_name_hash, isa));
       return true;
     }
     return false;
   }
 
 private:
   // We keep a map of <Class,Selector>->Implementation so we don't have to call
   // the resolver function over and over.
 
   // FIXME: We need to watch for the loading of Protocols, and flush the cache
   // for any
   // class that we see so changed.
 
   struct ClassAndSel {
     ClassAndSel() {
       sel_addr = LLDB_INVALID_ADDRESS;
       class_addr = LLDB_INVALID_ADDRESS;
     }
 
     ClassAndSel(lldb::addr_t in_sel_addr, lldb::addr_t in_class_addr)
         : class_addr(in_class_addr), sel_addr(in_sel_addr) {}
 
     bool operator==(const ClassAndSel &rhs) {
       if (class_addr == rhs.class_addr && sel_addr == rhs.sel_addr)
         return true;
       else
         return false;
     }
 
     bool operator<(const ClassAndSel &rhs) const {
       if (class_addr < rhs.class_addr)
         return true;
       else if (class_addr > rhs.class_addr)
         return false;
       else {
         if (sel_addr < rhs.sel_addr)
           return true;
         else
           return false;
       }
     }
 
     lldb::addr_t class_addr;
     lldb::addr_t sel_addr;
   };
 
   typedef std::map<ClassAndSel, lldb::addr_t> MsgImplMap;
   typedef std::map<ObjCISA, ClassDescriptorSP> ISAToDescriptorMap;
   typedef std::multimap<uint32_t, ObjCISA> HashToISAMap;
   typedef ISAToDescriptorMap::iterator ISAToDescriptorIterator;
   typedef HashToISAMap::iterator HashToISAIterator;
   typedef ThreadSafeDenseMap<void *, uint64_t> TypeSizeCache;
 
   MsgImplMap m_impl_cache;
   LazyBool m_has_new_literals_and_indexing;
   ISAToDescriptorMap m_isa_to_descriptor;
   HashToISAMap m_hash_to_isa_map;
   TypeSizeCache m_type_size_cache;
 
 protected:
   uint32_t m_isa_to_descriptor_stop_id;
 
   typedef std::map<ConstString, lldb::TypeWP> CompleteClassMap;
   CompleteClassMap m_complete_class_cache;
 
   struct ConstStringSetHelpers {
     size_t operator()(ConstString arg) const // for hashing
     {
       return (size_t)arg.GetCString();
     }
     bool operator()(ConstString arg1,
                     ConstString arg2) const // for equality
     {
       return arg1.operator==(arg2);
     }
   };
   typedef std::unordered_set<ConstString, ConstStringSetHelpers,
                              ConstStringSetHelpers>
       CompleteClassSet;
   CompleteClassSet m_negative_complete_class_cache;
 
   ISAToDescriptorIterator GetDescriptorIterator(ConstString name);
 
   friend class ::CommandObjectObjC_ClassTable_Dump;
 
   std::pair<ISAToDescriptorIterator, ISAToDescriptorIterator>
   GetDescriptorIteratorPair(bool update_if_needed = true);
 
   void ReadObjCLibraryIfNeeded(const ModuleList &module_list);
 
   DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ObjCLanguageRuntime_h_

source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

 //===-- ObjCLanguageRuntime.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "clang/AST/Type.h"
 
+#include "ObjCLanguageRuntime.h"
+
 #include "lldb/Core/MappedHash.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DJB.h"
 
 using namespace lldb;

source/Symbol/CMakeLists.txt

LINK_LIBS
     lldbExpression
     lldbHost
     lldbTarget
     lldbUtility
     lldbPluginExpressionParserClang
     lldbPluginSymbolFileDWARF
     lldbPluginSymbolFilePDB
     lldbPluginObjCLanguage
+    lldbPluginObjCRuntime
 
   LINK_COMPONENTS
     Support
   )

source/Symbol/ClangASTContext.cpp

 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VerifyDecl.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Scalar.h"
 
+#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/PDB/PDBASTParser.h"
 
 #include <stdio.h>
 
 #include <mutex>
 
 using namespace lldb;

source/Target/CMakeLists.txt

 add_lldb_library(lldbTarget
   ABI.cpp
   ExecutionContext.cpp
   JITLoader.cpp
   JITLoaderList.cpp
   InstrumentationRuntime.cpp
   InstrumentationRuntimeStopInfo.cpp
   Language.cpp
   LanguageRuntime.cpp
   Memory.cpp
   MemoryHistory.cpp
   ModuleCache.cpp
-  ObjCLanguageRuntime.cpp
   OperatingSystem.cpp
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
   Queue.cpp
   QueueItem.cpp
   QueueList.cpp
   RegisterContext.cpp