[lldb] Identify Swift-implemented ObjC classes

[kastiglione]

Summary

Classes implemented in Swift can be exposed to ObjC. For those classes, the ObjC
metadata is incomplete (the types of the ivars are incomplete), but as one would expect
the Swift metadata is complete. In such cases, the Swift runtime should be consulted
first when determining the dynamic type of a value.

[bulbazord]

lldb/source/Core/ValueObjectDynamicValue.cpp

10

Is there a way we can avoid using a plugin in non-plugin code?

[kastiglione]

lldb/source/Core/ValueObjectDynamicValue.cpp

118–122

@bulbazord this is where it's used, to work with ClassDescriptor which is part of the ObjCLanguageRuntime. I don't think it would make sense to lift that into the generic LangaugeRuntime. What other courses might there be?

[aprantl]

lldb/source/Core/ValueObjectDynamicValue.cpp

152

This is a bit of a layering violation. Could the ObjC language runtime perform this check in GetDynamicTypeAndAddress and dispatch to the Swift runtime there?

If you do this, we need to ensure we can't get into an infinite loop between the runtimes.

Alternatively, we could add a virtual GetPreferredLanguageRuntime() method to LanguageRuntime that we call here, maybe?

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

90

Can you add a Doxygen commen?
/// Determine whether this class is implemented in Swift.

[kastiglione]

Refactor for better API layering

[kastiglione]

@bulbazord @augusto2112 hopefully this is a quick review.

[bulbazord]

My concerns have been addressed, LGTM.

[kastiglione]

Change bool IsSwift() to LanguageType GetImplementationLanguage()

[kastiglione]

Redo ValueObjectDynamicValue::UpdateValue changes based on upstream testing

lldb/include/lldb/Target/LanguageRuntime.h

 public:
   static LanguageRuntime *FindPlugin(Process *process,
                                      lldb::LanguageType language);
 
   static void InitializeCommands(CommandObject *parent);
 
   virtual lldb::LanguageType GetLanguageType() const = 0;
 
