swiftlang · nate-chandler · Sep 15, 2021 · Sep 13, 2021 · Sep 11, 2021 · Sep 13, 2021
@@ -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>>,

diff --git a/cmake/modules/Libdispatch.cmake b/cmake/modules/Libdispatch.cmake
@@ -47,7 +47,8 @@ endif()
 # Build any target libdispatch if needed.
 foreach(sdk ${SWIFT_SDKS})
   # Darwin targets have libdispatch available, do not build it.
-  if(NOT "${sdk}" IN_LIST SWIFT_DARWIN_PLATFORMS)
+  # Wasm/WASI doesn't support libdispatch yet. See https://bugs.swift.org/browse/SR-12097 for more details.
+  if(NOT "${sdk}" IN_LIST SWIFT_DARWIN_PLATFORMS AND NOT "${sdk}" STREQUAL WASI)
     list(APPEND DISPATCH_SDKS "${sdk}")
   endif()
 endforeach()

@@ -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)

@@ -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``.
 

@@ -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))

@@ -81,6 +81,12 @@ enum class IRGenEmbedMode : unsigned {
   EmbedBitcode
 };
 
+enum class SwiftAsyncFramePointerKind : unsigned {
+   Auto, // Choose Swift async extended frame info based on deployment target.
+   Always, // Unconditionally emit Swift async extended frame info.
+   Never,  // Don't emit Swift async extended frame info.
+};
+
 using clang::PointerAuthSchema;
 
 struct PointerAuthOptions : clang::PointerAuthOptions {
@@ -282,6 +288,8 @@ class IRGenOptions {
 
   IRGenLLVMLTOKind LLVMLTOKind : 2;
 
+  SwiftAsyncFramePointerKind SwiftAsyncFramePointer : 2;
+
   /// Add names to LLVM values.
   unsigned HasValueNamesSetting : 1;
   unsigned ValueNames : 1;
@@ -393,7 +401,9 @@ class IRGenOptions {
         Playground(false),
         EmitStackPromotionChecks(false), FunctionSections(false),
         PrintInlineTree(false), EmbedMode(IRGenEmbedMode::None),
-        LLVMLTOKind(IRGenLLVMLTOKind::None), HasValueNamesSetting(false),
+        LLVMLTOKind(IRGenLLVMLTOKind::None),
+        SwiftAsyncFramePointer(SwiftAsyncFramePointerKind::Always),
+        HasValueNamesSetting(false),
         ValueNames(false), EnableReflectionMetadata(true),
         EnableReflectionNames(true), EnableAnonymousContextMangledNames(false),
         ForcePublicLinkage(false), LazyInitializeClassMetadata(false),

@@ -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;
 

@@ -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;

@@ -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">;
@@ -802,6 +806,10 @@ def type_info_dump_filter_EQ : Joined<["-"], "type-info-dump-filter=">,
   Flags<[FrontendOption]>,
   HelpText<"One of 'all', 'resilient' or 'fragile'">;
 
+def swift_async_frame_pointer_EQ : Joined<["-"], "swift-async-frame-pointer=">,
+  Flags<[FrontendOption]>,
+  HelpText<"One of 'auto', 'always' or 'never'">;
+
 def previous_module_installname_map_file
   : Separate<["-"], "previous-module-installname-map-file">, MetaVarName<"<path>">,
     HelpText<"Path to a Json file indicating module name to installname map for @_originallyDefinedIn">;
@@ -827,6 +835,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">;
 

@@ -381,14 +381,16 @@ class SILBuilder {
 
   AllocStackInst *createAllocStack(SILLocation Loc, SILType elementType,
                                    Optional<SILDebugVariable> Var = None,
-                                   bool hasDynamicLifetime = false) {
+                                   bool hasDynamicLifetime = false,
+                                   bool isLexical = false) {
     llvm::SmallString<4> Name;
     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(),
-        substituteAnonymousArgs(Name, Var, Loc), hasDynamicLifetime));
+        substituteAnonymousArgs(Name, Var, Loc), hasDynamicLifetime,
+        isLexical));
   }
 
   AllocRefInst *createAllocRef(SILLocation Loc, SILType ObjectType,

@@ -759,9 +759,9 @@ SILCloner<ImplClass>::visitAllocStackInst(AllocStackInst *Inst) {
     Loc = MandatoryInlinedLocation::getAutoGeneratedLocation();
     VarInfo = None;
   }
-  auto *NewInst =
-      getBuilder().createAllocStack(Loc, getOpType(Inst->getElementType()),
-                                    VarInfo, Inst->hasDynamicLifetime());
+  auto *NewInst = getBuilder().createAllocStack(
+      Loc, getOpType(Inst->getElementType()), VarInfo,
+      Inst->hasDynamicLifetime(), Inst->isLexical());
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }

