[Target] Remove Process::GetObjCLanguageRuntime

[xiaobai]

Summary

In an effort to make Process more language agnostic, I removed
GetCPPLanguageRuntime from Process. I'm following up now with an equivalent
change for ObjC.

[xiaobai]

Small cleanups

[compnerd]

include/lldb/Target/ObjCLanguageRuntime.h

202 ↗

(On Diff #203714)

I think it would be nice to just call this Get (and we could have equivalents in the other languages). It makes the uses less verbose and repetitive.

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

515 ↗

(On Diff #203714)

Why not create a variable?

if (const auto *runtime = ObjCLanguageRuntime::Get(*process))

[labath]

include/lldb/Target/ObjCLanguageRuntime.h

202 ↗

(On Diff #203714)

I like that idea.

[xiaobai]

include/lldb/Target/ObjCLanguageRuntime.h

202 ↗

(On Diff #203714)

I also like this idea. Would you mind if I did that in a follow up?

[xiaobai]

Simplify a change

[labath]

include/lldb/Target/ObjCLanguageRuntime.h

202 ↗

(On Diff #203714)

You're introducing the function in this patch. What's the point in renaming it immediately after that?

I can see how renaming GetCPPLanguageRuntime might be a good thing to do in a separate patch, but I don't see a reason to do that with this function

[xiaobai]

include/lldb/Target/ObjCLanguageRuntime.h

202 ↗

(On Diff #203714)

Fair enough. I'll update this patch.

[xiaobai]

ObjCLanguageRuntime::GetObjCLanguageRuntime -> ObjCLanguageRuntime::Get

lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h

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

lldb/trunk/include/lldb/Target/Process.h

public:
   OperatingSystem *GetOperatingSystem() { return m_os_up.get(); }
 
   std::vector<LanguageRuntime *>
   GetLanguageRuntimes(bool retry_if_null = true);
 
   LanguageRuntime *GetLanguageRuntime(lldb::LanguageType language,
                                       bool retry_if_null = true);
 
-  ObjCLanguageRuntime *GetObjCLanguageRuntime(bool retry_if_null = true);
-
   bool IsPossibleDynamicValue(ValueObject &in_value);
 
   bool IsRunning() const;
 
   DynamicCheckerFunctions *GetDynamicCheckers() {
     return m_dynamic_checkers_up.get();
   }
 

lldb/trunk/include/lldb/lldb-forward.h

 class MemoryHistory;
 class MemoryRegionInfo;
 class MemoryRegionInfos;
 class Module;
 class ModuleList;
 class ModuleSpec;
 class ModuleSpecList;
 struct NameSearchContext;
-class ObjCLanguageRuntime;
 class ObjectContainer;
 class OptionGroup;
 class OptionGroupOptions;
 class OptionGroupPlatform;
 class ObjectFile;
 class ObjectFileJITDelegate;
 class OperatingSystem;
 class Options;

lldb/trunk/source/API/SBTarget.cpp

if (typename_cstr && typename_cstr[0] && target_sp) {
 
     // Didn't find the type in the symbols; try the Objective-C runtime if one
     // is installed
 
     ProcessSP process_sp(target_sp->GetProcessSP());
 
     if (process_sp) {
       ObjCLanguageRuntime *objc_language_runtime =
-          process_sp->GetObjCLanguageRuntime();
+          ObjCLanguageRuntime::Get(*process_sp);
 
       if (objc_language_runtime) {
         DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor();
 
         if (objc_decl_vendor) {
           std::vector<clang::NamedDecl *> decls;
 
           if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) {
if (typename_cstr && typename_cstr[0] && target_sp) {
     }
 
     // Try the Objective-C runtime if one is installed
 
     ProcessSP process_sp(target_sp->GetProcessSP());
 
     if (process_sp) {
       ObjCLanguageRuntime *objc_language_runtime =
-          process_sp->GetObjCLanguageRuntime();
+          ObjCLanguageRuntime::Get(*process_sp);
 
       if (objc_language_runtime) {
         DeclVendor *objc_decl_vendor = objc_language_runtime->GetDeclVendor();
 
         if (objc_decl_vendor) {
           std::vector<clang::NamedDecl *> decls;
 
           if (objc_decl_vendor->FindDecls(const_typename, true, 1, decls) > 0) {

lldb/trunk/source/Core/ValueObject.cpp

if (class_type) {
     ConstString class_name(class_type.GetConstTypeName());
 
     if (class_name) {
       ProcessSP process_sp(
           GetUpdatePoint().GetExecutionContextRef().GetProcessSP());
 
       if (process_sp) {
         ObjCLanguageRuntime *objc_language_runtime(
-            process_sp->GetObjCLanguageRuntime());
+            ObjCLanguageRuntime::Get(*process_sp));
 
         if (objc_language_runtime) {
           TypeSP complete_objc_class_type_sp =
               objc_language_runtime->LookupInCompleteClassCache(class_name);
 
           if (complete_objc_class_type_sp) {
             CompilerType complete_class(
                 complete_objc_class_type_sp->GetFullCompilerType());

 }
 
 bool ValueObject::IsRuntimeSupportValue() {
   Process *process(GetProcessSP().get());
   if (process) {
     LanguageRuntime *runtime =
         process->GetLanguageRuntime(GetObjectRuntimeLanguage());
     if (!runtime)
-      runtime = process->GetObjCLanguageRuntime();
+      runtime = ObjCLanguageRuntime::Get(*process);
     if (runtime)
       return runtime->IsRuntimeSupportValue(*this);
     // If there is no language runtime, trust the compiler to mark all
     // runtime support variables as artificial.
     return GetVariable() && GetVariable()->IsArtificial();
   }
   return false;
 }
lldb::ThreadSP ValueObjectManager::GetThreadSP() const {
   return lldb::ThreadSP();
 }
 
 lldb::StackFrameSP ValueObjectManager::GetFrameSP() const {
   if (m_root_valobj_sp)
     return m_root_valobj_sp->GetFrameSP();
   return lldb::StackFrameSP();
 }
-

lldb/trunk/source/Expression/IRDynamicChecks.cpp

bool DynamicCheckerFunctions::Install(DiagnosticManager &diagnostic_manager,
 
   if (!m_valid_pointer_check->Install(diagnostic_manager, exe_ctx))
     return false;
 
   Process *process = exe_ctx.GetProcessPtr();
 
   if (process) {
     ObjCLanguageRuntime *objc_language_runtime =
-        process->GetObjCLanguageRuntime();
+        ObjCLanguageRuntime::Get(*process);
 
     if (objc_language_runtime) {
       m_objc_object_check.reset(objc_language_runtime->CreateObjectChecker(
           VALID_OBJC_OBJECT_CHECK_NAME));
 
       if (!m_objc_object_check->Install(diagnostic_manager, exe_ctx))
         return false;
     }

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

bool DynamicLoaderDarwin::AlwaysRelyOnEHUnwindInfo(SymbolContext &sym_ctx) {
   }
   if (module_sp.get() == nullptr && sym_ctx.function) {
     module_sp =
         sym_ctx.function->GetAddressRange().GetBaseAddress().GetModule();
   }
   if (module_sp.get() == nullptr)
     return false;
 
-  ObjCLanguageRuntime *objc_runtime = m_process->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*m_process);
   return objc_runtime != nullptr &&
          objc_runtime->IsModuleObjCLibrary(module_sp);
 }
 
 // Dump a Segment to the file handle provided.
 void DynamicLoaderDarwin::Segment::PutToLog(Log *log,
                                             lldb::addr_t slide) const {
   if (log) {

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (m_target->GetUseModernTypeLookup()) {
     }
 
     do {
       lldb::ProcessSP process(m_target->GetProcessSP());
 
       if (!process)
         break;
 
-      ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
+      ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
 
       if (!language_runtime)
         break;
 
       DeclVendor *runtime_decl_vendor = language_runtime->GetDeclVendor();
 
       if (!runtime_decl_vendor)
         break;

 
 clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
     const clang::ObjCInterfaceDecl *interface_decl) {
   lldb::ProcessSP process(m_target->GetProcessSP());
 
   if (!process)
     return nullptr;
 
-  ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
+  ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
 
   if (!language_runtime)
     return nullptr;
 
   ConstString class_name(interface_decl->getNameAsString().c_str());
 
   lldb::TypeSP complete_type_sp(
       language_runtime->LookupInCompleteClassCache(class_name));
if (!context.m_found.type) {
         // one exists.
 
         lldb::ProcessSP process(m_target->GetProcessSP());
 
         if (!process)
           break;
 
         ObjCLanguageRuntime *language_runtime(
-            process->GetObjCLanguageRuntime());
+            ObjCLanguageRuntime::Get(*process));
 
         if (!language_runtime)
           break;
 
         DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
 
         if (!decl_vendor)
           break;
do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and the modules don't get us anywhere.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
     if (!process)
       break;
 
-    ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
+    ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
 
     if (!language_runtime)
       break;
 
     DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
 
     if (!decl_vendor)
       break;
do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and nothing was in the modules.
 
     lldb::ProcessSP process(m_target->GetProcessSP());
 
     if (!process)
       return;
 
-    ObjCLanguageRuntime *language_runtime(process->GetObjCLanguageRuntime());
+    ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
 
     if (!language_runtime)
       return;
 
     DeclVendor *decl_vendor = language_runtime->GetDeclVendor();
 
     if (!decl_vendor)
       break;

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

for (uint32_t i = 0;
     case eSymbolTypeObjCMetaClass:
     case eSymbolTypeObjCIVar:
       symbol_load_addr = sym_address.GetLoadAddress(&target);
       break;
     }
   }
 
   if (symbol_load_addr == LLDB_INVALID_ADDRESS && process) {
-    ObjCLanguageRuntime *runtime = process->GetObjCLanguageRuntime();
+    ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process);
 
     if (runtime) {
       symbol_load_addr = runtime->LookupRuntimeSymbol(name);
     }
   }
 
   return symbol_load_addr;
 }

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (clang_expr && clang_expr->DidImportCxxModules()) {
     lang_opts.DoubleSquareBracketAttributes = true;
     lang_opts.CPlusPlus11 = true;
 
     SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
                            target_sp);
   }
 
   if (process_sp && lang_opts.ObjC) {
-    if (process_sp->GetObjCLanguageRuntime()) {
-      if (process_sp->GetObjCLanguageRuntime()->GetRuntimeVersion() ==
+    if (auto *runtime = ObjCLanguageRuntime::Get(*process_sp)) {
+      if (runtime->GetRuntimeVersion() ==
           ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2)
         lang_opts.ObjCRuntime.set(ObjCRuntime::MacOSX, VersionTuple(10, 7));
       else
         lang_opts.ObjCRuntime.set(ObjCRuntime::FragileMacOSX,
                                   VersionTuple(10, 7));
 
-      if (process_sp->GetObjCLanguageRuntime()->HasNewLiteralsAndIndexing())
+      if (runtime->HasNewLiteralsAndIndexing())
         lang_opts.DebuggerObjCLiteral = true;
     }
   }
 
   lang_opts.ThreadsafeStatics = false;
   lang_opts.AccessControl = false; // Debuggers get universal access
   lang_opts.DollarIdents = true;   // $ indicates a persistent variable name
   // We enable all builtin functions beside the builtins from libc/libm (e.g.

lldb/trunk/source/Plugins/Language/ObjC/CF.cpp

 bool lldb_private::formatters::CFBagSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   static ConstString g_TypeHint("CFBag");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor.get() || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::CFBitVectorSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor.get() || !descriptor->IsValid())

 bool lldb_private::formatters::CFBinaryHeapSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   static ConstString g_TypeHint("CFBinaryHeap");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor.get() || !descriptor->IsValid())

lldb/trunk/source/Plugins/Language/ObjC/Cocoa.cpp

 using namespace lldb_private::formatters;
 
 bool lldb_private::formatters::NSBundleSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSTimeZoneSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSNotificationSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSMachPortSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSIndexSetSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSNumberSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())
if (descriptor->GetTaggedPointerInfo(&i_bits, &value)) {
         NSNumber_FormatLong(valobj, stream, value, options.GetLanguage());
         break;
       default:
         return false;
       }
       return true;
     } else {
       Status error;
-      
-      AppleObjCRuntime *runtime =
-      llvm::dyn_cast_or_null<AppleObjCRuntime>(
-          process_sp->GetObjCLanguageRuntime());
+      AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
+          ObjCLanguageRuntime::Get(*process_sp));
 
       const bool new_format =
           (runtime && runtime->GetFoundationVersion() >= 1400);
 
       enum class TypeCodes : int {
         sint8 = 0x0,
         sint16 = 0x1,
         sint32 = 0x2,

 }
 
 bool lldb_private::formatters::NSURLSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 bool lldb_private::formatters::NSDateSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())
bool lldb_private::formatters::NSDateSummaryProvider(
   if (date_value == -63114076800) {
     stream.Printf("0001-12-30 00:00:00 +0000");
     return true;
   }
 
   // Accomodate for the __NSTaggedDate format introduced in Foundation 1600.
   if (class_name == g___NSTaggedDate) {
     auto *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
-        process_sp->GetObjCLanguageRuntime());
+        ObjCLanguageRuntime::Get(*process_sp));
     if (runtime && runtime->GetFoundationVersion() >= 1600)
       date_value = decodeTaggedTimeInterval(value_bits << 4);
   }
 
   // this snippet of code assumes that time_t == seconds since Jan-1-1970 this
   // is generally true and POSIXly happy, but might break if a library vendor
   // decides to get creative
   time_t epoch = GetOSXEpoch();

 }
 
 bool lldb_private::formatters::ObjCClassSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptorFromISA(valobj.GetValueAsUnsigned(0)));
 
   if (!descriptor || !descriptor->IsValid())

 
 template <bool needs_at>
 bool lldb_private::formatters::NSDataSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())
bool lldb_private::formatters::ObjCBooleanSummaryProvider(
   if (valobj_ptr_value == LLDB_INVALID_ADDRESS)
     return false;
 
   ProcessSP process_sp(valobj.GetProcessSP());
   if (!process_sp)
     return false;
 
   if (AppleObjCRuntime *objc_runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
-          process_sp->GetObjCLanguageRuntime())) {
+          ObjCLanguageRuntime::Get(*process_sp))) {
     lldb::addr_t cf_true = LLDB_INVALID_ADDRESS,
                  cf_false = LLDB_INVALID_ADDRESS;
     objc_runtime->GetValuesForGlobalCFBooleans(cf_true, cf_false);
     if (valobj_ptr_value == cf_true) {
       stream.PutCString("YES");
       return true;
     }
     if (valobj_ptr_value == cf_false) {

lldb/trunk/source/Plugins/Language/ObjC/NSArray.cpp

 bool lldb_private::formatters::NSArraySummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   static ConstString g_TypeHint("NSArray");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())
lldb_private::formatters::NSArraySyntheticFrontEndCreator(
     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
   if (!valobj_sp)
     return nullptr;
 
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return nullptr;
   AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
-      process_sp->GetObjCLanguageRuntime());
+      ObjCLanguageRuntime::Get(*process_sp));
   if (!runtime)
     return nullptr;
 
   CompilerType valobj_type(valobj_sp->GetCompilerType());
   Flags flags(valobj_type.GetTypeInfo());
 
   if (flags.IsClear(eTypeIsPointer)) {
     Status error;

lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.cpp

 template <bool name_entries>
 bool lldb_private::formatters::NSDictionarySummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   static ConstString g_TypeHint("NSDictionary");
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime =  process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return nullptr;
-  AppleObjCRuntime *runtime =
-      llvm::dyn_cast_or_null<AppleObjCRuntime>(process_sp->GetObjCLanguageRuntime());
+  AppleObjCRuntime *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
+      ObjCLanguageRuntime::Get(*process_sp));
   if (!runtime)
     return nullptr;
 
   CompilerType valobj_type(valobj_sp->GetCompilerType());
   Flags flags(valobj_type.GetTypeInfo());
 
   if (flags.IsClear(eTypeIsPointer)) {
     Status error;

lldb/trunk/source/Plugins/Language/ObjC/NSError.cpp

 };
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSErrorSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return nullptr;
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
   if (!runtime)
     return nullptr;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(*valobj_sp.get()));
 
   if (!descriptor.get() || !descriptor->IsValid())
     return nullptr;

lldb/trunk/source/Plugins/Language/ObjC/NSException.cpp

 };
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSExceptionSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return nullptr;
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
   if (!runtime)
     return nullptr;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(*valobj_sp.get()));
 
   if (!descriptor.get() || !descriptor->IsValid())
     return nullptr;

lldb/trunk/source/Plugins/Language/ObjC/NSIndexPath.cpp

bool Update() override {
 
     static ConstString g__indexes("_indexes");
     static ConstString g__length("_length");
 
     ProcessSP process_sp = m_backend.GetProcessSP();
     if (!process_sp)
       return false;
 
-    ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+    ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
     if (!runtime)
       return false;
 
     ObjCLanguageRuntime::ClassDescriptorSP descriptor(
         runtime->GetClassDescriptor(m_backend));
 
     if (!descriptor.get() || !descriptor->IsValid())

lldb/trunk/source/Plugins/Language/ObjC/NSSet.cpp

 bool lldb_private::formatters::NSSetSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   static ConstString g_TypeHint("NSSet");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor || !descriptor->IsValid())

 }
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSSetSyntheticFrontEndCreator(
     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)
     return nullptr;
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
   if (!runtime)
     return nullptr;
 
   CompilerType valobj_type(valobj_sp->GetCompilerType());
   Flags flags(valobj_type.GetTypeInfo());
 
   if (flags.IsClear(eTypeIsPointer)) {
     Status error;

lldb/trunk/source/Plugins/Language/ObjC/NSString.cpp

bool lldb_private::formatters::NSStringSummaryProvider(
     ValueObject &valobj, Stream &stream,
     const TypeSummaryOptions &summary_options) {
   static ConstString g_TypeHint("NSString");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
-  ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
 
   ObjCLanguageRuntime::ClassDescriptorSP descriptor(
       runtime->GetClassDescriptor(valobj));
 
   if (!descriptor.get() || !descriptor->IsValid())

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.cpp

ObjCLanguage::GetPossibleFormattersMatches(ValueObject &valobj,
   bool canBeObjCDynamic =
       compiler_type.IsPossibleDynamicType(nullptr, check_cpp, check_objc);
 
   if (canBeObjCDynamic) {
     do {
       lldb::ProcessSP process_sp = valobj.GetProcessSP();
       if (!process_sp)
         break;
-      ObjCLanguageRuntime *runtime = process_sp->GetObjCLanguageRuntime();
+      ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
       if (runtime == nullptr)
         break;
       ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp(
           runtime->GetClassDescriptor(valobj));
       if (!objc_class_sp)
         break;
       if (ConstString name = objc_class_sp->GetClassName())
         result.push_back(name);
std::unique_ptr<Language::TypeScavenger> ObjCLanguage::GetTypeScavenger() {
   class ObjCRuntimeScavenger : public Language::TypeScavenger {
   protected:
     bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
                    ResultSet &results) override {
       bool result = false;
 
       Process *process = exe_scope->CalculateProcess().get();
       if (process) {
-        const bool create_on_demand = false;
-        auto objc_runtime = process->GetObjCLanguageRuntime(create_on_demand);
+        auto objc_runtime = ObjCLanguageRuntime::Get(*process);
         if (objc_runtime) {
           auto decl_vendor = objc_runtime->GetDeclVendor();
           if (decl_vendor) {
             std::vector<clang::NamedDecl *> decls;
             ConstString name(key);
             decl_vendor->FindDecls(name, true, UINT32_MAX, decls);
             for (auto decl : decls) {
               if (decl) {

lldb/trunk/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"
bool DoExecute(Args &command, CommandReturnObject &result) override {
     default: {
       result.AppendError("please provide 0 or 1 arguments");
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
     }
 
     Process *process = m_exe_ctx.GetProcessPtr();
-    ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
+    ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
     if (objc_runtime) {
       auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
       auto iterator = iterators_pair.first;
       auto &std_out = result.GetOutputStream();
       for (; iterator != iterators_pair.second; iterator++) {
         if (iterator->second) {
           const char *class_name =
               iterator->second->GetClassName().AsCString("<unknown>");
bool DoExecute(Args &command, CommandReturnObject &result) override {
     if (command.GetArgumentCount() == 0) {
       result.AppendError("this command requires arguments");
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
 
     Process *process = m_exe_ctx.GetProcessPtr();
     ExecutionContext exe_ctx(process);
-    ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
+    ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
     if (objc_runtime) {
       ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor =
           objc_runtime->GetTaggedPointerVendor();
       if (tagged_ptr_vendor) {
         for (size_t i = 0; i < command.GetArgumentCount(); i++) {
           const char *arg_str = command.GetArgumentAtIndex(i);
           if (!arg_str)
             continue;

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

bool AppleObjCTrampolineHandler::AppleObjCVTables::InitializeVTableSymbols() {
   if (process_sp) {
     Target &target = process_sp->GetTarget();
 
     const ModuleList &target_modules = target.GetImages();
     std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     size_t num_modules = target_modules.GetSize();
     if (!m_objc_module_sp) {
       for (size_t i = 0; i < num_modules; i++) {
-        if (process_sp->GetObjCLanguageRuntime()->IsModuleObjCLibrary(
+        if (ObjCLanguageRuntime::Get(*process_sp)
+                ->IsModuleObjCLibrary(
                     target_modules.GetModuleAtIndexUnlocked(i))) {
           m_objc_module_sp = target_modules.GetModuleAtIndexUnlocked(i);
           break;
         }
       }
     }
 
     if (m_objc_module_sp) {
       ConstString trampoline_name("gdb_objc_trampolines");
if (found_it) {
 
     if (isa_addr != LLDB_INVALID_ADDRESS) {
       if (log) {
         log->Printf("Resolving call for class - 0x%" PRIx64
                     " and selector - 0x%" PRIx64,
                     isa_addr, sel_addr);
       }
       ObjCLanguageRuntime *objc_runtime =
-          thread.GetProcess()->GetObjCLanguageRuntime();
+          ObjCLanguageRuntime::Get(*thread.GetProcess());
       assert(objc_runtime != nullptr);
 
       impl_addr = objc_runtime->LookupInMethodCache(isa_addr, sel_addr);
     }
 
     if (impl_addr != LLDB_INVALID_ADDRESS) {
       // Yup, it was in the cache, so we can run to that address directly.
 

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

if (m_trampoline_handler->AddrIsMsgForward(target_addr)) {
       return false;
     }
 
     if (log)
       log->Printf("Running to ObjC method implementation: 0x%" PRIx64,
                   target_addr);
 
     ObjCLanguageRuntime *objc_runtime =
-        GetThread().GetProcess()->GetObjCLanguageRuntime();
+        ObjCLanguageRuntime::Get(*GetThread().GetProcess());
     assert(objc_runtime != nullptr);
     objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
     if (log)
       log->Printf("Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
                   "} = addr=0x%" PRIx64 " to cache.",
                   m_isa_addr, m_sel_addr, target_addr);
 
     // Extract the target address from the value:

lldb/trunk/source/Symbol/ClangASTContext.cpp

case clang::Type::Record:
         return None;
       break;
 
     case clang::Type::ObjCInterface:
     case clang::Type::ObjCObject: {
       ExecutionContext exe_ctx(exe_scope);
       Process *process = exe_ctx.GetProcessPtr();
       if (process) {
-        ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
+        ObjCLanguageRuntime *objc_runtime = ObjCLanguageRuntime::Get(*process);
         if (objc_runtime) {
           uint64_t bit_size = 0;
           if (objc_runtime->GetTypeBitSize(
                   CompilerType(getASTContext(), qual_type), bit_size))
             return bit_size;
         }
       } else {
         static bool g_printed = false;
if (idx_is_valid && GetCompleteType(type)) {
                 // this class. So if we have a process around that we can ask
                 // about this object, do so.
                 child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
                 Process *process = nullptr;
                 if (exe_ctx)
                   process = exe_ctx->GetProcessPtr();
                 if (process) {
                   ObjCLanguageRuntime *objc_runtime =
-                      process->GetObjCLanguageRuntime();
+                      ObjCLanguageRuntime::Get(*process);
                   if (objc_runtime != nullptr) {
                     CompilerType parent_ast_type(getASTContext(),
                                                  parent_qual_type);
                     child_byte_offset = objc_runtime->GetByteOffsetForIvar(
                         parent_ast_type, ivar_decl->getNameAsString().c_str());
                   }
                 }
 

lldb/trunk/source/Target/Process.cpp

 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 #include "lldb/Target/JITLoader.h"
 #include "lldb/Target/JITLoaderList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/MemoryHistory.h"
 #include "lldb/Target/MemoryRegionInfo.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
if (runtime)
     // for example, CPPLanguageRuntime will support eLanguageTypeC_plus_plus,
     // eLanguageTypeC_plus_plus_03, etc. Because of this, we should get the
     // primary language type and make sure that our runtime supports it.
     assert(runtime->GetLanguageType() == Language::GetPrimaryLanguage(language));
 
   return runtime;
 }
 
-ObjCLanguageRuntime *Process::GetObjCLanguageRuntime(bool retry_if_null) {
-  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
-  LanguageRuntime *runtime =
-      GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
-  return llvm::cast_or_null<ObjCLanguageRuntime>(runtime);
-}
-
 bool Process::IsPossibleDynamicValue(ValueObject &in_value) {
   if (m_finalizing)
     return false;
 
   if (in_value.IsDynamic())
     return false;
   LanguageType known_type = in_value.GetObjectRuntimeLanguage();