Merge pull request #1411 from swiftwasm/master

[pull] swiftwasm from master

Author: kateinoigakukun

include/swift/AST/SILOptions.h

@@ -40,11 +40,6 @@ class SILOptions {
   /// Controls the aggressiveness of the loop unroller.
   int UnrollThreshold = 250;
 
-  /// Controls whether to pull in SIL from partial modules during the
-  /// merge modules step. Could perhaps be merged with the link mode
-  /// above but the interactions between all the flags are tricky.
-  bool MergePartialModules = false;
-
   /// Remove all runtime assertions during optimizations.
   bool RemoveRuntimeAsserts = false;
 

include/swift/AST/TypeCheckRequests.h

@@ -2444,7 +2444,7 @@ class HasImplementationOnlyImportsRequest
 
 class ResolveTypeRequest
     : public SimpleRequest<ResolveTypeRequest,
-                           Type(TypeResolution *, TypeRepr *),
+                           Type(const TypeResolution *, TypeRepr *),
                            RequestFlags::Uncached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2457,7 +2457,7 @@ class ResolveTypeRequest
   friend SimpleRequest;
 
   // Evaluation.
-  Type evaluate(Evaluator &evaluator, TypeResolution *resolution,
+  Type evaluate(Evaluator &evaluator, const TypeResolution *resolution,
                 TypeRepr *repr) const;
 };
 

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -240,7 +240,8 @@ SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeRequest,
-              Type (TypeResolution *, TypeRepr *), Uncached, NoLocationInfo)
+              Type (const TypeResolution *, TypeRepr *),
+              Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SPIGroupsRequest,
               llvm::ArrayRef<Identifier>(Decl *),
               Cached, NoLocationInfo)

include/swift/ClangImporter/BuiltinMappedTypes.def

@@ -21,23 +21,32 @@
 //  - CLANG_BUILTIN_KIND is the kind of builtin type, clang::BuiltinType
 //  - SWIFT_TYPE_NAME is the name of the corresponding stdlib type.
 //
+// MAP_BUILTIN_CCHAR_TYPE(CLANG_BUILTIN_KIND, SWIFT_TYPE_NAME)
+//  - CLANG_BUILTIN_KIND is the kind of builtin type, clang::BuiltinType
+//  - SWIFT_TYPE_NAME is the name of the corresponding stdlib type.
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef MAP_BUILTIN_INTEGER_TYPE
 #define MAP_BUILTIN_INTEGER_TYPE(CLANG, SWIFT) MAP_BUILTIN_TYPE(CLANG, SWIFT)
 #endif
 
+#ifndef MAP_BUILTIN_CCHAR_TYPE
+#define MAP_BUILTIN_CCHAR_TYPE(CLANG, SWIFT) MAP_BUILTIN_TYPE(CLANG, SWIFT)
+#endif
+
+MAP_BUILTIN_CCHAR_TYPE(Char_U,    CChar)
+MAP_BUILTIN_CCHAR_TYPE(Char_S,    CChar)
+MAP_BUILTIN_CCHAR_TYPE(WChar_S,   CWideChar)
+MAP_BUILTIN_CCHAR_TYPE(WChar_U,   CWideChar)
+
 MAP_BUILTIN_TYPE(Bool,      CBool)
-MAP_BUILTIN_INTEGER_TYPE(Char_U,    CChar)
-MAP_BUILTIN_INTEGER_TYPE(Char_S,    CChar)
 MAP_BUILTIN_INTEGER_TYPE(UChar,     CUnsignedChar)
 MAP_BUILTIN_INTEGER_TYPE(UShort,    CUnsignedShort)
 MAP_BUILTIN_INTEGER_TYPE(UInt,      CUnsignedInt)
 MAP_BUILTIN_INTEGER_TYPE(ULong,     CUnsignedLong)
 MAP_BUILTIN_INTEGER_TYPE(ULongLong, CUnsignedLongLong)
 MAP_BUILTIN_INTEGER_TYPE(UInt128,   CUnsignedInt128)
-MAP_BUILTIN_INTEGER_TYPE(WChar_S,   CWideChar)
-MAP_BUILTIN_INTEGER_TYPE(WChar_U,   CWideChar)
 MAP_BUILTIN_INTEGER_TYPE(Char16,    CChar16)
 MAP_BUILTIN_INTEGER_TYPE(Char32,    CChar32)
 MAP_BUILTIN_INTEGER_TYPE(SChar,     CSignedChar)
@@ -54,4 +63,4 @@ MAP_BUILTIN_TYPE(LongDouble, CLongDouble)
 
 #undef MAP_BUILTIN_TYPE
 #undef MAP_BUILTIN_INTEGER_TYPE
-
+#undef MAP_BUILTIN_CCHAR_TYPE