@@ -1900,16 +1900,16 @@ class AllocStackInst final
   friend SILBuilder;
 
   bool dynamicLifetime = false;
+  bool lexical = false;
 
   AllocStackInst(SILDebugLocation Loc, SILType elementType,
-                 ArrayRef<SILValue> TypeDependentOperands,
-                 SILFunction &F,
-                 Optional<SILDebugVariable> Var, bool hasDynamicLifetime);
+                 ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
+                 Optional<SILDebugVariable> Var, bool hasDynamicLifetime,
+                 bool isLexical);
 
   static AllocStackInst *create(SILDebugLocation Loc, SILType elementType,
-                                SILFunction &F,
-                                Optional<SILDebugVariable> Var,
-                                bool hasDynamicLifetime);
+                                SILFunction &F, Optional<SILDebugVariable> Var,
+                                bool hasDynamicLifetime, bool isLexical);
 
   SIL_DEBUG_VAR_SUPPLEMENT_TRAILING_OBJS_IMPL()
 
@@ -1940,6 +1940,9 @@ class AllocStackInst final
   /// is conditionally initialized.
   bool hasDynamicLifetime() const { return dynamicLifetime; }
 
+  /// Whether the alloc_stack instruction corresponds to a source-level VarDecl.
+  bool isLexical() const { return lexical; }
+
   /// Return the debug variable information attached to this instruction.
   Optional<SILDebugVariable> getVarInfo() const {
     Optional<SILType> AuxVarType;

@@ -35,6 +35,7 @@ namespace swift {
     bool SkipSymbolGraphInheritedDocs = true;
     bool IncludeSPISymbolsInSymbolGraph = false;
     llvm::VersionTuple UserModuleVersion;
+    std::string SDKName;
 
     StringRef GroupInfoPath;
     StringRef ImportedHeader;

@@ -66,7 +66,11 @@ enum class Status {
   TargetIncompatible,
 
   /// The module file was built for a target newer than the current target.
-  TargetTooNew
+  TargetTooNew,
+
+  /// The module file was built with a different SDK than the one in use
+  /// to build the client.
+  SDKMismatch
 };
 
 /// Returns true if the data looks like it contains a serialized AST.
@@ -80,6 +84,7 @@ struct ValidationInfo {
   StringRef miscVersion = {};
   version::Version compatibilityVersion = {};
   llvm::VersionTuple userModuleVersion;
+  StringRef sdkName = {};
   size_t bytes = 0;
   Status status = Status::Malformed;
 };

diff --git a/lib/APIDigester/ModuleAnalyzerNodes.cpp b/lib/APIDigester/ModuleAnalyzerNodes.cpp
@@ -2233,6 +2233,9 @@ swift::ide::api::getSDKNodeRoot(SDKContext &SDKCtx,
 
   auto &Ctx = CI.getASTContext();
 
+  // Don't check if the stdlib was build with the same SDK as what is loaded
+  // here as some tests rely on using a different stdlib.
+  Ctx.SearchPathOpts.EnableSameSDKCheck = false;
 
   // Load standard library so that Clang importer can use it.
   auto *Stdlib = Ctx.getStdlibModule(/*loadIfAbsent=*/true);