Merge branch 'apple:main' into autodiff-fix-generic-param-decl-verification

Author: astrotuna201

CMakeLists.txt

@@ -250,6 +250,10 @@ option(SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER
        "Use the host compiler and not the internal clang to build the swift runtime"
        FALSE)
 
+option(SWIFT_RUN_TESTS_WITH_HOST_COMPILER
+       "Run tests against the host compiler and not the just built swift"
+       FALSE)
+
 set(SWIFT_SDKS "" CACHE STRING
     "If non-empty, limits building target binaries only to specified SDKs (despite other SDKs being available)")
 

benchmark/single-source/BufferFill.swift

@@ -28,6 +28,11 @@ public let BufferFill = [
                 tags: [.validation, .api],
                 setUpFunction: rawBufferInitializeMemorySetup,
                 tearDownFunction: rawBufferInitializeMemoryTeardown),
+  BenchmarkInfo(name: "RawBuffer.copyContents",
+                runFunction: rawBufferCopyContentsExecute,
+                tags: [.validation, .api],
+                setUpFunction: rawBufferCopyContentsSetup,
+                tearDownFunction: rawBufferCopyContentsTeardown),
 ]
 
 let c = 100_000
@@ -119,3 +124,43 @@ public func rawBufferInitializeMemoryExecute(n: Int) {
   let value = offset.load(as: Int.self)
   CheckResults(value == a[r])
 }
+
+var r8: UnsafeRawBufferPointer = .init(start: nil, count: 0)
+var b8: UnsafeMutableBufferPointer<UInt8> = .init(start: nil, count: 0)
+
+public func rawBufferCopyContentsSetup() {
+  assert(r8.baseAddress == nil)
+  let count = a.count * MemoryLayout<Int>.stride
+  let rb = UnsafeMutableRawBufferPointer.allocate(
+    byteCount: count, 
+    alignment: MemoryLayout<Int>.alignment)
+  a.withUnsafeBytes {
+    rb.copyMemory(from: $0)
+  }
+  r8 = UnsafeRawBufferPointer(rb)
+  assert(b8.baseAddress == nil)
+  b8 = .allocate(capacity: rb.count)
+  r = rb.indices.randomElement()!
+}
+
+public func rawBufferCopyContentsTeardown() {
+  r8.deallocate()
+  r8 = .init(start: nil, count: 0)
+  b8.deallocate()
+  b8 = .init(start: nil, count: 0)
+}
+
+@inline(never)
+public func rawBufferCopyContentsExecute(n: Int) {
+  // Measure performance of copying bytes from an
+  // `UnsafeRawBufferPointer` to an `UnsafeMutableBufferPointer<UInt8>`.
+  // See: https://bugs.swift.org/browse/SR-9604
+
+  for _ in 0..<n {
+    var (iterator, initialized) = b8.initialize(from: r8)
+    blackHole(b8)
+    CheckResults(initialized == r8.count && iterator.next() == nil)
+  }
+
+  CheckResults(b8[r] == r8[r])
+}

benchmark/single-source/ObjectiveCBridgingStubs.swift

@@ -18,6 +18,7 @@ import ObjectiveCTests
 
 let t: [BenchmarkCategory] = [.validation, .bridging]
 let ts: [BenchmarkCategory] = [.validation, .String, .bridging]
