Merge pull request #2254 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

benchmark/CMakeLists.txt

@@ -189,6 +189,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Walsh
     single-source/WordCount
     single-source/XorLoop
+    cxx-source/CreateObjects
 )
 
 set(SWIFT_MULTISOURCE_SWIFT_BENCHES

benchmark/Package.swift

@@ -49,6 +49,11 @@ var singleSourceLibraries: [String] = singleSourceLibraryDirs.flatMap {
   getSingleSourceLibraries(subDirectory: $0)
 }
 
+var cxxSingleSourceLibraryDirs: [String] = ["cxx-source"]
+var cxxSingleSourceLibraries: [String] = cxxSingleSourceLibraryDirs.flatMap {
+  getSingleSourceLibraries(subDirectory: $0)
+}
+
 //===---
 // Multi Source Libraries
 //
@@ -80,6 +85,7 @@ products.append(.library(name: "ObjectiveCTests", type: .static, targets: ["Obje
 products.append(.executable(name: "SwiftBench", targets: ["SwiftBench"]))
 
 products += singleSourceLibraries.map { .library(name: $0, type: .static, targets: [$0]) }
+products += cxxSingleSourceLibraries.map { .library(name: $0, type: .static, targets: [$0]) }
 products += multiSourceLibraries.map {
   return .library(name: $0.name, type: .static, targets: [$0.name])
 }
@@ -103,13 +109,18 @@ swiftBenchDeps.append(.target(name: "ObjectiveCTests"))
 #endif
 swiftBenchDeps.append(.target(name: "DriverUtils"))
 swiftBenchDeps += singleSourceLibraries.map { .target(name: $0) }
+swiftBenchDeps += cxxSingleSourceLibraries.map { .target(name: $0) }
 swiftBenchDeps += multiSourceLibraries.map { .target(name: $0.name) }
 
 targets.append(
     .target(name: "SwiftBench",
     dependencies: swiftBenchDeps,
     path: "utils",
-    sources: ["main.swift"]))
+    sources: ["main.swift"],
+    swiftSettings: [.unsafeFlags(["-Xfrontend",
+                                  "-enable-cxx-interop",
+                                  "-I",
+                                  "utils/CxxTests"])]))
 
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 targets.append(
@@ -139,6 +150,18 @@ targets += singleSourceLibraries.map { name in
       sources: ["\(name).swift"])
 }
 
+targets += cxxSingleSourceLibraries.map { name in
+  return .target(
+    name: name,
+    dependencies: singleSourceDeps,
+    path: "cxx-source",
+    sources: ["\(name).swift"],
+    swiftSettings: [.unsafeFlags(["-Xfrontend",
+                                  "-enable-cxx-interop",
+                                  "-I",
+                                  "utils/CxxTests"])])
+}
+
 targets += multiSourceLibraries.map { lib in
   return .target(
     name: lib.name,

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -478,6 +478,12 @@ function (swift_benchmark_compile_archopts)
       list(APPEND SWIFT_BENCH_OBJFILES "${objfile}")
       list(APPEND bench_library_swiftmodules "${swiftmodule}")
 
+      # Only set "enable-cxx-interop" for tests in the "cxx-source" directory.
+      set(cxx_options "")
+      if ("${module_name_path}" MATCHES ".*cxx-source/.*")
+        list(APPEND cxx_options "-Xfrontend" "-enable-cxx-interop" "-I" "${srcdir}/utils/CxxTests/")
+      endif()
+
       if ("${bench_flags}" MATCHES "-whole-module.*")
         set(output_option "-o" "${objfile}")
       else()
@@ -501,6 +507,7 @@ function (swift_benchmark_compile_archopts)
           "-module-name" "${module_name}"
           "-emit-module-path" "${swiftmodule}"
           "-I" "${objdir}"
+          ${cxx_options}
           ${output_option}
           "${source}")
       if (SWIFT_BENCHMARK_EMIT_SIB)
@@ -518,6 +525,7 @@ function (swift_benchmark_compile_archopts)
             ${SWIFT_BENCHMARK_EXTRA_FLAGS}
             "-module-name" "${module_name}"
             "-I" "${objdir}"
+            ${cxx_options}
             "-emit-sib"
             "-o" "${sibfile}"
             "${source}")
@@ -582,6 +590,8 @@ function (swift_benchmark_compile_archopts)
       "-whole-module-optimization"
       "-emit-module" "-module-name" "${module_name}"
       "-I" "${objdir}"
+      "-Xfrontend" "-enable-cxx-interop"
+      "-I" "${srcdir}/utils/CxxTests/"
       "-o" "${objdir}/${module_name}.o"
       "${source}")
   list(APPEND SWIFT_BENCH_OBJFILES "${objdir}/${module_name}.o")

benchmark/cxx-source/CreateObjects.swift

@@ -0,0 +1,31 @@
+//===--- CreateObjects.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This is a simple test that creates thousands of C++ objects and does nothing
+// with them.
+
+import TestsUtils
+import CxxCreateObjects
+
+public let CreateObjects = BenchmarkInfo(
+  name: "CreateObjects",
+  runFunction: run_CreateObjects,
+  tags: [.validation, .bridging])
+
+@inline(never)
+public func run_CreateObjects(_ N: Int) {
+  for i in 0...(N * 10_000) {
+    let x = Int32(i)
+    let f = CxxLoadableIntWrapper(value: x)
+    blackHole(f)
+  }
+}

benchmark/utils/CxxTests/CreateObjects.h

@@ -0,0 +1,3 @@
+struct CxxLoadableIntWrapper {
+  int value;
+};

benchmark/utils/CxxTests/module.modulemap

@@ -0,0 +1,3 @@
+module CxxCreateObjects {
+  header "CreateObjects.h"
+}

benchmark/utils/main.swift

@@ -48,6 +48,7 @@ import Chars
 import ClassArrayGetter
 import Codable
 import Combos
+import CreateObjects
 import DataBenchmarks
 import DeadArray
 import DevirtualizeProtocolComposition
@@ -236,6 +237,7 @@ registerBenchmark(Chars)
 registerBenchmark(Codable)
 registerBenchmark(Combos)
 registerBenchmark(ClassArrayGetter)
+registerBenchmark(CreateObjects)
 registerBenchmark(DataBenchmarks)
 registerBenchmark(DeadArray)
 registerBenchmark(DevirtualizeProtocolComposition)

include/swift/ABI/Task.h

@@ -127,6 +127,10 @@ class alignas(2 * alignof(void*)) Job {
     return Flags.isAsyncTask();
   }
 
+  JobPriority getPriority() const {
+    return Flags.getPriority();
+  }
+
   /// Run this job.
   void run(ExecutorRef currentExecutor);
 };

