Merge pull request #3531 from swiftwasm/main

Author: MaxDesiatov

benchmark/single-source/SetTests.swift

@@ -25,11 +25,13 @@ let setAB = Set(0 ..< size)                              //   0 ..< 400
 let setCD = Set(size ..< 2 * size)                       // 400 ..< 800
 let setBC = Set(size - quarter ..< 2 * size - quarter)   // 300 ..< 700
 let setB = Set(size - quarter ..< size)                  // 300 ..< 400
+let setCDS = Set(size ..< (size + (size/4)))             // 400 ..< 500
 
 let setOAB = Set(setAB.map(Box.init))
 let setOCD = Set(setCD.map(Box.init))
 let setOBC = Set(setBC.map(Box.init))
 let setOB = Set(setB.map(Box.init))
+let setOCDS = Set(setCDS.map(Box.init))
 
 let countA = size - quarter        // 300
 let countB = quarter               // 100
@@ -368,6 +370,16 @@ public let SetTests = [
     runFunction: { n in run_SetIsDisjointBox(setOAB, setOCD, true, 50 * n) },
     tags: [.validation, .api, .Set],
     setUpFunction: { blackHole([setOAB, setOCD]) }),
+  BenchmarkInfo(
+    name: "Set.isDisjoint.Smaller.Int0",
+    runFunction: { n in run_SetIsDisjointIntCommutative(setAB, setCDS, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setAB, setCDS]) }),
+  BenchmarkInfo(
+    name: "Set.isDisjoint.Smaller.Box0",
+    runFunction: { n in run_SetIsDisjointBoxCommutative(setOAB, setOCDS, true, 50 * n) },
+    tags: [.validation, .api, .Set],
+    setUpFunction: { blackHole([setOAB, setOCDS]) }),
   BenchmarkInfo(
     name: "Set.isDisjoint.Int25",
     runFunction: { n in run_SetIsDisjointInt(setB, setAB, false, 5000 * n) },
@@ -891,6 +903,22 @@ public func run_SetIsDisjointInt(
     }
 }
 
+// Run isDisjoint Int switching the order of the two sets.  
+@inline(never)
+public func run_SetIsDisjointIntCommutative(
+    _ a: Set<Int>,
+    _ b: Set<Int>,
+    _ r: Bool,
+    _ n: Int) {
+    for _ in 0 ..< n {
+      let isDisjointA = a.isDisjoint(with: identity(b))
+      CheckResults(isDisjointA == r)
+  
+      let isDisjointB = b.isDisjoint(with: identity(a))
+      CheckResults(isDisjointB == r)
+    }
+}
+
 @inline(never)
 public func run_SetIsDisjointSeqInt(
     _ a: Set<Int>,
@@ -1091,6 +1119,22 @@ func run_SetIsDisjointBox(
     }
 }
 
