Merge pull request swiftlang#15672 from rjmccall/cyclic-metadata-4.2

[4.2] Finish the first stage of incomplete type metadata support

Author: rjmccall

include/swift/ABI/MetadataValues.h

@@ -1385,28 +1385,74 @@ class GenericMetadataPatternFlags : public FlagSet<uint32_t> {
 
 /// The public state of a metadata.
 enum class MetadataState : size_t {
-  /// A request for fully-completed metadata.  The metadata must be
-  /// prepared for all supported type operations.  This is a superset
-  /// of the requirements of LayoutComplete.
+  // The values of this enum are set up to give us some future flexibility
+  // in adding states.  The compiler emits unsigned comparisons against
+  // these values, so adding states that aren't totally ordered with at
+  // least the existing values will pose a problem; but we also use a
+  // gradually-shrinking bitset in case it's useful to track states as
+  // separate capabilities.  Specific values have been chosen so that a
+  // MetadataRequest of 0 represents a blocking complete request, which
+  // is the most likely request from ordinary code.  The total size of a
+  // state is kept to 8 bits so that a full request, even with additional
+  // flags, can be materialized as a single immediate on common ISAs, and
+  // so that the state can be extracted with a byte truncation.
+  // The spacing between states reflects guesswork about where new
+  // states/capabilities are most likely to be added.
+
+  /// The metadata is fully complete.  By definition, this is the
+  /// end-state of all metadata.  Generally, metadata is expected to be
+  /// complete before it can be passed to arbitrary code, e.g. as
+  /// a generic argument to a function or as a metatype value.
   ///
-  /// For example, a class must be ready for subclassing and instantiation:
-  /// it must have a completed instance layout and (under ObjCInterop)
-  /// must have been realized by the Objective-C runtime.
-  Complete,
-
-  /// A request for metadata that can be used for type layout; that is,
-  /// the type's value witness table must be completely initialized.
-  LayoutComplete,
-
-  /// A request for a metadata pointer that fully identifies the type.
-  /// Basic type structure, such as the type context descriptor and the
-  /// list of generic arguments, should have been installed, but there is
-  /// no requirement for a valid value witness table.
-  Abstract,
+  /// In addition to the requirements of NonTransitiveComplete, certain
+  /// transitive completeness guarantees must hold.  Most importantly,
+  /// complete nominal type metadata transitively guarantee the completion
+  /// of their stored generic type arguments and superclass metadata.
+  Complete = 0x00,
+
+  /// The metadata is fully complete except for any transitive completeness
+  /// guarantees.
+  ///
+  /// In addition to the requirements of LayoutComplete, metadata in this
+  /// state must be prepared for all basic type operations.  This includes:
+  ///
+  ///   - any sort of internal layout necessary to allocate and work
+  ///     with concrete values of the type, such as the instance layout
+  ///     of a class;
+  ///
+  ///   - any sort of external dynamic registration that might be required
+  ///     for the type, such as the realization of a class by the Objective-C
+  ///     runtime; and
+  ///
+  ///   - the initialization of any other information kept in the metadata
+  ///     object, such as a class's v-table.
+  NonTransitiveComplete = 0x01,
+
+  /// The metadata is ready for the layout of other types that store values
+  /// of this type.
+  ///
+  /// In addition to the requirements of Abstract, metadata in this state
+  /// must have a valid value witness table, meaning that its size,
+  /// alignment, and basic type properties (such as POD-ness) have been
+  /// computed.
+  LayoutComplete = 0x3F,
+
+  /// The metadata has its basic identity established.  It is possible to
+  /// determine what formal type it corresponds to.  Among other things, it
+  /// is possible to use the runtime mangling facilities with the type.
+  ///
+  /// For example, a metadata for a generic struct has a metadata kind,
+  /// a type descriptor, and all of its type arguments.  However, it does not
+  /// necessarily have a meaningful value-witness table.
+  ///
+  /// References to other types that are not part of the type's basic identity
+  /// may not yet have been established.  Most crucially, this includes the
+  /// superclass pointer.
+  Abstract = 0xFF,
 };
 
-/// Something that can be static_asserted in all the places where we depend
-/// on metadata state ordering.
+/// Something that can be static_asserted in all the places where we do
+/// comparisons on metadata states.
 constexpr const bool MetadataStateIsReverseOrdered = true;
 
 /// Return true if the first metadata state is at least as advanced as the

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;
 
@@ -1848,6 +1868,10 @@ struct TargetTupleTypeMetadata : public TargetMetadata<Runtime> {
     OpaqueValue *findIn(OpaqueValue *tuple) const {
       return (OpaqueValue*) (((char*) tuple) + Offset);
     }
+
+    const TypeLayout *getTypeLayout() const {
+      return Type->getTypeLayout();
+    }
   };
 
   Element *getElements() {
@@ -3438,6 +3462,8 @@ class TargetTypeContextDescriptor
     return getFullGenericContextHeader();
   }
 
+  llvm::ArrayRef<GenericParamDescriptor> getGenericParams() const;
+
   /// Return the offset of the start of generic arguments in the nominal
   /// type's metadata. The returned value is measured in sizeof(void*).
   int32_t getGenericArgumentOffset() const;
@@ -3575,6 +3601,7 @@ class TargetClassDescriptor final
   using TrailingGenericContextObjects::getGenericContext;
   using TrailingGenericContextObjects::getGenericContextHeader;
   using TrailingGenericContextObjects::getFullGenericContextHeader;
+  using TrailingGenericContextObjects::getGenericParams;
   using TargetTypeContextDescriptor<Runtime>::getTypeContextDescriptorFlags;
 
   /// The superclass of this class.  This pointer can be interpreted
@@ -3791,6 +3818,7 @@ class TargetStructDescriptor final
   using TrailingGenericContextObjects::getGenericContext;
   using TrailingGenericContextObjects::getGenericContextHeader;
   using TrailingGenericContextObjects::getFullGenericContextHeader;
+  using TrailingGenericContextObjects::getGenericParams;
 
   /// The number of stored properties in the struct.
   /// If there is a field offset vector, this is its length.
@@ -3833,6 +3861,7 @@ class TargetEnumDescriptor final
   using TrailingGenericContextObjects::getGenericContext;
   using TrailingGenericContextObjects::getGenericContextHeader;
   using TrailingGenericContextObjects::getFullGenericContextHeader;
+  using TrailingGenericContextObjects::getGenericParams;
 
   /// The number of non-empty cases in the enum are in the low 24 bits;
   /// the offset of the payload size in the metadata record in words,
@@ -3937,6 +3966,21 @@ TargetTypeContextDescriptor<Runtime>::getFullGenericContextHeader() const {
   }
 }
 
