Merge pull request #1005 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

benchmark/scripts/run_smoke_bench

@@ -272,6 +272,7 @@ def report_code_size(opt_level, old_dir, new_dir, platform, output_file):
     old_lines = ""
     new_lines = ""
     for oldfile in files:
+        new_dir = os.path.join(new_dir, '')
         newfile = oldfile.replace(old_dir, new_dir, 1)
         if os.path.isfile(newfile):
             oldsize = get_codesize(oldfile)

include/swift/AST/GenericSignature.h

@@ -152,7 +152,7 @@ class GenericSignature {
                       TypeArrayView<GenericTypeParamType> genericParams,
                       ArrayRef<Requirement> requirements);
 public:
-  using ConformsToArray = SmallVector<ProtocolDecl *, 2>;
+  using RequiredProtocols = SmallVector<ProtocolDecl *, 2>;
 
 private:
   // Direct comparison is disabled for generic signatures.  Canonicalize them
@@ -318,12 +318,13 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Determine the superclass bound on the given dependent type.
   Type getSuperclassBound(Type type) const;
 
-  /// Determine the set of protocols to which the given dependent type
-  /// must conform.
-  GenericSignature::ConformsToArray getConformsTo(Type type) const;
+  /// Determine the set of protocols to which the given type parameter is
+  /// required to conform.
+  GenericSignature::RequiredProtocols getRequiredProtocols(Type type) const;
 
-  /// Determine whether the given dependent type conforms to this protocol.
-  bool conformsToProtocol(Type type, ProtocolDecl *proto) const;
+  /// Determine whether the given type parameter is required to conform to
+  /// the given protocol.
+  bool requiresProtocol(Type type, ProtocolDecl *proto) const;
 
   /// Determine whether the given dependent type is equal to a concrete type.
   bool isConcreteType(Type type) const;

include/swift/AST/Types.h

@@ -2696,10 +2696,10 @@ enum class FunctionTypeRepresentation : uint8_t {
   /// A "thin" function that needs no context.
   Thin,
 
-  /// A C function pointer, which is thin and also uses the C calling
-  /// convention.
+  /// A C function pointer (or reference), which is thin and also uses the C
+  /// calling convention.
   CFunctionPointer,
-  
+
   /// The value of the greatest AST function representation.
   Last = CFunctionPointer,
 };