include/swift/AST/DiagnosticsSema.def

@@ -4213,9 +4213,10 @@ ERROR(actor_isolated_concurrent_access,none,
         "actor-isolated %0 %1 is unsafe to reference in code "
         "that may execute concurrently",
         (DescriptiveDeclKind, DeclName))
-NOTE(actor_isolated_method,none,
-     "only asynchronous methods can be used outside the actor instance; "
-     "do you want to add 'async'?", ())
+NOTE(actor_isolated_sync_func,none,
+     "calls to %0 %1 from outside of its actor context are "
+     "implicitly asynchronous",
+     (DescriptiveDeclKind, DeclName))
 NOTE(actor_mutable_state,none,
      "mutable state is only available within the actor instance", ())
 WARNING(shared_mutable_state_access,none,

include/swift/AST/Expr.h

@@ -334,9 +334,10 @@ class alignas(8) Expr {
     NumCaptures : 32
   );
 
-  SWIFT_INLINE_BITFIELD(ApplyExpr, Expr, 1+1,
+  SWIFT_INLINE_BITFIELD(ApplyExpr, Expr, 1+1+1,
     ThrowsIsSet : 1,
-    Throws : 1
+    Throws : 1,
+    ImplicitlyAsync : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(CallExpr, ApplyExpr, 1+1+16,
@@ -4308,6 +4309,7 @@ class ApplyExpr : public Expr {
     assert(classof((Expr*)this) && "ApplyExpr::classof out of date");
     assert(validateArg(Arg) && "Arg is not a permitted expr kind");
     Bits.ApplyExpr.ThrowsIsSet = false;
+    Bits.ApplyExpr.ImplicitlyAsync = false;
   }
 
 public:
@@ -4346,6 +4348,29 @@ class ApplyExpr : public Expr {
     Bits.ApplyExpr.Throws = throws;
   }
 
+  /// Is this application _implicitly_ required to be an async call?
+  /// Note that this is _not_ a check for whether the callee is async!
+  /// Only meaningful after complete type-checking.
+  ///
+  /// Generally, this comes up only when we have a non-self call to an actor
+  /// instance's synchronous method. Such calls are conceptually treated as if
+  /// they are wrapped with an async closure. For example,
+  ///
+  ///   act.syncMethod(a, b) 
+  ///
+  /// is equivalent to the eta-expanded version of act.syncMethod,
+  ///
+  ///   { (a1, b1) async in act.syncMethod(a1, b1) }(a, b)
+  ///
+  /// where the new closure is declared to be async.
+  ///
+  bool implicitlyAsync() const {
+    return Bits.ApplyExpr.ImplicitlyAsync;
+  }
+  void setImplicitlyAsync(bool flag) {
+    Bits.ApplyExpr.ImplicitlyAsync = flag;
+  }
+
   ValueDecl *getCalledValue() const;
 
   /// Retrieve the argument labels provided at the call site.

include/swift/Basic/Fingerprint.h

@@ -124,7 +124,7 @@ class Fingerprint final {
   ///
   /// Very well, LLVM. A default value you shall have.
   friend class llvm::yaml::IO;
-  Fingerprint() : Core{DIGEST_LENGTH, '0'} {}
+  Fingerprint() : Core(DIGEST_LENGTH, '0') {}
 };
 
 void simple_display(llvm::raw_ostream &out, const Fingerprint &fp);

include/swift/Runtime/Concurrency.h

@@ -173,6 +173,10 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_removeStatusRecord(AsyncTask *task,
                                    TaskStatusRecord *record);
 
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+JobFlags
+swift_task_getJobFlags(AsyncTask* task);
+
 /// This should have the same representation as an enum like this:
 ///    enum NearestTaskDeadline {
 ///      case none

include/swift/SIL/SILInstruction.h

@@ -7689,10 +7689,16 @@ class BranchInst final
   unsigned getNumArgs() const { return getAllOperands().size(); }
   SILValue getArg(unsigned i) const { return getAllOperands()[i].get(); }
 
+  /// Return the SILPhiArgument for the given operand.
+  const SILPhiArgument *getArgForOperand(const Operand *oper) const {
+    auto *self = const_cast<BranchInst *>(this);
+    return self->getArgForOperand(oper);
+  }
+
   /// Return the SILPhiArgument for the given operand.
   ///
   /// See SILArgument.cpp.
-  const SILPhiArgument *getArgForOperand(const Operand *oper) const;
+  SILPhiArgument *getArgForOperand(const Operand *oper);
 };
 
 /// A conditional branch.

lib/IRGen/GenConstant.h

@@ -27,7 +27,7 @@ namespace irgen {
 /// Construct a ConstantInt from an IntegerLiteralInst.
 llvm::Constant *emitConstantInt(IRGenModule &IGM, IntegerLiteralInst *ILI);
 
-/// Construct a zero from a zero intializer BuiltinInst.
+/// Construct a zero from a zero initializer BuiltinInst.
 llvm::Constant *emitConstantZero(IRGenModule &IGM, BuiltinInst *Bi);
 
 /// Construct a ConstantFP from a FloatLiteralInst.

lib/IRGen/GenMeta.cpp

@@ -4162,13 +4162,18 @@ namespace {
                                  ConstantStructBuilder &B)
       : super(IGM, theStruct, B) {}
 
+    Size getExtraDataSize(StructMetadataLayout &layout) {
+      auto extraSize = layout.getSize().getOffsetToEnd() -
+                       IGM.getOffsetOfStructTypeSpecificMetadataMembers();
+      return extraSize;
+    }
+
     llvm::Value *emitAllocateMetadata(IRGenFunction &IGF,
                                       llvm::Value *descriptor,
                                       llvm::Value *arguments,
                                       llvm::Value *templatePointer) {
       auto &layout = IGM.getMetadataLayout(Target);
-      auto extraSize = layout.getSize().getOffsetToEnd()
-                         - IGM.getOffsetOfStructTypeSpecificMetadataMembers();
+      auto extraSize = getExtraDataSize(layout);
       auto extraSizeV = IGM.getSize(extraSize);
 
       // Sign the descriptor.
@@ -4236,6 +4241,7 @@ namespace {
     PartialPattern buildExtraDataPattern() {
       ConstantInitBuilder builder(IGM);
       auto init = builder.beginStruct();
+      init.setPacked(true);
 
       struct Scanner : StructMetadataScanner<Scanner> {
         GenericStructMetadataBuilder &Outer;
@@ -4280,10 +4286,9 @@ namespace {
       Offset zeroingEnd = offsetUpToTrailingFlags 
                             ? layout.getTrailingFlagsOffset()
                             : layout.getFieldOffsetVectorOffset();
-      return { global,
-               zeroingEnd.getStatic()
-                 - zeroingStart,
-               structSize };
+      auto offset = zeroingEnd.getStatic() - zeroingStart;
+      assert((offset + structSize) == getExtraDataSize(layout));
+      return {global, offset, structSize};
     }
 
     bool hasCompletionFunction() {
@@ -4559,13 +4564,18 @@ namespace {
                                ConstantStructBuilder &B)
       : super(IGM, theEnum, B) {}
 
+    Size getExtraDataSize(EnumMetadataLayout &layout) {
+      auto size = layout.getSize().getOffsetToEnd() -
+                  IGM.getOffsetOfEnumTypeSpecificMetadataMembers();
+      return size;
+    }
+
     llvm::Value *emitAllocateMetadata(IRGenFunction &IGF,
                                       llvm::Value *descriptor,
                                       llvm::Value *arguments,
                                       llvm::Value *templatePointer) {
       auto &layout = IGM.getMetadataLayout(Target);
-      auto extraSize = layout.getSize().getOffsetToEnd()
-                         - IGM.getOffsetOfEnumTypeSpecificMetadataMembers();
+      auto extraSize = getExtraDataSize(layout);
       auto extraSizeV = IGM.getSize(extraSize);
 
       // Sign the descriptor.
@@ -4604,6 +4614,7 @@ namespace {
     PartialPattern buildExtraDataPattern() {
       ConstantInitBuilder builder(IGM);
       auto init = builder.beginStruct();
+      init.setPacked(true);
 
       auto &layout = IGM.getMetadataLayout(Target);
 
@@ -4625,10 +4636,9 @@ namespace {
       Offset zeroingEnd = offsetUpToTrailingFlags 
                             ? layout.getTrailingFlagsOffset()
                             : layout.getPayloadSizeOffset();
-      return { global,
-               zeroingEnd.getStatic()
-                 - zeroingStart,
-               structSize };
+      auto offset = zeroingEnd.getStatic() - zeroingStart;
+      assert((offset + structSize) == getExtraDataSize(layout));
+      return {global, offset, structSize};
     }
 
     llvm::Constant *emitNominalTypeDescriptor() {

lib/IRGen/IRGenFunction.cpp

@@ -495,8 +495,6 @@ Address IRGenFunction::emitTaskAlloc(llvm::Value *size, Alignment alignment) {
   auto *call = Builder.CreateCall(IGM.getTaskAllocFn(), {getAsyncTask(), size});
   call->setDoesNotThrow();
   call->setCallingConv(IGM.SwiftCC);
-  call->addAttribute(llvm::AttributeList::FunctionIndex,
-                     llvm::Attribute::ReadNone);
   auto address = Address(call, alignment);
   return address;
 }

lib/Parse/ParsePattern.cpp

@@ -70,7 +70,7 @@ static ParserStatus parseDefaultArgument(
   SourceLoc equalLoc = P.consumeToken();
 
   if (P.SF.Kind == SourceFileKind::Interface) {
-    // Swift module interfaces don't synthesize inherited intializers and
+    // Swift module interfaces don't synthesize inherited initializers and
     // instead include them explicitly in subclasses. Since the
     // \c DefaultArgumentKind of these initializers is \c Inherited, this is
     // represented textually as `= super` in the interface.

lib/SIL/IR/SILArgument.cpp

@@ -300,7 +300,7 @@ TermInst *SILPhiArgument::getSingleTerminator() const {
   return const_cast<SILBasicBlock *>(predBlock)->getTerminator();
 }
 
-const SILPhiArgument *BranchInst::getArgForOperand(const Operand *oper) const {
+SILPhiArgument *BranchInst::getArgForOperand(const Operand *oper) {
   assert(oper->getUser() == this);
   return cast<SILPhiArgument>(
       getDestBB()->getArgument(oper->getOperandNumber()));