+template <typename Runtime>
+llvm::ArrayRef<GenericParamDescriptor> 
+TargetTypeContextDescriptor<Runtime>::getGenericParams() const {
+  switch (this->getKind()) {
+  case ContextDescriptorKind::Class:
+    return llvm::cast<TargetClassDescriptor<Runtime>>(this)->getGenericParams();
+  case ContextDescriptorKind::Enum:
+    return llvm::cast<TargetEnumDescriptor<Runtime>>(this)->getGenericParams();
+  case ContextDescriptorKind::Struct:
+    return llvm::cast<TargetStructDescriptor<Runtime>>(this)->getGenericParams();
+  default:
+    swift_runtime_unreachable("Not a type context descriptor.");
+  }
+}
+
 /// \brief Fetch a uniqued metadata object for a generic nominal type.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
 MetadataResponse
@@ -4093,21 +4137,24 @@ swift_getForeignTypeMetadata(ForeignTypeMetadata *nonUnique);
 /// \param proposedWitnesses - an optional proposed set of value witnesses.
 ///   This is useful when working with a non-dependent tuple type
 ///   where the entrypoint is just being used to unique the metadata.
-SWIFT_RUNTIME_EXPORT
-const TupleTypeMetadata *
-swift_getTupleTypeMetadata(TupleTypeFlags flags,
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse
+swift_getTupleTypeMetadata(MetadataRequest request,
+                           TupleTypeFlags flags,
                            const Metadata * const *elements,
                            const char *labels,
                            const ValueWitnessTable *proposedWitnesses);
 
-SWIFT_RUNTIME_EXPORT
-const TupleTypeMetadata *
-swift_getTupleTypeMetadata2(const Metadata *elt0, const Metadata *elt1,
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse
+swift_getTupleTypeMetadata2(MetadataRequest request,
+                            const Metadata *elt0, const Metadata *elt1,
                             const char *labels,
                             const ValueWitnessTable *proposedWitnesses);
-SWIFT_RUNTIME_EXPORT
-const TupleTypeMetadata *
-swift_getTupleTypeMetadata3(const Metadata *elt0, const Metadata *elt1,
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataResponse
+swift_getTupleTypeMetadata3(MetadataRequest request,
+                            const Metadata *elt0, const Metadata *elt1,
                             const Metadata *elt2, const char *labels,
                             const ValueWitnessTable *proposedWitnesses);
 

include/swift/Runtime/RuntimeFunctions.def

@@ -869,31 +869,35 @@ FUNCTION(GetObjCClassFromMetadata, swift_getObjCClassFromMetadata, C_CC,
          ARGS(TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadNone))
 
-// Metadata *swift_getTupleTypeMetadata(TupleTypeFlags flags,
-//                                      Metadata * const *elts,
-//                                      const char *labels,
-//                                      value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata, swift_getTupleTypeMetadata, C_CC,
-         RETURNS(TypeMetadataPtrTy),
-         ARGS(SizeTy, TypeMetadataPtrTy->getPointerTo(0),
+// MetadataResponse swift_getTupleTypeMetadata(MetadataRequest request,
+//                                             TupleTypeFlags flags,
+//                                             Metadata * const *elts,
+//                                             const char *labels,
+//                                             value_witness_table_t *proposed);
+FUNCTION(GetTupleMetadata, swift_getTupleTypeMetadata, SwiftCC,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy, SizeTy, TypeMetadataPtrTy->getPointerTo(0),
               Int8PtrTy, WitnessTablePtrTy),
          ATTRS(NoUnwind, ReadOnly))
 
-// Metadata *swift_getTupleTypeMetadata2(Metadata *elt0, Metadata *elt1,
-//                                       const char *labels,
-//                                       value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata2, swift_getTupleTypeMetadata2, C_CC,
-         RETURNS(TypeMetadataPtrTy),
-         ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy,
+// MetadataResponse swift_getTupleTypeMetadata2(MetadataRequest request,
+//                                              Metadata *elt0, Metadata *elt1,
+//                                              const char *labels,
+//                                              value_witness_table_t *proposed);
+FUNCTION(GetTupleMetadata2, swift_getTupleTypeMetadata2, SwiftCC,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
               Int8PtrTy, WitnessTablePtrTy),
          ATTRS(NoUnwind, ReadOnly))
 
-// Metadata *swift_getTupleTypeMetadata3(Metadata *elt0, Metadata *elt1,
-//                                       Metadata *elt2, const char *labels,
-//                                       value_witness_table_t *proposed);
-FUNCTION(GetTupleMetadata3, swift_getTupleTypeMetadata3, C_CC,
-         RETURNS(TypeMetadataPtrTy),
-         ARGS(TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
+// MetadataResponse swift_getTupleTypeMetadata3(MetadataRequest request,
+//                                              Metadata *elt0, Metadata *elt1,
+//                                              Metadata *elt2,
+//                                              const char *labels,
+//                                              value_witness_table_t *proposed);
+FUNCTION(GetTupleMetadata3, swift_getTupleTypeMetadata3, SwiftCC,
+         RETURNS(TypeMetadataResponseTy),
+         ARGS(SizeTy, TypeMetadataPtrTy, TypeMetadataPtrTy, TypeMetadataPtrTy,
               Int8PtrTy, WitnessTablePtrTy),
          ATTRS(NoUnwind, ReadOnly))
 

lib/IRGen/Fulfillment.cpp

@@ -325,6 +325,7 @@ bool FulfillmentMap::addFulfillment(FulfillmentKey key,
 static StringRef getStateName(MetadataState state) {
   switch (state) {
   case MetadataState::Complete: return "complete";
+  case MetadataState::NonTransitiveComplete: return "non-transitive-complete";
   case MetadataState::LayoutComplete: return "layout-complete";
   case MetadataState::Abstract: return "abstract";
   }

lib/IRGen/GenMeta.cpp

@@ -1910,9 +1910,8 @@ namespace {
     void emitStoreOfSuperclass(IRGenFunction &IGF, CanType superclassType,
                                llvm::Value *metadata,
                                MetadataDependencyCollector *collector) {
-      auto request =
-        DynamicMetadataRequest::getNonBlocking(MetadataState::Complete,
-                                               collector);
+      auto request = DynamicMetadataRequest::getNonBlocking(
+                               MetadataState::NonTransitiveComplete, collector);
 
       llvm::Value *superMetadata =
         emitClassHeapMetadataRef(IGF, superclassType,

lib/IRGen/LocalTypeData.h

@@ -169,8 +169,8 @@ class LocalTypeDataCache {
   /// An abstract entry in the cache, which requires some amount of
   /// non-trivial evaluation to derive the desired value.
   struct AbstractCacheEntry : CacheEntry {
-    unsigned SourceIndex : 32 - LocalTypeDataValue::StateSize;
-    unsigned State : LocalTypeDataValue::StateSize;
+    unsigned SourceIndex;
+    unsigned State;
     MetadataPath Path;
 
     AbstractCacheEntry(DominancePoint point, bool isConditional,

lib/IRGen/MetadataPath.h

@@ -37,27 +37,8 @@ namespace irgen {
   class DynamicMetadataRequest;
   class IRGenFunction;
   class LocalTypeDataKey;
-  class LocalTypeDataValue;
   class MetadataResponse;
 
-class LocalTypeDataValue {
-public:
-  enum { StateSize = 2 };
-
-private:
-  llvm::PointerIntPair<llvm::Value*, StateSize, MetadataState> Value;
-
-public:
-  LocalTypeDataValue() {}
-  LocalTypeDataValue(llvm::Value *value, MetadataState state)
-    : Value(value, state) {}
-
-  explicit operator bool() const { return Value.getOpaqueValue() != nullptr; }
-
-  llvm::Value *getValue() const { return Value.getPointer(); }
-  MetadataState getState() const { return Value.getInt(); }
-};
-
 /// A path from one source metadata --- either Swift type metadata or a Swift
 /// protocol conformance --- to another.
 class MetadataPath {