Detect unbreakable metadata dependency cycles and abort with a diagnostic.

Author: rjmccall

include/swift/Runtime/Debug.h

@@ -167,7 +167,7 @@ struct RuntimeErrorDetails {
   uintptr_t framesToSkip;
 
   // Address of some associated object (if there's any).
-  void *memoryAddress;
+  const void *memoryAddress;
 
   // A structure describing an extra thread (and its stack) that is related.
   struct Thread {

include/swift/Runtime/Metadata.h

@@ -195,25 +195,45 @@ using Metadata = TargetMetadata<InProcess>;
 /// For performance, functions returning this type should use SWIFT_CC so
 /// that the components are returned as separate values.
 struct MetadataResponse {
-  /// For metadata access functions, this is the requested metadata.
-  ///
-  /// For metadata initialization functions, this is either null,
-  /// indicating that initialization was successful, or a metadata on
-  /// which initialization depends for further progress.
+  /// The requested metadata.
   const Metadata *Value;
 
-  /// For metadata access functions, this is the current state of the
-  /// metadata returned.  Always use this instead of trying to inspect
-  /// the metadata directly; an incomplete metadata may be getting
-  /// initialized concurrently.  This can generally be ignored if the
-  /// metadata request was for abstract metadata or if the request is
-  /// blocking.
-  ///
-  /// For metadata initialization functions, this is the state that the
-  /// given metadata needs to be in before initialization can continue.
+  /// The current state of the metadata returned.  Always use this
+  /// instead of trying to inspect the metadata directly to see if it
+  /// satisfies the request.  An incomplete metadata may be getting
+  /// initialized concurrently.  But this can generally be ignored if
+  /// the metadata request was for abstract metadata or if the request
+  /// is blocking.
   MetadataState State;
 };
-using MetadataDependency = MetadataResponse;
+
+/// A dependency on the metadata progress of other type, indicating that
+/// initialization of a metadata cannot progress until another metadata
+/// reaches a particular state.
+///
+/// For performance, functions returning this type should use SWIFT_CC so
+/// that the components are returned as separate values.
+struct MetadataDependency {
+  /// Either null, indicating that initialization was successful, or
+  /// a metadata on which initialization depends for further progress.
+  const Metadata *Value;
+
+  /// The state that Metadata needs to be in before initialization
+  /// can continue.
+  MetadataState Requirement;
+
+  MetadataDependency() : Value(nullptr) {}
+  MetadataDependency(const Metadata *metadata, MetadataState requirement)
+    : Value(metadata), Requirement(requirement) {}
+
+  explicit operator bool() const { return Value != nullptr; }
+
+  bool operator==(MetadataDependency other) const {
+    assert(Value && other.Value);
+    return Value == other.Value &&
+           Requirement == other.Requirement;
+  }
+};
 
 template <typename Runtime> struct TargetProtocolConformanceDescriptor;
 

stdlib/public/runtime/Metadata.cpp

@@ -243,23 +243,18 @@ namespace {
 
         // If this failed with a dependency, infer the current metadata state
         // and return.
-        if (dependency.Value) {
-          return { inferStateForMetadata(metadata),
-                   dependency.State, dependency.Value };
+        if (dependency) {
+          return { inferStateForMetadata(metadata), dependency };
         }
       }
 
       // Check for transitive completeness.
-      auto dependency =
-        checkTransitiveCompleteness(metadata, description);
-      if (dependency.Value) {
-        return { PrivateMetadataState::NonTransitiveComplete,
-                 dependency.State, dependency.Value };
+      if (auto dependency = checkTransitiveCompleteness(metadata, description)){
+        return { PrivateMetadataState::NonTransitiveComplete, dependency };
       }
 
       // We're done.
-      return { PrivateMetadataState::Complete,
-               MetadataState::Complete, nullptr };
+      return { PrivateMetadataState::Complete, MetadataDependency() };
     }
   };
 } // end anonymous namespace
@@ -3333,24 +3328,24 @@ static Result performOnMetadataCache(const Metadata *metadata,
 }
 
 bool swift::addToMetadataQueue(MetadataCompletionQueueEntry *queueEntry,
-                               const Metadata *dependency,
-                               MetadataState dependencyRequirement) {
+                               MetadataDependency dependency) {
   struct EnqueueCallbacks {
     MetadataCompletionQueueEntry *QueueEntry;
+    MetadataDependency Dependency;
 
     bool forGenericMetadata(const Metadata *metadata,
                             const TypeContextDescriptor *description,
                             GenericMetadataCache &cache,
                             MetadataCacheKey key) && {
-      return cache.enqueue(key, QueueEntry);
+      return cache.enqueue(key, QueueEntry, Dependency);
     }
 
     bool forOtherMetadata(const Metadata *metadata) && {
       swift_runtime_unreachable("metadata should always be complete");
     }
-  } callbacks = { queueEntry };
+  } callbacks = { queueEntry, dependency };
 
-  return performOnMetadataCache<bool>(dependency, std::move(callbacks));
+  return performOnMetadataCache<bool>(dependency.Value, std::move(callbacks));
 }
 
 void swift::resumeMetadataCompletion(MetadataCompletionQueueEntry *queueEntry) {
@@ -3553,6 +3548,114 @@ checkTransitiveCompleteness(const Metadata *initialType,
   return { nullptr, MetadataState::Complete };
 }
 
+/// Diagnose a metadata dependency cycle.
+LLVM_ATTRIBUTE_NORETURN
+static void diagnoseMetadataDependencyCycle(const Metadata *start,
+                                            ArrayRef<MetadataDependency> links){
+  assert(start == links.back().Value);
+
+  std::string diagnostic =
+    "runtime error: unresolvable type metadata dependency cycle detected\n  ";
+  diagnostic += nameForMetadata(start);
+
+  for (auto &link : links) {
+    // If the diagnostic gets too large, just cut it short.
+    if (diagnostic.size() >= 128 * 1024) {
+      diagnostic += "\n  (limiting diagnostic text at 128KB)";
+      break;
+    }
+
+    diagnostic += "\n  depends on ";
+
+    switch (link.Requirement) {
+    case MetadataState::Complete:
+      diagnostic += "transitive completion of ";
+      break;
+    case MetadataState::NonTransitiveComplete:
+      diagnostic += "completion of ";
+      break;
+    case MetadataState::LayoutComplete:
+      diagnostic += "layout of ";
+      break;
+    case MetadataState::Abstract:
+      diagnostic += "<corruption> of ";
+      break;
+    }
+
+    diagnostic += nameForMetadata(link.Value);
+  }
+
+  diagnostic += "\nAborting!\n";
+
+  if (_swift_shouldReportFatalErrorsToDebugger()) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wc99-extensions"
+    RuntimeErrorDetails details = {
+      .version = RuntimeErrorDetails::currentVersion,
+      .errorType = "type-metadata-cycle",
+      .currentStackDescription = "fetching metadata", // TODO?
+      .framesToSkip = 1, // skip out to the check function
+      .memoryAddress = start
+      // TODO: describe the cycle using notes instead of one huge message?
+    };
+#pragma GCC diagnostic pop
+
+    _swift_reportToDebugger(RuntimeErrorFlagFatal, diagnostic.c_str(),
+                            &details);
+  }
+
+  fatalError(0, diagnostic.c_str());
+}
+
+/// Check whether the given metadata dependency is satisfied, and if not,
+/// return its current dependency, if one exists.
+static MetadataDependency
+checkMetadataDependency(MetadataDependency dependency) {
+  struct IsIncompleteCallbacks {
+    MetadataState Requirement;
+    MetadataDependency forGenericMetadata(const Metadata *type,
+                                          const TypeContextDescriptor *desc,
+                                          GenericMetadataCache &cache,
+                                          MetadataCacheKey key) && {
+      return cache.checkDependency(key, Requirement);
+    }
+
+    MetadataDependency forOtherMetadata(const Metadata *type) && {
+      return MetadataDependency();
+    }
+  } callbacks = { dependency.Requirement };
+
+  return performOnMetadataCache<MetadataDependency>(dependency.Value,
+                                                    std::move(callbacks));
+}
+
+/// Check for an unbreakable metadata-dependency cycle.
+void swift::checkMetadataDependencyCycle(const Metadata *startMetadata,
+                                         MetadataDependency firstLink,
+                                         MetadataDependency secondLink) {
+  std::vector<MetadataDependency> links;
+  auto checkNewLink = [&](MetadataDependency newLink) {
+    links.push_back(newLink);
+    if (newLink.Value == startMetadata)
+      diagnoseMetadataDependencyCycle(startMetadata, links);
+    for (auto i = links.begin(), e = links.end() - 1; i != e; ++i) {
+      if (i->Value == newLink.Value) {
+        auto next = i + 1;
+        diagnoseMetadataDependencyCycle(i->Value,
+                                llvm::makeArrayRef(&*next, links.end() - next));
+      }
+    }
+  };
+
+  checkNewLink(firstLink);
+  checkNewLink(secondLink);
+  while (true) {
+    auto newLink = checkMetadataDependency(links.back());
+    if (!newLink) return;
+    checkNewLink(newLink);
+  }
+}
+
 /***************************************************************************/
 /*** Allocator implementation **********************************************/
 /***************************************************************************/