Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

Runtimes/Supplemental/Synchronization/CMakeLists.txt

@@ -141,6 +141,45 @@ target_link_libraries(swiftSynchronization PRIVATE
   $<$<PLATFORM_ID:Darwin>:swiftDarwin>
   $<$<PLATFORM_ID:Windows>:ClangModules>)
 
+if(WIN32 AND CMAKE_SYSTEM_PROCESSOR STREQUAL i686)
+  # FIXME(#83765) `-whole-module-optimization` should not be needed. However,
+  # without this, we will not properly optimize. On Windows i686 in particular,
+  # we observe the formation of `__atomic_load` calls rather than the expected
+  # native sequence.
+  cmake_policy(GET CMP0157 _PolicyCMP0157)
+  if(_PolicyCMP0157 STREQUAL NEW)
+    set_target_properties(swiftSynchronization PROPERTIES
+      Swift_COMPILATION_MODE wholemodule)
+  else()
+    target_compile_options(swiftSynchronization PRIVATE
+      $<$<COMPILE_LANGUAGE:Swift>:-whole-module-optimization>)
+  endif()
+
+  # WMO requires the early-swift-driver to be usable, which is not yet ready on
+  # Windows. Workaround this by creating an empty stub for swiftCore, removing
+  # the import library from the command line, and adding the library search path
+  # associated with it. Due to the autolink, we will still link against the
+  # library from the correct location but will also use an empty file for the
+  # additional input allowing us to perform the WMO.
+  if(CMAKE_Swift_COMPILER_USE_OLD_DRIVER)
+    get_target_property(_swiftCore_IMPORTED_IMPLIB_RELEASE swiftCore
+      IMPORTED_IMPLIB_RELEASE)
+    if(_swiftCore_IMPORTED_IMPLIB_RELEASE)
+      # Compute the library directory to allow us to find the import library by
+      # name.
+      get_filename_component(_swiftCore_IMPORTED_IMPLIB_RELEASE_DIRNAME
+        ${_swiftCore_IMPORTED_IMPLIB_RELEASE} DIRECTORY)
+      # Create a (empty) stub library
+      file(TOUCH "${CMAKE_CURRENT_BINARY_DIR}/swiftCoreStub.lib")
+      # Replace the import library with a stub to bypass the driver and frontend.
+      # Add the library search path to allow linking via autolinking.
+      set_target_properties(swiftCore PROPERTIES
+        IMPORTED_IMPLIB_RELEASE "${CMAKE_CURRENT_BINARY_DIR}/swiftCoreStub.lib"
+        INTERFACE_LINK_DIRECTORIES ${_swiftCore_IMPORTED_IMPLIB_RELEASE_DIRNAME})
+    endif()
+  endif()
+endif()
+
 install(TARGETS swiftSynchronization
   EXPORT SwiftSynchronizationTargets
   COMPONENT ${PROJECT_NAME}_runtime

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -109,7 +109,8 @@ private func optimizeObjectAllocation(allocRef: AllocRefInstBase, _ context: Fun
         type: allocRef.type, linkage: .private,
         // Only if it's a COW object we can be sure that the object allocated in the global is not mutated.
         // If someone wants to mutate it, it has to be copied first.
-        isLet: endOfInitInst is EndCOWMutationInst)
+        isLet: endOfInitInst is EndCOWMutationInst,
+        markedAsUsed: false)
 
   constructObject(of: allocRef, inInitializerOf: outlinedGlobal, storesToClassFields, storesToTailElements, context)
   context.erase(instructions: storesToClassFields)