+  /// Return the preferred language runtime instance, which in most cases will
+  /// be the current instance.
+  virtual LanguageRuntime *GetPreferredLanguageRuntime(ValueObject &in_value) {
+    return nullptr;
+  }
+
   virtual bool GetObjectDescription(Stream &str, ValueObject &object) = 0;
 
   virtual bool GetObjectDescription(Stream &str, Value &value,
                                     ExecutionContextScope *exe_scope) = 0;
 
   // this call should return true if it could set the name and/or the type
   virtual bool GetDynamicTypeAndAddress(ValueObject &in_value,
                                         lldb::DynamicValueType use_dynamic,

lldb/source/Core/ValueObjectDynamicValue.cpp

 //===-- ValueObjectDynamicValue.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 "lldb/Core/ValueObjectDynamicValue.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"

 
 bool ValueObjectDynamicValue::UpdateValue() {
   SetValueIsValid(false);
   m_error.Clear();
 
   if (!m_parent->UpdateValueIfNeeded(false)) {
     // The dynamic value failed to get an error, pass the error along
     if (m_error.Success() && m_parent->GetError().Fail())
       m_error = m_parent->GetError();
     return false;
   }
 
   // Setting our type_sp to NULL will route everything back through our parent
   // which is equivalent to not using dynamic values.
   if (m_use_dynamic == lldb::eNoDynamicValues) {
     m_dynamic_type_info.Clear();
     return true;
   }
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Target *target = exe_ctx.GetTargetPtr();
bool ValueObjectDynamicValue::UpdateValue() {
   Value::ValueType value_type;
 
   LanguageRuntime *runtime = nullptr;
 
   lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage();
   if (known_type != lldb::eLanguageTypeUnknown &&
       known_type != lldb::eLanguageTypeC) {
     runtime = process->GetLanguageRuntime(known_type);
-    if (runtime)
+    if (auto *preferred_runtime =
+            runtime->GetPreferredLanguageRuntime(*m_parent)) {
+      // Try the preferred runtime first.
+      found_dynamic_type = preferred_runtime->GetDynamicTypeAndAddress(
+          *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,
+          value_type);
+      if (found_dynamic_type)
+        // Set the operative `runtime` for later use in this function.
+        runtime = preferred_runtime;
+    }
+    if (!found_dynamic_type)
+      // Fallback to the runtime for `known_type`.
       found_dynamic_type = runtime->GetDynamicTypeAndAddress(
           *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,
           value_type);
   } else {
     runtime = process->GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus);
     if (runtime)
       found_dynamic_type = runtime->GetDynamicTypeAndAddress(
           *m_parent, m_use_dynamic, class_type_or_name, dynamic_address,

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 LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCCLASSDESCRIPTORV2_H
 #define LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCCLASSDESCRIPTORV2_H
 
 #include <mutex>
 
 #include "AppleObjCRuntimeV2.h"
+#include "lldb/lldb-enumerations.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;
 
   ConstString GetClassName() override;
 
   ObjCLanguageRuntime::ClassDescriptorSP GetSuperclass() override;
 
   ObjCLanguageRuntime::ClassDescriptorSP GetMetaclass() const override;
 
   bool IsValid() override {
     return true; // any Objective-C v2 runtime class descriptor we vend is valid
   }
 
+  lldb::LanguageType GetImplementationLanguage() const override;
+
   // a custom descriptor is used for tagged pointers
   bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr,
                             uint64_t *value_bits = nullptr,
                             uint64_t *payload = nullptr) override {
     return false;
   }
 
   bool GetTaggedPointerInfoSigned(uint64_t *info_bits = nullptr,

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

 //===-- AppleObjCClassDescriptorV2.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 "AppleObjCClassDescriptorV2.h"
 
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Target/ABI.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool ClassDescriptorV2::Read_objc_class(
     Process *process, std::unique_ptr<objc_class_t> &objc_class) const {
   objc_class = std::make_unique<objc_class_t>();
 
if (!Read_class_row(process, *objc_class, class_ro, class_rw))
       return 0;
 
     return class_ro->m_instanceSize;
   }
 
   return 0;
 }
 
+// From the ObjC runtime.
+static uint8_t IS_SWIFT_STABLE = 1U << 1;
+
+LanguageType ClassDescriptorV2::GetImplementationLanguage() const {
+  std::unique_ptr<objc_class_t> objc_class;
+  if (auto *process = m_runtime.GetProcess())
+    if (Read_objc_class(process, objc_class))
+      if (objc_class->m_flags & IS_SWIFT_STABLE)
+        return lldb::eLanguageTypeSwift;
+
+  return lldb::eLanguageTypeObjC;
+}
+
 ClassDescriptorV2::iVarsStorage::iVarsStorage() : m_ivars(), m_mutex() {}
 
 size_t ClassDescriptorV2::iVarsStorage::size() { return m_ivars.size(); }
 
 ClassDescriptorV2::iVarDescriptor &ClassDescriptorV2::iVarsStorage::
 operator[](size_t idx) {
   return m_ivars[idx];
 }

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

public:
 
   static void Terminate();
 
   static lldb_private::LanguageRuntime *
   CreateInstance(Process *process, lldb::LanguageType language);
 
   static llvm::StringRef GetPluginNameStatic() { return "apple-objc-v2"; }
 
+  LanguageRuntime *GetPreferredLanguageRuntime(ValueObject &in_value) override;
+
   static char ID;
 
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || AppleObjCRuntime::isA(ClassID);
   }
 
   static bool classof(const LanguageRuntime *runtime) {
     return runtime->isA(&ID);

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

 #include "lldb/Symbol/CompilerType.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/DynamicLoader.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/LanguageRuntime.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/LLDBLog.h"
static const ConstString g_objc_getRealizedClassList_trylock(
       "_objc_getRealizedClassList_trylock");
   m_has_objc_copyRealizedClassList = HasSymbol(g_objc_copyRealizedClassList);
   m_has_objc_getRealizedClassList_trylock =
       HasSymbol(g_objc_getRealizedClassList_trylock);
   WarnIfNoExpandedSharedCache();
   RegisterObjCExceptionRecognizer(process);
 }
 
+LanguageRuntime *
+AppleObjCRuntimeV2::GetPreferredLanguageRuntime(ValueObject &in_value) {
+  if (auto process_sp = in_value.GetProcessSP()) {
+    assert(process_sp.get() == m_process);
+    if (auto descriptor_sp = GetNonKVOClassDescriptor(in_value)) {
+      LanguageType impl_lang = descriptor_sp->GetImplementationLanguage();
+      if (impl_lang != eLanguageTypeUnknown)
+        return process_sp->GetLanguageRuntime(impl_lang);
+    }
+  }
+  return nullptr;
+}
+
 bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
     Value::ValueType &value_type) {
   // We should never get here with a null process...
   assert(m_process != nullptr);
 
   // The Runtime is attached to a particular process, you shouldn't pass in a

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

 
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/ThreadSafeDenseMap.h"
+#include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;
 
 namespace lldb_private {
 
 class TypeSystemClang;
 class UtilityFunction;
virtual bool IsCFType() {
         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);
     }
 
+    /// Determine whether this class is implemented in Swift.
+    virtual lldb::LanguageType GetImplementationLanguage() const {
+      return lldb::eLanguageTypeObjC;
+    }
+
     virtual bool IsValid() = 0;
 
     /// There are two routines in the ObjC runtime that tagged pointer clients
     /// can call to get the value from their tagged pointer, one that retrieves
     /// it as an unsigned value and one a signed value.  These two
     /// GetTaggedPointerInfo methods mirror those two ObjC runtime calls.
     /// @{
     virtual bool GetTaggedPointerInfo(uint64_t *info_bits = nullptr,