Merge branch 'master' into hermetic

Author: hlopko

docs/ABI/Mangling.rst

@@ -173,6 +173,9 @@ Globals
 
   global ::= global 'MK'                 // instantiation cache associated with global
 
+  global ::= global 'MJ'                 // noncanonical specialized generic type metadata instantiation cache associated with global
+  global ::= global 'MN'                 // noncanonical specialized generic type metadata for global
+
 A direct symbol resolves directly to the address of an object.  An
 indirect symbol resolves to the address of a pointer to the object.
 They are distinct manglings to make a certain class of bugs

include/swift/AST/Attr.def

@@ -244,7 +244,7 @@ SIMPLE_DECL_ATTR(nonobjc, NonObjC,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   30)
 SIMPLE_DECL_ATTR(_fixed_layout, FixedLayout,
-  OnVar | OnClass | OnStruct |
+  OnVar | OnClass | OnStruct | OnProtocol |
   UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove |
   APIStableToAdd | APIStableToRemove,
   31)

include/swift/AST/AutoDiff.h

@@ -649,6 +649,29 @@ bool getBuiltinDifferentiableOrLinearFunctionConfig(
 bool getBuiltinDifferentiableOrLinearFunctionConfig(
     StringRef operationName, unsigned &arity, bool &throws);
 
+/// Returns the SIL differentiability witness generic signature given the
+/// original declaration's generic signature and the derivative generic
+/// signature.
+///
+/// In general, the differentiability witness generic signature is equal to the
+/// derivative generic signature.
+///
+/// Edge case, if two conditions are satisfied:
+/// 1. The derivative generic signature is equal to the original generic
+///    signature.
+/// 2. The derivative generic signature has *all concrete* generic parameters
+///    (i.e. all generic parameters are bound to concrete types via same-type
+///    requirements).
+///
+/// Then the differentiability witness generic signature is `nullptr`.
+///
+/// Both the original and derivative declarations are lowered to SIL functions
+/// with a fully concrete type and no generic signature, so the
+/// differentiability witness should similarly have no generic signature.
+GenericSignature
+getDifferentiabilityWitnessGenericSignature(GenericSignature origGenSig,
+                                            GenericSignature derivativeGenSig);
+
 } // end namespace autodiff
 
 } // end namespace swift

include/swift/AST/DiagnosticsSema.def

