Merge pull request #4240 from swiftwasm/maxd/main-merge

Fix build issues with upstream `main`

Author: MaxDesiatov

CMakeLists.txt

@@ -192,6 +192,13 @@ set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
     option only affects the tools that run on the host (the compiler), and has
     no effect on the target libraries (the standard library and the runtime).")
 
+option(SWIFT_TOOLS_LD64_LTO_CODEGEN_ONLY_FOR_SUPPORTING_TARGETS
+    "When building ThinLTO using ld64 on Darwin, controls whether to opt out of
+    LLVM IR optimizations when linking targets that will get
+    little benefit from it (e.g. tools for bootstrapping or
+    debugging Swift)"
+    FALSE)
+
 option(BOOTSTRAPPING_MODE [=[
 How to build the swift compiler modules. Possible values are
     OFF:           build without swift modules

cmake/modules/AddSwift.cmake

@@ -638,7 +638,7 @@ macro(add_swift_lib_subdirectory name)
 endmacro()
 
 function(add_swift_host_tool executable)
-  set(options HAS_SWIFT_MODULES)
+  set(options HAS_SWIFT_MODULES THINLTO_LD64_ADD_FLTO_CODEGEN_ONLY)
   set(single_parameter_options SWIFT_COMPONENT BOOTSTRAPPING)
   set(multiple_parameter_options LLVM_LINK_COMPONENTS)
 
@@ -861,6 +861,19 @@ function(add_swift_host_tool executable)
     endif()
   endif()
 
+  if(ASHT_THINLTO_LD64_ADD_FLTO_CODEGEN_ONLY)
+    string(CONCAT lto_codegen_only_link_options
+      "$<"
+        "$<AND:"
+          "$<BOOL:${LLVM_LINKER_IS_LD64}>,"
+          "$<BOOL:${SWIFT_TOOLS_LD64_LTO_CODEGEN_ONLY_FOR_SUPPORTING_TARGETS}>,"
+          "$<STREQUAL:${SWIFT_TOOLS_ENABLE_LTO},thin>"
+        ">:"
+        "LINKER:-flto-codegen-only"
+      ">")
+    target_link_options(${executable} PRIVATE "${lto_codegen_only_link_options}")
+  endif()
+
   if(NOT ${ASHT_SWIFT_COMPONENT} STREQUAL "no_component")
     add_dependencies(${ASHT_SWIFT_COMPONENT} ${executable})
     swift_install_in_component(TARGETS ${executable}

cmake/modules/UnixCompileRules.cmake

@@ -11,3 +11,20 @@ set(CMAKE_C_ARCHIVE_FINISH "")
 set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> crs <TARGET> <LINK_FLAGS> <OBJECTS>")
 set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qs <TARGET> <LINK_FLAGS> <OBJECTS>")
 set(CMAKE_CXX_ARCHIVE_FINISH "")
+
+# When archiving LTO-based .o files with ar/ranlib/libtool on Darwin, the tools
+# use libLTO.dylib to inspect the bitcode files. However, by default the
+# "host" libLTO.dylib is loaded, which might be too old and not understand our
+# just-built bitcode format. So let's instead ask ar/ranlib/libtool to use the
+# just-built libLTO.dylib from the toolchain that we're using to build.
+if(APPLE AND SWIFT_NATIVE_CLANG_TOOLS_PATH)
+  set(liblto_path "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/../lib/libLTO.dylib")
+
+  set(CMAKE_C_ARCHIVE_CREATE "${CMAKE_COMMAND} -E env LIBLTO_PATH=${liblto_path} <CMAKE_AR> crs <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_C_ARCHIVE_APPEND "${CMAKE_COMMAND} -E env LIBLTO_PATH=${liblto_path} <CMAKE_AR> qs <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_C_ARCHIVE_FINISH "")
+
+  set(CMAKE_CXX_ARCHIVE_CREATE "${CMAKE_COMMAND} -E env LIBLTO_PATH=${liblto_path} <CMAKE_AR> crs <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_CXX_ARCHIVE_APPEND "${CMAKE_COMMAND} -E env LIBLTO_PATH=${liblto_path} <CMAKE_AR> qs <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_CXX_ARCHIVE_FINISH "")
+endif()

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -39,6 +39,15 @@ Most notably, default argument expressions are implicitly
 `@_alwaysEmitIntoClient`, which means that adding a default argument to a
 function which did not have one previously does not break ABI.
 
+## `@_backDeploy(availabilitySpec ...)`
+
+Causes the body of a function to be emitted into the module interface to be
+available for inlining in clients with deployment targets lower than the formal
+availability of the function. When inlined, the body of the function is
+transformed such that it calls the library's copy of the function if it is
+available at runtime. Otherwise, the copy of the original function body is
+executed.
+
 ## `@_assemblyVision`
 
 Forces emission of assembly vision remarks for a function or method, showing

include/swift/ABI/ObjectFile.h

@@ -66,12 +66,7 @@ class SwiftObjectFileFormatMachO : public SwiftObjectFileFormat {
   }
 
   bool sectionContainsReflectionData(llvm::StringRef sectionName) override {
-    // For Mach-O, the caller must call this function twice, once with just the
-    // section name (ex `__swift5_fieldmd`), and again with the segment
-    // qualified section name (ex `__DATA,__const`).
-    return sectionName.startswith("__swift5_") ||
-           sectionName == "__DATA_CONST,__const" ||
-           sectionName == "__DATA,__const";
+    return sectionName.startswith("__swift5_") || sectionName == "__const";
   }
 };
 

include/swift/ABI/Task.h

@@ -290,23 +290,35 @@ class AsyncTask : public Job {
     return ResumeTask(ResumeContext); // 'return' forces tail call
   }
 
+  /// A task can have the following states:
+  ///   * suspended: In this state, a task is considered not runnable
+  ///   * enqueued: In this state, a task is considered runnable
+  ///   * running on a thread
+  ///   * completed
+  ///
+  /// The following state transitions are possible:
+  ///       suspended -> enqueued
+  ///       suspended -> running
+  ///       enqueued -> running
+  ///       running -> suspended
+  ///       running -> completed
+  ///       running -> enqueued
+  ///
+  /// The 4 methods below are how a task switches from one state to another.
+
   /// Flag that this task is now running.  This can update
   /// the priority stored in the job flags if the priority has been
   /// escalated.
   ///
   /// Generally this should be done immediately after updating
   /// ActiveTask.
   void flagAsRunning();
-  void flagAsRunning_slow();
-
-  /// Flag that this task is now suspended.  This can update the
-  /// priority stored in the job flags if the priority hsa been
-  /// escalated.  Generally this should be done immediately after
-  /// clearing ActiveTask and immediately before enqueuing the task
-  /// somewhere.  TODO: record where the task is enqueued if
-  /// possible.
+
+  /// Flag that this task is now suspended.
   void flagAsSuspended();
-  void flagAsSuspended_slow();
+
+  /// Flag that the task is to be enqueued on the provided executor
+  void flagAsEnqueuedOnExecutor(ExecutorRef newExecutor);
 
   /// Flag that this task is now completed. This normally does not do anything
   /// but can be used to locally insert logging.

include/swift/AST/ArgumentList.h

@@ -249,11 +249,13 @@ class alignas(Argument) ArgumentList final
   static ArgumentList *
   createImplicit(ASTContext &ctx, SourceLoc lParenLoc, ArrayRef<Argument> args,
                  SourceLoc rParenLoc,
+                 Optional<unsigned> firstTrailingClosureIndex = None,
                  AllocationArena arena = AllocationArena::Permanent);
 
   /// Create a new implicit ArgumentList with a set of \p args.
   static ArgumentList *
   createImplicit(ASTContext &ctx, ArrayRef<Argument> args,
+                 Optional<unsigned> firstTrailingClosureIndex = None,
                  AllocationArena arena = AllocationArena::Permanent);
 
   /// Create a new implicit ArgumentList with a single labeled argument

include/swift/AST/Attr.def

@@ -651,7 +651,7 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
 // 117 was 'spawn' and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
-  DeclModifier | OnClass | OnFunc |
+  DeclModifier | OnClass | OnFunc | OnVar |
   DistributedOnly |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
@@ -713,6 +713,12 @@ DECL_ATTR(exclusivity, Exclusivity,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   128)
 
+DECL_ATTR(_backDeploy, BackDeploy,
+  OnAbstractFunction |
+  AllowMultipleAttributes | LongAttribute | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
+  129)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Attr.h

@@ -2172,6 +2172,30 @@ class UnavailableFromAsyncAttr : public DeclAttribute {
   }
 };
 
+/// The @_backDeploy(...) attribute, used to make function declarations available
+/// for back deployment to older OSes via emission into the client binary.
+class BackDeployAttr: public DeclAttribute {
+public:
+  BackDeployAttr(SourceLoc AtLoc, SourceRange Range,
+                 PlatformKind Platform,
+                 const llvm::VersionTuple Version,
+                 bool Implicit)
+    : DeclAttribute(DAK_BackDeploy, AtLoc, Range, Implicit),
+      Platform(Platform),
+      Version(Version) {}
+
+  /// The platform the symbol is available for back deployment on.
+  const PlatformKind Platform;
+
+  /// The earliest platform version that may use the back deployed implementation.
+  const llvm::VersionTuple Version;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_BackDeploy;
+  }
+};
+
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/Decl.h

@@ -144,6 +144,7 @@ enum class DescriptiveDeclKind : uint8_t {
   Property,
   StaticProperty,
   ClassProperty,
+  DistributedProperty,
   InfixOperator,
   PrefixOperator,
   PostfixOperator,
@@ -5240,6 +5241,9 @@ class VarDecl : public AbstractStorageDecl {
   /// Is this an "async let" property?
   bool isAsyncLet() const;
 
+  /// Does this have a 'distributed' modifier?
+  bool isDistributed() const;
+
   /// Is this a stored property that will _not_ trigger any user-defined code
   /// upon any kind of access?
   bool isOrdinaryStoredProperty() const;