+// Run isDisjoint Box switching the order of the two sets.  
+@inline(never)
+func run_SetIsDisjointBoxCommutative(
+    _ a: Set<Box<Int>>,
+    _ b: Set<Box<Int>>,
+    _ r: Bool,
+    _ n: Int) {
+    for _ in 0 ..< n {
+        let isDisjointA = a.isDisjoint(with: identity(b))
+        CheckResults(isDisjointA == r)
+  
+        let isDisjointB = b.isDisjoint(with: identity(a))
+        CheckResults(isDisjointB == r)
+    }
+}
+
 @inline(never)
 func run_SetIsDisjointSeqBox(
     _ a: Set<Box<Int>>,

docs/HowToGuides/GettingStarted.md

@@ -16,7 +16,7 @@ toolchain as a one-off, there are a couple of differences:
   - [Troubleshooting cloning issues](#troubleshooting-cloning-issues)
 - [Installing dependencies](#installing-dependencies)
   - [macOS](#macOS)
-  - [Ubuntu Linux](#ubuntu-linux)
+  - [Linux](#linux)
 - [Building the project for the first time](#building-the-project-for-the-first-time)
   - [Spot check dependencies](#spot-check-dependencies)
   - [The roles of different tools](#the-roles-of-different-tools)

docs/SIL.rst

@@ -3079,7 +3079,7 @@ alloc_stack
 ```````````
 ::
 
-  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? sil-type (',' debug-var-attr)*
+  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? '[lexical]'? sil-type (',' debug-var-attr)*
 
   %1 = alloc_stack $T
   // %1 has type $*T
@@ -3102,6 +3102,9 @@ The ``dynamic_lifetime`` attribute specifies that the initialization and
 destruction of the stored value cannot be verified at compile time.
 This is the case, e.g. for conditionally initialized objects.
 
+The optional ``lexical`` attribute specifies that the operand corresponds to a
+local variable in the Swift source.
+
 The memory is not retainable. To allocate a retainable box for a value
 type, use ``alloc_box``.
 

include/swift/AST/DiagnosticsSema.def

@@ -782,6 +782,9 @@ ERROR(serialization_name_mismatch_repl,none,
 ERROR(serialization_target_incompatible,Fatal,
       "module %0 was created for incompatible target %1: %2",
       (Identifier, StringRef, StringRef))
+ERROR(serialization_sdk_mismatch,Fatal,
+      "cannot load module %0 built with SDK '%1' when using SDK '%2': %3",
+      (Identifier, StringRef, StringRef, StringRef))
 ERROR(serialization_target_incompatible_repl,none,
       "module %0 was created for incompatible target %1: %2",
       (Identifier, StringRef, StringRef))

include/swift/AST/IRGenOptions.h

@@ -345,6 +345,8 @@ class IRGenOptions {
 
   unsigned EnableGlobalISel : 1;
 
+  unsigned VirtualFunctionElimination : 1;
+
   /// The number of threads for multi-threaded code generation.
   unsigned NumThreads = 0;
 
@@ -401,7 +403,8 @@ class IRGenOptions {
         GenerateProfile(false), EnableDynamicReplacementChaining(false),
         DisableRoundTripDebugTypes(false), DisableDebuggerShadowCopies(false),
         DisableConcreteTypeMetadataMangledNameAccessors(false),
-        EnableGlobalISel(false), CmdArgs(),
+        EnableGlobalISel(false), VirtualFunctionElimination(false),
+        CmdArgs(),
         SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {}
 

include/swift/AST/SearchPathOptions.h

@@ -82,6 +82,10 @@ class SearchPathOptions {
   /// would for a non-system header.
   bool DisableModulesValidateSystemDependencies = false;
 
+  /// Enforce loading only serialized modules built with the same SDK
+  /// as the context loading it.
+  bool EnableSameSDKCheck = true;
+
   /// A set of compiled modules that may be ready to use.
   std::vector<std::string> CandidateCompiledModules;
 

include/swift/Basic/LangOptions.h

@@ -127,6 +127,9 @@ namespace swift {
     /// The target variant SDK version, if known.
     Optional<llvm::VersionTuple> VariantSDKVersion;
 
+    /// The SDK canonical name, if known.
+    std::string SDKName;
+
     /// The alternate name to use for the entry point instead of main.
     std::string entryPointFunctionName = "main";
 
@@ -301,6 +304,9 @@ namespace swift {
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
+    /// Enable experimental support for emitting defined borrow scopes.
+    bool EnableExperimentalDefinedLifetimes = false;
+
     /// Enable experimental support for named opaque result types, e.g.
     /// `func f() -> <T> T`.
     bool EnableExperimentalNamedOpaqueTypes = false;

include/swift/Option/FrontendOptions.td

@@ -247,6 +247,10 @@ def enable_experimental_concurrency :
   Flag<["-"], "enable-experimental-concurrency">,
   HelpText<"Enable experimental concurrency model">;
 
+def enable_experimental_defined_lifetimes :
+  Flag<["-"], "enable-experimental-defined-lifetimes">,
+  HelpText<"Enable experimental defined lifetimes">;
+
 def enable_experimental_distributed :
   Flag<["-"], "enable-experimental-distributed">,
   HelpText<"Enable experimental 'distributed' actors and functions">;
@@ -489,6 +493,10 @@ def enable_implicit_dynamic : Flag<["-"], "enable-implicit-dynamic">,
   Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
   HelpText<"Add 'dynamic' to all declarations">;
 
+def enable_llvm_vfe : Flag<["-"], "enable-llvm-vfe">,
+  Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
+  HelpText<"Use LLVM Virtual Function Elimination on Swift class virtual tables">;
+
 def disable_previous_implementation_calls_in_dynamic_replacements :
   Flag<["-"], "disable-previous-implementation-calls-in-dynamic-replacements">,
   Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
@@ -823,6 +831,9 @@ def target_sdk_version : Separate<["-"], "target-sdk-version">,
 def target_variant_sdk_version : Separate<["-"], "target-variant-sdk-version">,
   HelpText<"The version of target variant SDK used for compilation">;
 
+def target_sdk_name : Separate<["-"], "target-sdk-name">,
+  HelpText<"Canonical name of the target SDK used for compilation">;
+
 def extra_clang_options_only : Flag<["-"], "only-use-extra-clang-opts">,
   HelpText<"Options passed via -Xcc are sufficient for Clang configuration">;
 

include/swift/Runtime/RuntimeFunctions.def

@@ -634,6 +634,24 @@ FUNCTION(GetFunctionMetadataGlobalActor,
               TypeMetadataPtrTy),
          ATTRS(NoUnwind, ReadOnly))
 
+// Metadata *
+// swift_getFunctionTypeMetadataGlobalActorBackDeploy(unsigned long flags,
+//                                                    unsigned long diffKind,
+//                                               const Metadata **parameters,
+//                                               const uint32_t *parameterFlags,
+//                                               const Metadata *result,
+//                                               const Metadata *globalActor);
+FUNCTION(GetFunctionMetadataGlobalActorBackDeploy,
+         swift_getFunctionTypeMetadataGlobalActorBackDeploy,
+         C_CC, OpaqueTypeAvailability,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(SizeTy,
+              SizeTy,
+              TypeMetadataPtrTy->getPointerTo(0),
+              Int32Ty->getPointerTo(0),
+              TypeMetadataPtrTy,
+              TypeMetadataPtrTy),
+         ATTRS(NoUnwind, ReadOnly))
 
 // Metadata *swift_getFunctionTypeMetadata0(unsigned long flags,
 //                                          const Metadata *resultMetadata);

include/swift/SIL/SILBuilder.h

@@ -365,13 +365,14 @@ class SILBuilder {
 
   AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType,
                                    Optional<SILDebugVariable> Var = None,
-                                   bool hasDynamicLifetime = false) {
+                                   bool hasDynamicLifetime = false,
+                                   bool isLexical = false) {
     Loc.markAsPrologue();
     assert((!dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
            "location is a VarDecl, but SILDebugVariable is empty");
     return insert(AllocStackInst::create(getSILDebugLocation(Loc), elementType,
-                                         getFunction(),
-                                         Var, hasDynamicLifetime));
+                                         getFunction(), Var, hasDynamicLifetime,
+                                         isLexical));
   }
 
   AllocRefInst *createAllocRef(SILLocation Loc, SILType ObjectType,