@@ -555,7 +556,7 @@ private func replace(findStringCall: ApplyInst,
 
   // Create an "opaque" global variable which is passed as inout to
   // _findStringSwitchCaseWithCache and into which the function stores the "cache".
-  let cacheVar = context.createGlobalVariable(name: name, type: cacheType, linkage: .private, isLet: false)
+  let cacheVar = context.createGlobalVariable(name: name, type: cacheType, linkage: .private, isLet: false, markedAsUsed: false)
 
   let varBuilder = Builder(staticInitializerOf: cacheVar, context)
   let zero = varBuilder.createIntegerLiteral(0, type: wordTy)

SwiftCompilerSources/Sources/SIL/Context.swift

@@ -114,9 +114,10 @@ extension MutatingContext {
     _bridged.notifyChanges(.Effects)
   }
 
-  public func createGlobalVariable(name: String, type: Type, linkage: Linkage, isLet: Bool) -> GlobalVariable {
+  public func createGlobalVariable(name: String, type: Type, linkage: Linkage, isLet: Bool, markedAsUsed: Bool) -> GlobalVariable {
     let gv = name._withBridgedStringRef {
-      _bridged.createGlobalVariable($0, type.bridged, linkage.bridged, isLet)
+      _bridged.createGlobalVariable($0, type.bridged, linkage.bridged, isLet,
+                                    markedAsUsed)
     }
     return gv.globalVar
   }

include/swift/AST/Decl.h

@@ -1068,6 +1068,14 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// behaviors for it and, if it's an extension, its members.
   bool isObjCImplementation() const;
 
+  /// True if this declaration should never have its implementation made
+  /// available to any client. This overrides cross-module optimization and
+  /// optimizations that might use the implementation, such that the only
+  /// implementation of this function is the one compiled into its owning
+  /// module. Practically speaking, this prohibits serialization of the SIL
+  /// for this definition.
+  bool isNeverEmittedIntoClient() const;
+
   using AuxiliaryDeclCallback = llvm::function_ref<void(Decl *)>;
 
   /// Iterate over the auxiliary declarations for this declaration,

include/swift/AST/DeclAttr.def

@@ -201,7 +201,11 @@ SIMPLE_DECL_ATTR(requires_stored_property_inits, RequiresStoredPropertyInits,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | UnreachableInABIAttr,
   27)
 
-// Unused '28'
+SIMPLE_DECL_ATTR(_neverEmitIntoClient, NeverEmitIntoClient,
+  OnVar | OnSubscript | OnAbstractFunction,
+  UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
+  28)
+
 // Unused '29'
 
 SIMPLE_DECL_ATTR(nonobjc, NonObjC,

include/swift/AST/DiagnosticsClangImporter.def

@@ -261,11 +261,11 @@ ERROR(foreign_reference_types_invalid_retain_release, none,
 
 ERROR(foreign_reference_types_retain_non_void_or_self_return_type, none,
       "specified retain function '%0' is invalid; "
-      "retain function must have 'void' or parameter return type",
+      "retain function must either return have 'void', the reference count as an integer, or the parameter type",
       (StringRef))
 ERROR(foreign_reference_types_release_non_void_return_type, none,
       "specified release function '%0' is invalid; "
-      "release function must have 'void' return type",
+      "release function must either return 'void' or the reference count as an integer",
       (StringRef))
 ERROR(foreign_reference_types_retain_release_not_a_function_decl, none,
       "specified %select{retain|release}0 function '%1' is not a function",

include/swift/IRGen/Linking.h

@@ -1850,6 +1850,14 @@ class LinkEntity {
   bool isTypeKind() const { return isTypeKind(getKind()); }
 
   bool isAlwaysSharedLinkage() const;
+
+  /// Whether the link entity's definitions must be considered non-unique.
+  ///
+  /// This applies only in the Embedded Swift linkage model, and is used for
+  /// any symbols that have not been explicitly requested to have unique
+  /// definitions (e.g., with @_used).
+  bool hasNonUniqueDefinition() const;
+
 #undef LINKENTITY_GET_FIELD
 #undef LINKENTITY_SET_FIELD
 

include/swift/SIL/SILBridging.h

@@ -596,6 +596,8 @@ struct BridgedGlobalVar {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedStringRef getName() const;
   BRIDGED_INLINE bool isLet() const;
   BRIDGED_INLINE void setLet(bool value) const;
+  BRIDGED_INLINE bool markedAsUsed() const;
+  BRIDGED_INLINE void setMarkedAsUsed(bool value) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedType getType() const;
   BRIDGED_INLINE BridgedLinkage getLinkage() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE swift::SourceLoc getSourceLocation() const;
@@ -1449,7 +1451,8 @@ struct BridgedContext {
                                                           bool hasSelfParam,
                                                           BridgedFunction fromFunc) const;
   SWIFT_IMPORT_UNSAFE BridgedGlobalVar createGlobalVariable(BridgedStringRef name, BridgedType type,
-                                                            BridgedLinkage linkage, bool isLet) const;
+                                                            BridgedLinkage linkage, bool isLet,
+                                                            bool markedAsUsed) const;
   void moveFunctionBody(BridgedFunction sourceFunc, BridgedFunction destFunc) const;
 
   // Function-local SIL modifications

include/swift/SIL/SILBridgingImpl.h

@@ -932,6 +932,14 @@ bool BridgedGlobalVar::isLet() const { return getGlobal()->isLet(); }
 
 void BridgedGlobalVar::setLet(bool value) const { getGlobal()->setLet(value); }
 
+bool BridgedGlobalVar::markedAsUsed() const {
+  return getGlobal()->markedAsUsed();
+}
+
+void BridgedGlobalVar::setMarkedAsUsed(bool value) const {
+  getGlobal()->setMarkedAsUsed(value);
+}
+
 BridgedType BridgedGlobalVar::getType() const {
   return getGlobal()->getLoweredType();
 }

include/swift/SIL/SILDeclRef.h

@@ -399,6 +399,14 @@ struct SILDeclRef {
   /// True if the function has the @backDeployed attribute.
   bool isBackDeployed() const;
 
+  /// True if this entity should have a non-unique definition based on the
+  /// embedded linkage model.
+  bool hasNonUniqueDefinition() const;
+
+  /// True if the declaration should have a non-unique definition based on the
+  /// embedded linkage model.
+  static bool declHasNonUniqueDefinition(const ValueDecl *decl);
+
   /// Return the expected linkage for a definition of this declaration.
   SILLinkage getDefinitionLinkage() const;