Factor out SwiftLanguageRuntimeImpl::ForEachSuperClassTypeInfo()

Author: adrian-prantl

lldb/source/Target/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -858,6 +858,8 @@ SwiftLanguageRuntimeImpl::GetMemberVariableOffsetRemoteAST(
 llvm::Optional<uint64_t> SwiftLanguageRuntimeImpl::GetMemberVariableOffsetRemoteMirrors(
     CompilerType instance_type, ValueObject *instance, ConstString member_name,
     Status *error) {
+  LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
+            "using remote mirrors");
   auto *ts = llvm::dyn_cast_or_null<TypeSystemSwiftTypeRef>(
       instance_type.GetTypeSystem());
   if (!ts) {
@@ -866,72 +868,53 @@ llvm::Optional<uint64_t> SwiftLanguageRuntimeImpl::GetMemberVariableOffsetRemote
     return {};
   }
 
-  // Try remote mirrors.
-  LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
-            "[GetMemberVariableOffsetRemoteMirrors] using remote mirrors");
-  if (const swift::reflection::TypeInfo *type_info = GetTypeInfo(
-          instance_type,
-          instance ? instance->GetExecutionContextRef().GetFrameSP().get()
-                   : nullptr)) {
-    auto record_type_info =
-        llvm::dyn_cast<swift::reflection::RecordTypeInfo>(type_info);
-    if (record_type_info) {
-      // Handle tuples.
-      LLDB_LOGF(
-          GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
-          "[GetMemberVariableOffsetRemoteMirrors] using record type info");
-      if (record_type_info->getRecordKind() ==
-          swift::reflection::RecordKind::Tuple) {
-        unsigned tuple_idx;
-        if (member_name.GetStringRef().getAsInteger(10, tuple_idx) ||
-            tuple_idx >= record_type_info->getNumFields()) {
-          if (error)
-            error->SetErrorString("tuple index out of bounds");
-          return {};
-        }
-        return record_type_info->getFields()[tuple_idx].Offset;
-      }
-
-      // Handle other record types.
-      for (auto &field : record_type_info->getFields()) {
-        if (ConstString(field.Name) == member_name)
-          return field.Offset;
-      }
-    }
-  }
-
-  lldb::addr_t pointer = instance->GetPointerValue();
-  auto *reflection_ctx = GetReflectionContext();
-  if (!reflection_ctx)
-    return {};
-
-  auto find_field =
-      [&](const swift::reflection::TypeInfo *ti) -> llvm::Optional<uint64_t> {
-    auto class_type_info =
-        llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(ti);
-    if (class_type_info) {
-      for (auto &field : class_type_info->getFields()) {
-        if (ConstString(field.Name) == member_name)
-          return field.Offset;
+  // Try the static type metadata.
+  auto frame = instance ? instance->GetExecutionContextRef().GetFrameSP().get()
+                        : nullptr;
+  if (auto *ti = llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(
+          GetTypeInfo(instance_type, frame))) {
+    auto fields = ti->getFields();
+    LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
+              "using record type info");
+
+    // Handle tuples.
+    if (ti->getRecordKind() == swift::reflection::RecordKind::Tuple) {
+      unsigned tuple_idx;
+      if (member_name.GetStringRef().getAsInteger(10, tuple_idx) ||
+          tuple_idx >= ti->getNumFields()) {
+        if (error)
+          error->SetErrorString("tuple index out of bounds");
+        return {};
       }
+      return fields[tuple_idx].Offset;
     }
-    return {};
-  };
-
-  LLDBTypeInfoProvider provider(*this, *ts);
-  auto md_ptr = reflection_ctx->readMetadataFromInstance(pointer);
-  LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
-            "[GetMemberVariableOffsetRemoteMirrors] using instance type info");
-  while (md_ptr && *md_ptr) {
-    if (auto offset =
-            find_field(reflection_ctx->getMetadataTypeInfo(*md_ptr, &provider)))
-      return offset;
 
-    // Continue with the base class.
-    md_ptr = reflection_ctx->readSuperClassFromClassMetadata(*md_ptr);
+    // Handle other record types.
+   for (auto &field : fields)
+      if (StringRef(field.Name) == member_name.GetStringRef())
+        return field.Offset;
   }
 
-  return {};
+  // Try the instance type metadata.
+  bool did_log = false;
+  llvm::Optional<uint64_t> result;
+  if (instance)
+    ForEachSuperClassTypeInfo(
+        *instance, [&](const swift::reflection::RecordTypeInfo &ti) -> bool {
+          if (!did_log) {
+            did_log = true;
+            LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
+                      "using instance type info");
+          }
+          for (auto &field : ti.getFields())
+            if (StringRef(field.Name) == member_name.GetStringRef()) {
+              result = field.Offset;
+              return true;
+            }
+          return false;
+        });
+
+  return result;
 }
 
 
@@ -994,6 +977,44 @@ llvm::Optional<uint64_t> SwiftLanguageRuntimeImpl::GetMemberVariableOffset(
   }
   return offset;
 }
+
+bool SwiftLanguageRuntimeImpl::ForEachSuperClassTypeInfo(
+    ValueObject &instance,
+    std::function<bool(const swift::reflection::RecordTypeInfo &rti)> fn) {
+  lldb::addr_t pointer = instance.GetPointerValue();
+  auto *reflection_ctx = GetReflectionContext();
+  if (!reflection_ctx)
+    return false;
+
+  auto *ts = llvm::dyn_cast_or_null<TypeSystemSwiftTypeRef>(
+      instance.GetCompilerType().GetTypeSystem());
+  if (!ts)
+    return false;
+
+  LLDBTypeInfoProvider provider(*this, *ts);
+  auto md_ptr = reflection_ctx->readMetadataFromInstance(pointer);
+  if (!md_ptr)
+    return false;
+
+  // Class object.
+  LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES),
+            "found RecordTypeInfo for instance");
+  while (md_ptr && *md_ptr) {
+    auto *ti = reflection_ctx->getMetadataTypeInfo(*md_ptr, &provider);
+    if (auto *class_type_info =
+            llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(ti)) {
+      if (fn(*class_type_info))
+        return true;
+    }
+
+    // Continue with the base class.
+    md_ptr = reflection_ctx->readSuperClassFromClassMetadata(*md_ptr);
+  }
+  return false;
+}
+
+
+
 bool SwiftLanguageRuntime::IsSelf(Variable &variable) {
   // A variable is self if its name if "self", and it's either a
   // function argument or a local variable and it's scope is a

lldb/source/Target/SwiftLanguageRuntimeImpl.h

@@ -162,6 +162,14 @@ class SwiftLanguageRuntimeImpl {
   const swift::reflection::TypeRef *GetTypeRef(CompilerType type,
                                                Module *module = nullptr);
 
+  /// If \p instance points to a Swift object, retrieve its
+  /// RecordTypeInfo pass it to the callback \p fn. Repeat the process
+  /// with all superclasses. If \p fn returns \p true, early exit and
+  /// return \ptrue. Otherwise return \p false.
+  bool ForEachSuperClassTypeInfo(
+      ValueObject &instance,
+      std::function<bool(const swift::reflection::RecordTypeInfo &rti)> fn);
+
   // Classes that inherit from SwiftLanguageRuntime can see and modify these
   Value::ValueType GetValueType(Value::ValueType static_value_type,
                                 CompilerType static_type,