@@ -2795,7 +2795,7 @@ WARNING(differentiable_let_property_implicit_noderivative_fixit,none,
 NOTE(codable_extraneous_codingkey_case_here,none,
      "CodingKey case %0 does not match any stored properties", (Identifier))
 NOTE(codable_non_conforming_property_here,none,
-     "cannot automatically synthesize %0 because %1 does not conform to %0", (Type, Type))
+     "cannot automatically synthesize %0 because %1 does not conform to %0", (Type, TypeLoc))
 NOTE(codable_non_decoded_property_here,none,
      "cannot automatically synthesize %0 because %1 does not have a matching CodingKey and does not have a default value", (Type, Identifier))
 NOTE(codable_codingkeys_type_is_not_an_enum_here,none,

include/swift/Demangling/DemangleNodes.def

@@ -287,12 +287,12 @@ NODE(OpaqueTypeDescriptorAccessorVar)
 NODE(OpaqueReturnType)
 CONTEXT_NODE(OpaqueReturnTypeOf)
 
-// Added in Swift 5.3
+// Added in Swift 5.4
 NODE(CanonicalSpecializedGenericMetaclass)
 NODE(CanonicalSpecializedGenericTypeMetadataAccessFunction)
-
-// Added in Swift 5.4
 NODE(MetadataInstantiationCache)
+NODE(NoncanonicalSpecializedGenericTypeMetadata)
+NODE(NoncanonicalSpecializedGenericTypeMetadataCache)
 
 #undef CONTEXT_NODE
 #undef NODE

include/swift/IRGen/Linking.h

@@ -393,6 +393,16 @@ class LinkEntity {
     /// An access function for prespecialized type metadata.
     /// The pointer is a canonical TypeBase*.
     CanonicalSpecializedGenericTypeMetadataAccessFunction,
+
+    /// Metadata for a specialized generic type which cannot be statically
+    /// guaranteed to be canonical and so must be canonicalized.
+    /// The pointer is a canonical TypeBase*.
+    NoncanonicalSpecializedGenericTypeMetadata,
+
+    /// A cache variable for noncanonical specialized type metadata, to be 
+    /// passed to swift_getCanonicalSpecializedMetadata.
+    /// The pointer is a canonical TypeBase*.
+    NoncanonicalSpecializedGenericTypeMetadataCacheVariable,
   };
   friend struct llvm::DenseMapInfo<LinkEntity>;
 
@@ -1045,6 +1055,24 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity
+  forNoncanonicalSpecializedGenericTypeMetadata(CanType theType) {
+    LinkEntity entity;
+    entity.setForType(Kind::NoncanonicalSpecializedGenericTypeMetadata,
+                      theType);
+    entity.Data |= LINKENTITY_SET_FIELD(
+        MetadataAddress, unsigned(TypeMetadataAddress::FullMetadata));
+    return entity;
+  }
+
+
+  static LinkEntity
+  forNoncanonicalSpecializedGenericTypeMetadataCacheVariable(CanType theType) {
+    LinkEntity entity;
+    entity.setForType(Kind::NoncanonicalSpecializedGenericTypeMetadataCacheVariable, theType);
+    return entity;
+  }
+
   void mangle(llvm::raw_ostream &out) const;
   void mangle(SmallVectorImpl<char> &buffer) const;
   std::string mangleAsString() const;
@@ -1152,6 +1180,7 @@ class LinkEntity {
   }
   TypeMetadataAddress getMetadataAddress() const {
     assert(getKind() == Kind::TypeMetadata ||
+           getKind() == Kind::NoncanonicalSpecializedGenericTypeMetadata ||
            getKind() == Kind::ObjCResilientClassStub);
     return (TypeMetadataAddress)LINKENTITY_GET_FIELD(Data, MetadataAddress);
   }

include/swift/Parse/Parser.h

@@ -660,7 +660,7 @@ class Parser {
   /// \returns true if there is an instance of \c T1 on the current line (this
   /// avoids the foot-gun of not considering T1 starting the next line for a
   /// plain Tok.is(T1) check).
-  bool skipUntilTokenOrEndOfLine(tok T1);
+  bool skipUntilTokenOrEndOfLine(tok T1, tok T2 = tok::NUM_TOKENS);
 
   /// Skip a braced block (e.g. function body). The current token must be '{'.
   /// Returns \c true if the parser hit the eof before finding matched '}'.

include/swift/SIL/MemAccessUtils.h

@@ -189,7 +189,9 @@ namespace swift {
 /// the base of a formal access. It may be from a ref_tail_addr, undef, or some
 /// recognized memory initialization pattern. Unidentified valid storage cannot
 /// represent any arbitrary base address--it must at least been proven not to
-/// correspond to any class or global variable access.
+/// correspond to any class or global variable access, unless it's nested within
+/// another access to the same object. So, Unidentified can overlap with
+/// Class/Global access, but it cannot be the only formal access to that memory.
 ///
 /// An *invalid* AccessedStorage object is Unidentified and associated with an
 /// invalid SILValue. This signals that analysis has failed to recognize an
@@ -219,6 +221,7 @@ class AccessedStorage {
     Stack,
     Global,
     Class,
+    Tail,
     Argument,
     Yield,
     Nested,
@@ -228,10 +231,16 @@ class AccessedStorage {
 
   static const char *getKindName(Kind k);
 
-  /// Directly create an AccessedStorage for class property access.
+  // Give object tail storage a fake property index for convenience.
+  static constexpr unsigned TailIndex = ~0U;
+
+  /// Directly create an AccessedStorage for class or tail property access.
   static AccessedStorage forClass(SILValue object, unsigned propertyIndex) {
     AccessedStorage storage;
-    storage.initKind(Class, propertyIndex);
+    if (propertyIndex == TailIndex)
+      storage.initKind(Tail);
+    else
+      storage.initKind(Class, propertyIndex);
     storage.value = object;
     return storage;
   }
@@ -301,7 +310,8 @@ class AccessedStorage {
   union {
     // For non-class storage, 'value' is the access base. For class storage
     // 'value' is the object base, where the access base is the class' stored
-    // property.
+    // property. For tail storage 'value' is the object base and there is no
+    // value for the access base.
     SILValue value;
     SILGlobalVariable *global;
   };
@@ -334,7 +344,7 @@ class AccessedStorage {
   }
 
   SILValue getValue() const {
-    assert(getKind() != Global && getKind() != Class);
+    assert(getKind() != Global && getKind() != Class && getKind() != Tail);
     return value;
   }
 
@@ -354,7 +364,7 @@ class AccessedStorage {
   }
 
   SILValue getObject() const {
-    assert(getKind() == Class);
+    assert(getKind() == Class || getKind() == Tail);
     return value;
   }
   unsigned getPropertyIndex() const {
@@ -374,6 +384,7 @@ class AccessedStorage {
     switch (getKind()) {
     case Box:
     case Stack:
+    case Tail:
     case Argument:
     case Yield:
     case Nested:
@@ -396,6 +407,7 @@ class AccessedStorage {
       return true;
     case Global:
     case Class:
+    case Tail:
     case Argument:
     case Yield:
     case Nested:
@@ -405,6 +417,11 @@ class AccessedStorage {
     llvm_unreachable("unhandled kind");
   }
 
+  /// Return trye if the given access is guaranteed to be within a heap object.
+  bool isObjectAccess() const {
+    return getKind() == Class || getKind() == Tail;
+  }
+
   /// Return true if the given access is on a 'let' lvalue.
   bool isLetAccess(SILFunction *F) const;
 
@@ -420,6 +437,7 @@ class AccessedStorage {
     case Global:
       return true;
     case Class:
+    case Tail:
     case Argument:
     case Yield:
     case Nested:
@@ -455,20 +473,47 @@ class AccessedStorage {
   // Return true if this storage is guaranteed not to overlap with \p other's
   // storage.
   bool isDistinctFrom(const AccessedStorage &other) const {
-    if (isUniquelyIdentified() && other.isUniquelyIdentified()) {
-      return !hasIdenticalBase(other);
+    if (isUniquelyIdentified()) {
+      if (other.isUniquelyIdentified() && !hasIdenticalBase(other))
+        return true;
+
+      if (other.isObjectAccess())
+        return true;
+
+      // We currently assume that Unidentified storage may overlap with
+      // Box/Stack storage.
+      return false;
     }
-    if (getKind() != Class || other.getKind() != Class)
-      // At least one side is an Argument or Yield, or is unidentified.
+    if (other.isUniquelyIdentified())
+      return other.isDistinctFrom(*this);
+
+    // Neither storage is uniquely identified.
+    if (isObjectAccess()) {
+      if (other.isObjectAccess()) {
+        // Property access cannot overlap with Tail access.
+        if (getKind() != other.getKind())
+          return true;
+
+        // We could also check if the object types are distinct, but that only
+        // helps if we know the relationships between class types.
+        return getKind() == Class
+               && getPropertyIndex() != other.getPropertyIndex();
+      }
+      // Any type of nested/argument address may be within the same object.
+      //
+      // We also currently assume Unidentified access may be within an object
+      // purely to handle KeyPath accesses. The deriviation of the KeyPath
+      // address must separately appear to be a Class access so that all Class
+      // accesses are accounted for.
       return false;
-
-    // Classes are not uniquely identified by their base. However, if the
-    // underling objects have identical types and distinct property indices then
-    // they are distinct storage locations.
-    if (getObject()->getType() == other.getObject()->getType()
-        && getPropertyIndex() != other.getPropertyIndex()) {
-      return true;
     }
+    if (other.isObjectAccess())
+      return other.isDistinctFrom(*this);
+
+    // Neither storage is from a class or tail.
+    //
+    // Unidentified values may alias with each other or with any kind of
+    // nested/argument access.
     return false;
   }
 
@@ -530,10 +575,11 @@ template <> struct DenseMapInfo<swift::AccessedStorage> {
       return storage.getParamIndex();
     case swift::AccessedStorage::Global:
       return DenseMapInfo<void *>::getHashValue(storage.getGlobal());
-    case swift::AccessedStorage::Class: {
+    case swift::AccessedStorage::Class:
       return llvm::hash_combine(storage.getObject(),
                                 storage.getPropertyIndex());
-    }
+    case swift::AccessedStorage::Tail:
+      return DenseMapInfo<swift::SILValue>::getHashValue(storage.getObject());
     }
     llvm_unreachable("Unhandled AccessedStorageKind");
   }
@@ -673,6 +719,9 @@ class AccessUseDefChainVisitor {
   Result visitClassAccess(RefElementAddrInst *field) {
     return asImpl().visitBase(field, AccessedStorage::Class);
   }
+  Result visitTailAccess(RefTailAddrInst *tail) {
+    return asImpl().visitBase(tail, AccessedStorage::Tail);
+  }
   Result visitArgumentAccess(SILFunctionArgument *arg) {
     return asImpl().visitBase(arg, AccessedStorage::Argument);
   }
@@ -808,7 +857,7 @@ Result AccessUseDefChainVisitor<Impl, Result>::visit(SILValue sourceAddr) {
   // This is a valid address producer for nested @inout argument
   // access, but it is never used for formal access of identified objects.
   case ValueKind::RefTailAddrInst:
-    return asImpl().visitUnidentified(sourceAddr);
+    return asImpl().visitTailAccess(cast<RefTailAddrInst>(sourceAddr));
 
   // Inductive single-operand cases:
   // Look through address casts to find the source address.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -68,8 +68,10 @@ PASS(CrossModuleSerializationSetup, "cross-module-serialization-setup",
      "Setup serialization flags for cross-module optimization")
 PASS(AccessSummaryDumper, "access-summary-dump",
      "Dump Address Parameter Access Summary")
+PASS(AccessedStorageAnalysisDumper, "accessed-storage-analysis-dump",
+     "Dump Accessed Storage Analysis Summaries")
 PASS(AccessedStorageDumper, "accessed-storage-dump",
-     "Dump Accessed Storage Summary")
+     "Dump Accessed Storage Information")
 PASS(AccessMarkerElimination, "access-marker-elim",
      "Access Marker Elimination.")
 PASS(AddressLowering, "address-lowering",

lib/AST/AutoDiff.cpp

@@ -372,6 +372,23 @@ bool autodiff::getBuiltinDifferentiableOrLinearFunctionConfig(
   return operationName.empty();
 }
 
+GenericSignature autodiff::getDifferentiabilityWitnessGenericSignature(
+    GenericSignature origGenSig, GenericSignature derivativeGenSig) {
+  // If there is no derivative generic signature, return the original generic
+  // signature.
+  if (!derivativeGenSig)
+    return origGenSig;
+  // If derivative generic signature has all concrete generic parameters and is
+  // equal to the original generic signature, return `nullptr`.
+  auto derivativeCanGenSig = derivativeGenSig.getCanonicalSignature();
+  auto origCanGenSig = origGenSig.getCanonicalSignature();
+  if (origCanGenSig == derivativeCanGenSig &&
+      derivativeCanGenSig->areAllParamsConcrete())
+    return GenericSignature();
+  // Otherwise, return the derivative generic signature.
+  return derivativeGenSig;
+}
+
 Type TangentSpace::getType() const {
   switch (kind) {
   case Kind::TangentVector:

lib/AST/GenericSignatureBuilder.cpp

@@ -2065,18 +2065,9 @@ Type EquivalenceClass::getTypeInContext(GenericSignatureBuilder &builder,
       return ErrorType::get(anchor);
 
     // Map the parent type into this context.
-    Type parentType = parentEquivClass->getTypeInContext(builder, genericEnv);
-
-    // If the parent is concrete, handle the
-    parentArchetype = parentType->getAs<ArchetypeType>();
-    if (!parentArchetype) {
-      // Resolve the member type.
-      Type memberType =
-        depMemTy->substBaseType(parentType, builder.getLookupConformanceFn());
-
-      return genericEnv->mapTypeIntoContext(memberType,
-                                            builder.getLookupConformanceFn());
-    }
+    parentArchetype =
+      parentEquivClass->getTypeInContext(builder, genericEnv)
+                      ->castTo<ArchetypeType>();
 
     // If we already have a nested type with this name, return it.
     assocType = depMemTy->getAssocType();