+let bs: [BenchmarkCategory] = [.String, .bridging]
 
 public let ObjectiveCBridgingStubs = [
   BenchmarkInfo(name: "ObjectiveCBridgeStubDataAppend",
@@ -68,9 +69,24 @@ public let ObjectiveCBridgingStubs = [
   BenchmarkInfo(name: "ObjectiveCBridgeStringGetUTF8Contents",
     runFunction: run_ObjectiveCBridgeStringGetUTF8Contents, tags: ts,
     setUpFunction: setup_StringBridgeBenchmark),
-  BenchmarkInfo(name: "ObjectiveCBridgeStringRangeOfString",
+  BenchmarkInfo(name: "ObjectiveCBridgeStringRangeOfString", //should be BridgeString.find.mixed
     runFunction: run_ObjectiveCBridgeStringRangeOfString, tags: ts,
     setUpFunction: setup_StringBridgeBenchmark),
+  BenchmarkInfo(name: "BridgeString.find.native",
+    runFunction: run_ObjectiveCBridgeStringRangeOfStringAllSwift, tags: bs,
+    setUpFunction: setup_SpecificRangeOfStringBridging),
+  BenchmarkInfo(name: "BridgeString.find.native.nonASCII",
+    runFunction: run_ObjectiveCBridgeStringRangeOfStringAllSwiftNonASCII, tags: bs,
+    setUpFunction: setup_SpecificRangeOfStringBridging),
+  BenchmarkInfo(name: "BridgeString.find.native.long",
+    runFunction: run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystack, tags: bs,
+    setUpFunction: setup_SpecificRangeOfStringBridging),
+  BenchmarkInfo(name: "BridgeString.find.native.longBoth",
+    runFunction: run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystackLongNeedle, tags: bs,
+    setUpFunction: setup_SpecificRangeOfStringBridging),
+  BenchmarkInfo(name: "BridgeString.find.native.longNonASCII",
+    runFunction: run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystackNonASCII, tags: bs,
+    setUpFunction: setup_SpecificRangeOfStringBridging),
   BenchmarkInfo(name: "ObjectiveCBridgeStringHash",
     runFunction: run_ObjectiveCBridgeStringHash, tags: ts,
     setUpFunction: setup_StringBridgeBenchmark),
@@ -408,6 +424,47 @@ public func run_ObjectiveCBridgeStringRangeOfString(N: Int) {
   #endif
 }
 
+@inline(__always)
+func run_rangeOfStringSpecific(needle: String, haystack: String, N: Int) {
+#if _runtime(_ObjC)
+  b.testRangeOfStringSpecific(withNeedle: needle, haystack: haystack, n: N)
+#endif
+}
+
+@inline(never)
+public func run_ObjectiveCBridgeStringRangeOfStringAllSwift(N: Int) {
+  run_rangeOfStringSpecific(needle: "y", haystack: "The quick brown fox jumps over the lazy dog", N: 100 * N)
+}
+
+var longNativeASCII: String! = nil
+var longNativeNonASCII: String! = nil
+public func setup_SpecificRangeOfStringBridging() {
+  setup_StringBridgeBenchmark()
+  longNativeASCII = Array(repeating: "The quick brown fox jump over the lazy dog", count: 1000).joined() + "s"
+  longNativeNonASCII = "ü" + longNativeASCII + "ö"
+  
+}
+
+@inline(never)
+public func run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystack(N: Int) {
+  run_rangeOfStringSpecific(needle: "s", haystack: longNativeASCII, N: N)
+}
+
+@inline(never)
+public func run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystackNonASCII(N: Int) {
+  run_rangeOfStringSpecific(needle: "s", haystack: longNativeNonASCII, N: N)
+}
+
+@inline(never)
+public func run_ObjectiveCBridgeStringRangeOfStringAllSwiftNonASCII(N: Int) {
+  run_rangeOfStringSpecific(needle: "ü", haystack: "The quick brown fox jump over the lazy dogü", N: 100 * N)
+}
+
+@inline(never)
+public func run_ObjectiveCBridgeStringRangeOfStringAllSwiftLongHaystackLongNeedle(N: Int) {
+  run_rangeOfStringSpecific(needle: "The quick brown fox jump over the lazy dogs", haystack: longNativeASCII, N: N)
+}
+
 @inline(never)
 public func run_ObjectiveCBridgeStringHash(N: Int) {
   #if _runtime(_ObjC)

benchmark/utils/ObjectiveCTests/ObjectiveCTests.h

@@ -42,6 +42,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)testGetUTF8Contents;
 - (void)testGetASCIIContents;
 - (void)testRangeOfString;
+- (void)testRangeOfStringSpecificWithNeedle:(NSString *)needle
+                                   haystack:(NSString *)haystack
+                                          n:(NSInteger)n;
 - (void)testHash;
 - (void)testCompare;
 - (void)testCompare2;

benchmark/utils/ObjectiveCTests/ObjectiveCTests.m

@@ -307,6 +307,14 @@ - (void)testRangeOfString {
   };
 }
 
+- (void)testRangeOfStringSpecificWithNeedle:(NSString *)needle
+                                   haystack:(NSString *)haystack
+                                          n:(NSInteger)n {
+  for (int i = 0; i < n; i++) {
+    (void)[haystack rangeOfString:needle];
+  }
+}
+
 - (void) testHash {
   for (NSString *str1 in bridgedStrings) {
     @autoreleasepool {

cmake/modules/AddSwift.cmake

@@ -7,9 +7,11 @@ include(SwiftAndroidSupport)
 function(_swift_gyb_target_sources target scope)
   file(GLOB GYB_UNICODE_DATA ${SWIFT_SOURCE_DIR}/utils/UnicodeData/*)
   file(GLOB GYB_STDLIB_SUPPORT ${SWIFT_SOURCE_DIR}/utils/gyb_stdlib_support.py)
-  file(GLOB GYB_SYNTAX_SUPPORT ${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/*)
-  file(GLOB GYB_SOURCEKIT_SUPPORT ${SWIFT_SOURCE_DIR}/utils/gyb_sourcekit_support/*)
+  file(GLOB GYB_SYNTAX_SUPPORT ${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/*.py)
+  file(GLOB GYB_SOURCEKIT_SUPPORT ${SWIFT_SOURCE_DIR}/utils/gyb_sourcekit_support/*.py)
   set(GYB_SOURCES
+    ${SWIFT_SOURCE_DIR}/utils/gyb
+    ${SWIFT_SOURCE_DIR}/utils/gyb.py
     ${SWIFT_SOURCE_DIR}/utils/GYBUnicodeDataUtils.py
     ${SWIFT_SOURCE_DIR}/utils/SwiftIntTypes.py
     ${GYB_UNICODE_DATA}

cmake/modules/SwiftHandleGybSources.cmake

@@ -77,7 +77,8 @@ endfunction()
 # handle_gyb_sources(
 #     dependency_out_var_name
 #     sources_var_name
-#     arch)
+#     [ARCH arch]
+#     [DEPENDS [depends ...]])
 #
 # Replace, in ${sources_var_name}, the given .gyb-suffixed sources with
 # their un-suffixed intermediate files, which will be generated by processing
@@ -93,11 +94,21 @@ endfunction()
 #   false, the files are architecture-independent and will be emitted
 #   into ${CMAKE_CURRENT_BINARY_DIR} instead of an architecture-specific
 #   destination; this is useful for generated include files.
-function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
+#
+# depends
+#   Additional file dependencies beyond the standard dependencies that all gyb
+#   invocations get.
+function(handle_gyb_sources dependency_out_var_name sources_var_name)
+  set(options)
+  set(single_value_args ARCH)
+  set(multi_value_args DEPENDS)
+  cmake_parse_arguments(GYB
+    "${options}" "${single_value_args}" "${multi_value_args}" ${ARGN})
+
   set(extra_gyb_flags "")
-  if (arch)
+  if (GYB_ARCH)
     set_if_arch_bitness(ptr_size
-      ARCH "${arch}"
+      ARCH "${GYB_ARCH}"
       CASE_32_BIT "4"
       CASE_64_BIT "8")
     set(extra_gyb_flags "-DCMAKE_SIZEOF_VOID_P=${ptr_size}")
@@ -141,7 +152,7 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
       set(dir_root ${CMAKE_CURRENT_BINARY_DIR})
     endif()
 
-    if (arch)
+    if (GYB_ARCH)
       set(dir "${dir_root}/${ptr_size}")
     else()
       set(dir "${dir_root}")
@@ -154,7 +165,7 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
         SOURCE "${src}"
         OUTPUT "${output_file_name}"
         FLAGS ${extra_gyb_flags}
-        DEPENDS "${gyb_extra_sources}"
+        DEPENDS "${GYB_DEPENDS}" "${gyb_extra_sources}"
         COMMENT "with ptr size = ${ptr_size}")
     list(APPEND dependency_targets "${dependency_target}")
   endforeach()
@@ -163,13 +174,7 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
 endfunction()
 
 function(add_gyb_target target sources)
-  set(options)
-  set(single_value_args ARCH)
-  set(multi_value_args)
-  cmake_parse_arguments(GYB
-    "${options}" "${single_value_args}" "${multi_value_args}" ${ARGN})
-
-  handle_gyb_sources(gyb_sources_depends sources "${GYB_ARCH}")
+  handle_gyb_sources(gyb_sources_depends sources ${ARGN})
 
   add_custom_target(${target}
     DEPENDS "${gyb_sources_depends}")

docs/CppInteroperabilityManifesto.md

@@ -407,13 +407,13 @@ void printInt(const int &value);
 ```swift
 // C++ header imported in Swift.
 
-void printInt(_ value: UnsafePointer<Int>)
+func printInt(_ value: UnsafePointer<Int>)
 ```
 
 ```swift
 // Usage example.
 
-void caller() {
+func caller() {
   var x = 42
   printInt(&x) // OK
 
@@ -450,13 +450,13 @@ void printInt(const int &value);
 ```swift
 // C++ header imported in Swift.
 
-void printInt(_ value: Int)
+func printInt(_ value: Int)
 ```
 
 ```swift
 // Usage example.
 
-void caller() {
+func caller() {
   let x = 42
   printInt(y) // OK
 }

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -39,6 +39,14 @@ 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.
 
+## `@_assemblyVision`
+
+Forces emission of assembly vision remarks for a function or method, showing
+where various runtime calls and performance impacting hazards are in the code
+at source level after optimization.
+
+Adding this attribute to a type leads to remarks being emitted for all methods.
+
 ## `@_borrowed`
 
 Indicates that the [conservative access pattern](/docs/Lexicon.md#access-pattern)
@@ -95,15 +103,15 @@ extension Text {
 }
 ```
 
-## `@_dynamicReplacement(for:)`
+## `@_dynamicReplacement(for: targetFunc(label:))`
 
 Marks a function as the dynamic replacement for another `dynamic` function.
 This is similar to method swizzling in other languages such as Objective-C,
 except that the replacement happens at program start (or loading a shared
 library), instead of at an arbitrary point in time.
 
 For more details, see the forum post on
-[Dynamic method replacement](https://forums.swift.org/t/dynamic-method-replacement/16619).
+[dynamic method replacement](https://forums.swift.org/t/dynamic-method-replacement/16619).
 
 ## `@_distributedActorIndependent`
 
@@ -124,7 +132,7 @@ already infer from static analysis.
 Changing the implementation in a way that violates the optimizer's assumptions
 about the effects results in undefined behavior.
 
-For more details, see [OptimizerEffects.rst](/docs/Proposals/OptimizerEffects.rst).
+For more details, see [OptimizerEffects.rst](/docs/proposals/OptimizerEffects.rst).
 
 ## `@_exported`
 
@@ -134,7 +142,7 @@ This attribute is most commonly used by overlays.
 
 ```swift
 // module M
-func f() {}
+public func f() {}
 
 // module N
 @_exported import M
@@ -264,17 +272,12 @@ class C {
 
 (Note that it is "inherit", not "inherits", unlike below.)
 
-Marks that a `@Sendable async` closure argument should inherited the actor
+Marks that a `@Sendable async` closure argument should inherit the actor
 context (i.e. what actor it should be run on) based on the declaration site
 of the closure. This is different from the typical behavior, where the closure
 may be runnable anywhere unless its type specifically declares that it will
 run on a specific actor.
 
-This new attribute can be used on parameters of `@Sendable async` type
-to indicate that the closures arguments passed to such parameters
-should inherit the actor context where they are formed, which is not
-the normal behavior for `@Sendable` closures.
-
 ## `@_inheritsConvenienceInitializers`
 
 An attribute that signals that a class declaration inherits its convenience
@@ -289,7 +292,6 @@ Indicates that a protocol is a marker protocol. Marker protocols represent some
 meaningful property at compile-time but have no runtime representation.
 
 For more details, see [SE-0302](https://github.com/apple/swift-evolution/blob/main/proposals/0302-concurrent-value-and-concurrent-closures.md#marker-protocols), which introduces marker protocols.
-
 At the moment, the language only has one marker protocol: `Sendable`.
 
 Fun fact: Rust has a very similar concept called

docs/SIL.rst

@@ -3505,6 +3505,7 @@ The operand must have loadable type.
    debug-var-attr ::= 'let'
    debug-var-attr ::= 'name' string-literal
    debug-var-attr ::= 'argno' integer-literal
+   debug-var-attr ::= 'implicit'
 
 ::
 
@@ -3520,12 +3521,13 @@ The operand must have loadable type.
 There are a number of attributes that provide details about the source
 variable that is being described, including the name of the
 variable. For function and closure arguments ``argno`` is the number
-of the function argument starting with 1. The advanced debug variable
-attributes represent source locations and type of the source variable
-when it was originally declared. It is useful when we're indirectly
-associating the SSA value with the source variable (via di-expression,
-for example) in which case SSA value's type is different from that of
-source variable.
+of the function argument starting with 1. A compiler-generated source
+variable will be marked ``implicit`` and optimizers are free to remove
+it even in -Onone. The advanced debug variable attributes represent source
+locations and type of the source variable when it was originally declared.
+It is useful when we're indirectly associating the SSA value with the
+source variable (via di-expression, for example) in which case SSA value's
+type is different from that of source variable.
 
 If the '[poison]' flag is set, then all references within this debug
 value will be overwritten with a sentinel at this point in the