include/swift/Option/FrontendOptions.td

@@ -554,8 +554,9 @@ def sil_unroll_threshold : Separate<["-"], "sil-unroll-threshold">,
   MetaVarName<"<250>">,
   HelpText<"Controls the aggressiveness of loop unrolling">;
 
+// FIXME: This option is now redundant and should eventually be removed.
 def sil_merge_partial_modules : Flag<["-"], "sil-merge-partial-modules">,
-  HelpText<"Merge SIL from all partial swiftmodules into the final module">;
+  Alias<merge_modules>;
 
 def sil_verify_all : Flag<["-"], "sil-verify-all">,
   HelpText<"Verify SIL after each transform">;

include/swift/SIL/SILModule.h

@@ -561,10 +561,6 @@ class SILModule {
   /// i.e. it can be linked by linkFunction.
   bool hasFunction(StringRef Name);
 
-  /// Link all definitions in all segments that are logically part of
-  /// the same AST module.
-  void linkAllFromCurrentModule();
-
   /// Look up the SILWitnessTable representing the lowering of a protocol
   /// conformance, and collect the substitutions to apply to the referenced
   /// witnesses, if any.

include/swift/Serialization/SerializedSILLoader.h

@@ -74,10 +74,6 @@ class SerializedSILLoader {
 
   bool invalidateFunction(SILFunction *F);
 
-  /// Deserialize all SILFunctions, VTables, and WitnessTables in all
-  /// SILModules.
-  void getAll();
-
   /// Deserialize all SILFunctions, VTables, and WitnessTables for
   /// a given Module.
   ///

lib/ClangImporter/ClangImporter.cpp

@@ -2908,11 +2908,12 @@ void ClangModuleUnit::lookupValue(DeclName name, NLKind lookupKind,
 bool ClangImporter::Implementation::isVisibleClangEntry(
     const clang::NamedDecl *clangDecl) {
   // For a declaration, check whether the declaration is hidden.
-  if (!clangDecl->isHidden()) return true;
+  clang::Sema &clangSema = getClangSema();
+  if (clangSema.isVisible(clangDecl)) return true;
 
   // Is any redeclaration visible?
   for (auto redecl : clangDecl->redecls()) {
-    if (!cast<clang::NamedDecl>(redecl)->isHidden()) return true;
+    if (clangSema.isVisible(cast<clang::NamedDecl>(redecl))) return true;
   }
 
   return false;
@@ -3023,8 +3024,10 @@ void ClangImporter::loadExtensions(NominalTypeDecl *nominal,
     SmallVector<clang::NamedDecl *, 4> DelayedCategories;
 
     // Simply importing the categories adds them to the list of extensions.
-    for (const auto *Cat : objcClass->visible_categories()) {
-      Impl.importDeclReal(Cat, Impl.CurrentVersion);
+    for (const auto *Cat : objcClass->known_categories()) {
+      if (getClangSema().isVisible(Cat)) {
+        Impl.importDeclReal(Cat, Impl.CurrentVersion);
+      }
     }
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -7097,9 +7097,12 @@ void SwiftDeclConverter::importMirroredProtocolMembers(
           return;
 
         bool inNearbyCategory =
-            std::any_of(interfaceDecl->visible_categories_begin(),
-                        interfaceDecl->visible_categories_end(),
+            std::any_of(interfaceDecl->known_categories_begin(),
+                        interfaceDecl->known_categories_end(),
                         [=](const clang::ObjCCategoryDecl *category) -> bool {
+                          if (!Impl.getClangSema().isVisible(category)) {
+                            return false;
+                          }
                           if (category != decl) {
                             auto *categoryModule =
                                 Impl.getClangModuleForDecl(category);

lib/ClangImporter/ImportType.cpp

@@ -236,7 +236,9 @@ namespace {
       case clang::BuiltinType::CLANG_BUILTIN_KIND:                        \
         return unwrapCType(Impl.getNamedSwiftType(Impl.getStdlibModule(), \
                                         #SWIFT_TYPE_NAME));
-          
+#define MAP_BUILTIN_CCHAR_TYPE(CLANG_BUILTIN_KIND, SWIFT_TYPE_NAME)       \
+      case clang::BuiltinType::CLANG_BUILTIN_KIND:                        \
+        return Impl.getNamedSwiftType(Impl.getStdlibModule(), #SWIFT_TYPE_NAME);
 #include "swift/ClangImporter/BuiltinMappedTypes.def"
 
       // Types that cannot be mapped into Swift, and probably won't ever be.

lib/Frontend/CompilerInvocation.cpp

@@ -1036,9 +1036,6 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   if (FEOpts.RequestedAction == FrontendOptions::ActionType::EmitModuleOnly)
     Opts.StopOptimizationAfterSerialization = true;
 
-  if (Args.hasArg(OPT_sil_merge_partial_modules))
-    Opts.MergePartialModules = true;
-
   // Propagate the typechecker's understanding of
   // -experimental-skip-non-inlinable-function-bodies to SIL.
   Opts.SkipNonInlinableFunctionBodies = TCOpts.SkipNonInlinableFunctionBodies;

lib/Frontend/Frontend.cpp

@@ -982,22 +982,17 @@ void CompilerInstance::freeASTContext() {
 /// Perform "stable" optimizations that are invariant across compiler versions.
 static bool performMandatorySILPasses(CompilerInvocation &Invocation,
                                       SILModule *SM) {
+  // Don't run diagnostic passes at all when merging modules.
   if (Invocation.getFrontendOptions().RequestedAction ==
       FrontendOptions::ActionType::MergeModules) {
-    // Don't run diagnostic passes at all.
-  } else if (!Invocation.getDiagnosticOptions().SkipDiagnosticPasses) {
-    if (runSILDiagnosticPasses(*SM))
-      return true;
-  } else {
+    return false;
+  }
+  if (Invocation.getDiagnosticOptions().SkipDiagnosticPasses) {
     // Even if we are not supposed to run the diagnostic passes, we still need
     // to run the ownership evaluator.
-    if (runSILOwnershipEliminatorPass(*SM))
-      return true;
+    return runSILOwnershipEliminatorPass(*SM);
   }
-
-  if (Invocation.getSILOptions().MergePartialModules)
-    SM->linkAllFromCurrentModule();
-  return false;
+  return runSILDiagnosticPasses(*SM);
 }
 
 /// Perform SIL optimization passes if optimizations haven't been disabled.

lib/SIL/IR/SILModule.cpp

@@ -427,11 +427,6 @@ bool SILModule::hasFunction(StringRef Name) {
   return getSILLoader()->hasSILFunction(Name);
 }
 
-void SILModule::linkAllFromCurrentModule() {
-  getSILLoader()->getAllForModule(getSwiftModule()->getName(),
-                                  /*PrimaryFile=*/nullptr);
-}
-
 void SILModule::invalidateSILLoaderCaches() {
   getSILLoader()->invalidateCaches();
 }

lib/SIL/Verifier/SILVerifier.cpp

@@ -1751,8 +1751,9 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
               "[dynamically_replaceable] function");
 
     // In canonical SIL, direct reference to a shared_external declaration
-    // is an error; we should have deserialized a body. In raw SIL, we may
-    // not have deserialized the body yet.
+    // is an error; we should have deserialized a body. In raw SIL, including
+    // the merge-modules phase, we may not have deserialized the body yet as we
+    // may not have run the SILLinker pass.
     if (F.getModule().getStage() >= SILStage::Canonical) {
       if (RefF->isExternalDeclaration()) {
         require(SingleFunction ||
@@ -5560,20 +5561,13 @@ void SILModule::verify() const {
   // Uniquing set to catch symbol name collisions.
   llvm::DenseSet<StringRef> symbolNames;
 
-  // When merging partial modules, we only link functions from the current
-  // module, without enabling "LinkAll" mode or running the SILLinker pass;
-  // in this case, we need to relax some of the checks.
-  bool SingleFunction = false;
-  if (getOptions().MergePartialModules)
-    SingleFunction = true;
-
   // Check all functions.
   for (const SILFunction &f : *this) {
     if (!symbolNames.insert(f.getName()).second) {
       llvm::errs() << "Symbol redefined: " << f.getName() << "!\n";
       assert(false && "triggering standard assertion failure routine");
     }
-    f.verify(SingleFunction);
+    f.verify(/*singleFunction*/ false);
   }
 
   // Check all globals.

lib/SILGen/SILGen.cpp

@@ -1928,12 +1928,12 @@ ASTLoweringRequest::evaluate(Evaluator &evaluator,
   }
 
   // Also make sure to process any intermediate files that may contain SIL.
-  bool hasSIB = llvm::any_of(desc.getFiles(), [](const FileUnit *File) -> bool {
-    auto *SASTF = dyn_cast<SerializedASTFile>(File);
-    return SASTF && SASTF->isSIB();
-  });
-  if (hasSIB) {
-    auto primary = desc.context.dyn_cast<FileUnit *>();
+  bool shouldDeserialize =
+      llvm::any_of(desc.getFiles(), [](const FileUnit *File) -> bool {
+        return isa<SerializedASTFile>(File);
+      });
+  if (shouldDeserialize) {
+    auto *primary = desc.context.dyn_cast<FileUnit *>();
     silMod->getSILLoader()->getAllForModule(silMod->getSwiftModule()->getName(),
                                             primary);
   }

lib/SILOptimizer/IPO/EagerSpecializer.cpp

@@ -10,6 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 ///
+/// \file
+///
 /// Eager Specializer
 /// -----------------
 ///
@@ -25,8 +27,11 @@
 ///
 /// TODO: We have not determined whether to support inexact type checks. It
 /// will be a tradeoff between utility of the attribute vs. cost of the check.
+///
+//===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "eager-specializer"
+
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Type.h"
 #include "swift/SIL/SILFunction.h"
@@ -36,7 +41,6 @@
 #include "llvm/Support/Debug.h"
 
 using namespace swift;
-using llvm::dbgs;
 
 // Temporary flag.
 llvm::cl::opt<bool> EagerSpecializeFlag(
@@ -650,7 +654,8 @@ emitArgumentConversion(SmallVectorImpl<SILValue> &CallArgs) {
     unsigned ArgIdx = OrigArg->getIndex();
 
     auto CastArg = emitArgumentCast(SubstitutedType, OrigArg, ArgIdx);
-    LLVM_DEBUG(dbgs() << "  Cast generic arg: "; CastArg->print(dbgs()));
+    LLVM_DEBUG(llvm::dbgs() << "  Cast generic arg: ";
+               CastArg->print(llvm::dbgs()));
 
     if (!substConv.useLoweredAddresses()) {
       CallArgs.push_back(CastArg);
@@ -710,16 +715,15 @@ static SILFunction *eagerSpecialize(SILOptFunctionBuilder &FuncBuilder,
                                     SILFunction *GenericFunc,
                                     const SILSpecializeAttr &SA,
                                     const ReabstractionInfo &ReInfo) {
-  LLVM_DEBUG(dbgs() << "Specializing " << GenericFunc->getName() << "\n");
+  LLVM_DEBUG(llvm::dbgs() << "Specializing " << GenericFunc->getName() << "\n");
 
   LLVM_DEBUG(auto FT = GenericFunc->getLoweredFunctionType();
-             dbgs() << "  Generic Sig:";
-             dbgs().indent(2); FT->getInvocationGenericSignature()->print(dbgs());
-             dbgs() << "  Generic Env:";
-             dbgs().indent(2);
-             GenericFunc->getGenericEnvironment()->dump(dbgs());
-             dbgs() << "  Specialize Attr:";
-             SA.print(dbgs()); dbgs() << "\n");
+             llvm::dbgs() << "  Generic Sig:"; llvm::dbgs().indent(2);
+             FT->getInvocationGenericSignature()->print(llvm::dbgs());
+             llvm::dbgs() << "  Generic Env:"; llvm::dbgs().indent(2);
+             GenericFunc->getGenericEnvironment()->dump(llvm::dbgs());
+             llvm::dbgs() << "  Specialize Attr:"; SA.print(llvm::dbgs());
+             llvm::dbgs() << "\n");
 
   GenericFuncSpecializer
       FuncSpecializer(FuncBuilder, GenericFunc,
@@ -728,7 +732,7 @@ static SILFunction *eagerSpecialize(SILOptFunctionBuilder &FuncBuilder,
 
   SILFunction *NewFunc = FuncSpecializer.trySpecialization();
   if (!NewFunc)
-    LLVM_DEBUG(dbgs() << "  Failed. Cannot specialize function.\n");
+    LLVM_DEBUG(llvm::dbgs() << "  Failed. Cannot specialize function.\n");
   return NewFunc;
 }
 
@@ -744,11 +748,12 @@ void EagerSpecializerTransform::run() {
     // TODO: we should support ownership here but first we'll have to support
     // ownership in GenericFuncSpecializer.
     if (!F.shouldOptimize() || F.hasOwnership()) {
-      LLVM_DEBUG(dbgs() << "  Cannot specialize function " << F.getName()
-                        << " because it has ownership or is marked to be "
-                           "excluded from optimizations.\n");
+      LLVM_DEBUG(llvm::dbgs() << "  Cannot specialize function " << F.getName()
+                              << " because it has ownership or is marked to be "
+                                 "excluded from optimizations.\n");
       continue;
     }
+
     // Only specialize functions in their home module.
     if (F.isExternalDeclaration() || F.isAvailableExternally())
       continue;
@@ -786,11 +791,13 @@ void EagerSpecializerTransform::run() {
                   EagerDispatch(&F, ReInfo).emitDispatchTo(NewFunc);
                 }
               });
+
     // Invalidate everything since we delete calls as well as add new
     // calls and branches.
     if (Changed) {
       invalidateAnalysis(&F, SILAnalysis::InvalidationKind::Everything);
     }
+
     // As specializations are created, the attributes should be removed.
     F.clearSpecializeAttrs();
   }