@@ -2980,8 +2980,8 @@ class AnyFunctionType : public TypeBase {
       // We preserve a full clang::Type *, not a clang::FunctionType * as:
       // 1. We need to keep sugar in case we need to present an error to the user.
       // 2. The actual type being stored is [ignoring sugar] either a
-      //    clang::PointerType or a clang::BlockPointerType which points to a
-      //    clang::FunctionType.
+      //    clang::PointerType, a clang::BlockPointerType, or a
+      //    clang::ReferenceType which points to a clang::FunctionType.
       const clang::Type *ClangFunctionType;
 
       bool empty() const { return !ClangFunctionType; }

include/swift/SILOptimizer/Utils/LoadStoreOptUtils.h

@@ -169,14 +169,16 @@ class LSBase {
   }
 
   /// Print the LSBase.
-  virtual void print(llvm::raw_ostream &os, SILModule *Mod,
-                     TypeExpansionContext context) {
+  virtual void print(llvm::raw_ostream &os) {
     os << Base;
-    Path.getValue().print(os, *Mod, context);
+    SILFunction *F = Base->getFunction();
+    if (F) {
+      Path.getValue().print(os, F->getModule(), TypeExpansionContext(*F));
+    }
   }
 
-  virtual void dump(SILModule *Mod, TypeExpansionContext context) {
-    print(llvm::dbgs(), Mod, context);
+  virtual void dump() {
+    print(llvm::dbgs());
   }
 };
 
@@ -260,13 +262,12 @@ class LSValue : public LSBase {
     return Path.getValue().createExtract(Base, Inst, true);
   }
 
-  void print(llvm::raw_ostream &os, SILModule *Mod,
-             TypeExpansionContext context) {
+  void print(llvm::raw_ostream &os) {
     if (CoveringValue) {
       os << "Covering Value";
       return;
     }
-    LSBase::print(os, Mod, context);
+    LSBase::print(os);
   }
 
   /// Expand this SILValue to all individual fields it contains.

lib/AST/ASTContext.cpp

@@ -3723,11 +3723,8 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
       superclass = superclass.subst(Substitutions);
     }
   #endif
-  SmallVector<ProtocolDecl*, 4> protos;
-  for (auto proto : signature->getConformsTo(opaqueInterfaceTy)) {
-    protos.push_back(proto);
-  }
-  
+  const auto protos = signature->getRequiredProtocols(opaqueInterfaceTy);
+
   auto mem = ctx.Allocate(
     OpaqueTypeArchetypeType::totalSizeToAlloc<ProtocolDecl *, Type, LayoutConstraint>(
       protos.size(), superclass ? 1 : 0, layout ? 1 : 0),

lib/AST/ASTMangler.cpp

@@ -2539,8 +2539,9 @@ void ASTMangler::appendGenericSignatureParts(
 DependentMemberType *
 ASTMangler::dropProtocolFromAssociatedType(DependentMemberType *dmt) {
   auto baseTy = dmt->getBase();
-  bool unambiguous = (!dmt->getAssocType() ||
-                      CurGenericSignature->getConformsTo(baseTy).size() <= 1);
+  bool unambiguous =
+      (!dmt->getAssocType() ||
+       CurGenericSignature->getRequiredProtocols(baseTy).size() <= 1);
 
   if (auto *baseDMT = baseTy->getAs<DependentMemberType>())
     baseTy = dropProtocolFromAssociatedType(baseDMT);
@@ -2573,8 +2574,8 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt) {
     // If the base type is known to have a single protocol conformance
     // in the current generic context, then we don't need to disambiguate the
     // associated type name by protocol.
-    if (!OptimizeProtocolNames || !CurGenericSignature
-        || CurGenericSignature->getConformsTo(dmt->getBase()).size() > 1) {
+    if (!OptimizeProtocolNames || !CurGenericSignature ||
+        CurGenericSignature->getRequiredProtocols(dmt->getBase()).size() > 1) {
       appendAnyGenericType(assocTy->getProtocol());
     }
     return;

lib/AST/GenericSignature.cpp

@@ -424,10 +424,10 @@ Type GenericSignatureImpl::getSuperclassBound(Type type) const {
   return equivClass->superclass;
 }
 
-/// Determine the set of protocols to which the given dependent type
-/// must conform.
-SmallVector<ProtocolDecl *, 2>
-GenericSignatureImpl::getConformsTo(Type type) const {
+/// Determine the set of protocols to which the given type parameter is
+/// required to conform.
+GenericSignature::RequiredProtocols
+GenericSignatureImpl::getRequiredProtocols(Type type) const {
   if (!type->isTypeParameter()) return { };
 
   auto &builder = *getGenericSignatureBuilder();
@@ -437,12 +437,12 @@ GenericSignatureImpl::getConformsTo(Type type) const {
                                   ArchetypeResolutionKind::CompleteWellFormed);
   if (!equivClass) return { };
 
-  // If this type was mapped to a concrete type, then there are no
-  // requirements.
+  // If this type parameter was mapped to a concrete type, then there
+  // are no requirements.
   if (equivClass->concreteType) return { };
 
   // Retrieve the protocols to which this type conforms.
-  SmallVector<ProtocolDecl *, 2> result;
+  GenericSignature::RequiredProtocols result;
   for (const auto &conforms : equivClass->conformsTo)
     result.push_back(conforms.first);
 
@@ -452,8 +452,8 @@ GenericSignatureImpl::getConformsTo(Type type) const {
   return result;
 }
 
-bool GenericSignatureImpl::conformsToProtocol(Type type,
-                                              ProtocolDecl *proto) const {
+bool GenericSignatureImpl::requiresProtocol(Type type,
+                                            ProtocolDecl *proto) const {
   assert(type->isTypeParameter() && "Expected a type parameter");
 
   auto &builder = *getGenericSignatureBuilder();
@@ -463,7 +463,11 @@ bool GenericSignatureImpl::conformsToProtocol(Type type,
                                   ArchetypeResolutionKind::CompleteWellFormed);
   if (!equivClass) return false;
 
-  // FIXME: Deal with concrete conformances here?
+  // FIXME: Optionally deal with concrete conformances here
+  // or have a separate method do that additionally?
+  //
+  // If this type parameter was mapped to a concrete type, then there
+  // are no requirements.
   if (equivClass->concreteType) return false;
 
   // Check whether the representative conforms to this protocol.
@@ -541,7 +545,7 @@ bool GenericSignatureImpl::isRequirementSatisfied(
     auto protocol = protocolType->getDecl();
 
     if (canFirstType->isTypeParameter())
-      return conformsToProtocol(canFirstType, protocol);
+      return requiresProtocol(canFirstType, protocol);
     else
       return (bool)GSB->lookupConformance(/*dependentType=*/CanType(),
                                           canFirstType, protocol);

lib/AST/SubstitutionMap.cpp

@@ -368,7 +368,7 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 
   // If the type doesn't conform to this protocol, the result isn't formed
   // from these requirements.
-  if (!genericSig->conformsToProtocol(type, proto))
+  if (!genericSig->requiresProtocol(type, proto))
     return ProtocolConformanceRef::forInvalid();
 
   auto accessPath =

lib/AST/Type.cpp

@@ -3044,12 +3044,21 @@ ProtocolConformanceRef ReplaceOpaqueTypesWithUnderlyingTypes::
 operator()(CanType maybeOpaqueType, Type replacementType,
            ProtocolDecl *protocol) const {
   auto abstractRef = ProtocolConformanceRef(protocol);
-
+  
   auto archetypeAndRoot = getArchetypeAndRootOpaqueArchetype(maybeOpaqueType);
   if (!archetypeAndRoot) {
-    assert(maybeOpaqueType->isTypeParameter() ||
-           maybeOpaqueType->is<ArchetypeType>());
-    return abstractRef;
+    if (maybeOpaqueType->isTypeParameter() ||
+        maybeOpaqueType->is<ArchetypeType>())
+      return abstractRef;
+    
+    // SIL type lowering may have already substituted away the opaque type, in
+    // which case we'll end up "substituting" the same type.
+    if (maybeOpaqueType->isEqual(replacementType)) {
+      return inContext->getParentModule()
+                      ->lookupConformance(replacementType, protocol);
+    }
+    
+    llvm_unreachable("origType should have been an opaque type or type parameter");
   }
 
   auto archetype = archetypeAndRoot->first;
@@ -3376,7 +3385,8 @@ void AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType(
 void
 AnyFunctionType::ExtInfo::assertIsFunctionType(const clang::Type *type) {
 #ifndef NDEBUG
-  if (!(type->isFunctionPointerType() || type->isBlockPointerType())) {
+  if (!(type->isFunctionPointerType() || type->isBlockPointerType() ||
+        type->isFunctionReferenceType())) {
     SmallString<256> buf;
     llvm::raw_svector_ostream os(buf);
     os << "Expected a Clang function type wrapped in a pointer type or "

lib/ClangImporter/ImportType.cpp

@@ -159,6 +159,30 @@ namespace {
     explicit operator bool() const { return (bool) AbstractType; }
   };
 
+  static ImportResult importFunctionPointerLikeType(const clang::Type &type,
+                                                    const Type &pointeeType) {
+    auto funcTy = pointeeType->castTo<FunctionType>();
+    return {FunctionType::get(
+                funcTy->getParams(), funcTy->getResult(),
+                funcTy->getExtInfo()
+                    .withRepresentation(
+                        AnyFunctionType::Representation::CFunctionPointer)
+                    .withClangFunctionType(&type)),
+            type.isReferenceType() ? ImportHint::None
+                                    : ImportHint::CFunctionPointer};
+  }
+
+  static ImportResult importOverAlignedFunctionPointerLikeType(
+      const clang::Type &type, ClangImporter::Implementation &Impl) {
+    auto opaquePointer = Impl.SwiftContext.getOpaquePointerDecl();
+    if (!opaquePointer) {
+      return Type();
+    }
+    return {opaquePointer->getDeclaredType(),
+            type.isReferenceType() ? ImportHint::None
+                                    : ImportHint::OtherPointer};
+  }
+
   class SwiftTypeConverter :
     public clang::TypeVisitor<SwiftTypeConverter, ImportResult>
   {
@@ -406,23 +430,11 @@ namespace {
       // alignment is greater than the maximum Swift alignment, import as
       // OpaquePointer.
       if (!pointeeType || Impl.isOverAligned(pointeeQualType)) {
-        auto opaquePointer = Impl.SwiftContext.getOpaquePointerDecl();
-        if (!opaquePointer)
-          return Type();
-        return {opaquePointer->getDeclaredType(),
-                ImportHint::OtherPointer};
+        return importOverAlignedFunctionPointerLikeType(*type, Impl);
       }
-      
+
       if (pointeeQualType->isFunctionType()) {
-        auto funcTy = pointeeType->castTo<FunctionType>();
-        return {
-          FunctionType::get(funcTy->getParams(), funcTy->getResult(),
-            funcTy->getExtInfo()
-              .withRepresentation(
-                AnyFunctionType::Representation::CFunctionPointer)
-              .withClangFunctionType(type)),
-          ImportHint::CFunctionPointer
-        };
+        return importFunctionPointerLikeType(*type, pointeeType);
       }
 
       PointerTypeKind pointerKind;
@@ -472,7 +484,29 @@ namespace {
     }
 
     ImportResult VisitReferenceType(const clang::ReferenceType *type) {
-      return Type();
+      auto pointeeQualType = type->getPointeeType();
+      auto quals = pointeeQualType.getQualifiers();
+      Type pointeeType =
+          Impl.importTypeIgnoreIUO(pointeeQualType, ImportTypeKind::Value,
+                                   AllowNSUIntegerAsInt, Bridgeability::None);
+
+      if (pointeeQualType->isFunctionType()) {
+        return importFunctionPointerLikeType(*type, pointeeType);
+      }
+
+      if (Impl.isOverAligned(pointeeQualType)) {
+        return importOverAlignedFunctionPointerLikeType(*type, Impl);
+      }
+
+      PointerTypeKind pointerKind;
+      if (quals.hasConst()) {
+        pointerKind = PTK_UnsafePointer;
+      } else {
+        pointerKind = PTK_UnsafeMutablePointer;
+      }
+
+      return {pointeeType->wrapInPointer(pointerKind),
+              ImportHint::None};
     }
 
     ImportResult VisitMemberPointer(const clang::MemberPointerType *type) {
@@ -2416,7 +2450,7 @@ bool ClangImporter::Implementation::matchesHashableBound(Type type) {
     if (auto *generic = genericTy->getDecl()) {
       auto genericSig =
         generic->getDeclContext()->getGenericSignatureOfContext();
-      if (genericSig && genericSig->getConformsTo(type).empty()) {
+      if (genericSig && genericSig->getRequiredProtocols(type).empty()) {
         type = genericSig->getSuperclassBound(type);
         if (!type)
           return false;