tensorflow merge (2020-06-09)

benchmark/CMakeLists.txt

@@ -108,6 +108,7 @@ set(SWIFT_BENCH_MODULES
     single-source/LuhnAlgoLazy
     single-source/MapReduce
     single-source/Memset
+    single-source/Mirror
     single-source/MonteCarloE
     single-source/MonteCarloPi
     single-source/NSDictionaryCastToSwift

benchmark/single-source/Mirror.swift

@@ -0,0 +1,105 @@
+//===--- Mirror.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 test measures performance of Mirror and related things.
+import TestsUtils
+
+public let TypeName = BenchmarkInfo(
+  name: "TypeName",
+  runFunction: run_TypeName,
+  tags: [.api, .String])
+
+public let MirrorDefault = BenchmarkInfo(
+  name: "MirrorDefault",
+  runFunction: run_MirrorDefault,
+  tags: [.api, .String])
+
+struct S1 { var s: String; var d: Double }
+struct S2 { var i: Int; var a: [Range<Int>] }
+
+class C { var i: Int = 0 }
+class D: C { var s: String = "" }
+
+enum E {
+  case a,b(Int)
+}
+
+struct G<T> { var t: T }
+class H<T>: C { var t: T; init(_ t: T) { self.t = t }}
+
+public func run_MirrorDefault(scale: Int) {
+  let N = 100*scale
+
+  let s1 = S1(s: "foo", d: 3.14)
+  let s2 = S2(i: 42, a: [0..<4])
+  let c = C()
+  let d = D()
+  let e = E.a
+  let f = E.b(99)
+  let g = G(t: 12.3)
+  let h = H<[Int]>([1,2,3])
+
+  var str = ""
+
+  for _ in 0..<N {
+    str = "\(s1),\(s2),\(c),\(d),\(e),\(f),\(g),\(h)"
+    blackHole(str)
+  }
+
+  CheckResults(str ==
+    "S1(s: \"foo\", d: 3.14),S2(i: 42, a: [Range(0..<4)]),Mirror.C,Mirror.D,a,b(99),G<Double>(t: 12.3),Mirror.H<Swift.Array<Swift.Int>>")
+}
+
+func typename<T>(of: T.Type) -> String {
+  "\(T.self)"
+}
+
+public func run_TypeName(scale: Int) {
+  let N = 1_000*scale
+  var a: [String] = []
+  a.reserveCapacity(16)
+
+  for _ in 0..<N {
+    a = []
+    a.removeAll(keepingCapacity: true)
+    a.append(typename(of: S1.self))
+    a.append(typename(of: S2.self))
+    a.append(typename(of: C.self))
+    a.append(typename(of: D.self))
+    a.append(typename(of: G<S1>.self))
+    a.append(typename(of: G<C>.self))
+    a.append(typename(of: G<String>.self))
+    a.append(typename(of: H<Int>.self))
+    a.append(typename(of: [S1].self))
+    a.append(typename(of: [G<Int>].self))
+    a.append(typename(of: [H<S1>].self))
+    a.append(typename(of: S1?.self))
+    a.append(typename(of: C?.self))
+    blackHole(a)
+  }
+
+  let expected = ["S1",
+    "S2",
+    "C",
+    "D",
+    "G<S1>",
+    "G<C>",
+    "G<String>",
+    "H<Int>",
+    "Array<S1>",
+    "Array<G<Int>>",
+    "Array<H<S1>>",
+    "Optional<S1>",
+    "Optional<C>",
+  ]
+  CheckResults(a == expected)
+}

benchmark/utils/main.swift

@@ -96,6 +96,7 @@ import LuhnAlgoEager
 import LuhnAlgoLazy
 import MapReduce
 import Memset
+import Mirror
 import MonteCarloE
 import MonteCarloPi
 import NibbleSort
@@ -281,6 +282,7 @@ registerBenchmark(LuhnAlgoEager)
 registerBenchmark(LuhnAlgoLazy)
 registerBenchmark(MapReduce)
 registerBenchmark(Memset)
+registerBenchmark(MirrorDefault)
 registerBenchmark(MonteCarloE)
 registerBenchmark(MonteCarloPi)
 registerBenchmark(NSDictionaryCastToSwift)
@@ -366,6 +368,7 @@ registerBenchmark(Suffix)
 registerBenchmark(SuperChars)
 registerBenchmark(TwoSum)
 registerBenchmark(TypeFlood)
+registerBenchmark(TypeName)
 registerBenchmark(UTF8Decode)
 registerBenchmark(Walsh)
 registerBenchmark(WordCount)

cmake/modules/AddSwift.cmake

@@ -75,25 +75,10 @@ function(_set_target_prefix_and_suffix target kind sdk)
   endif()
 endfunction()
 
-function(is_darwin_based_sdk sdk_name out_var)
-  if ("${sdk_name}" STREQUAL "OSX" OR
-      "${sdk_name}" STREQUAL "IOS" OR
-      "${sdk_name}" STREQUAL "IOS_SIMULATOR" OR
-      "${sdk_name}" STREQUAL "TVOS" OR
-      "${sdk_name}" STREQUAL "TVOS_SIMULATOR" OR
-      "${sdk_name}" STREQUAL "WATCHOS" OR
-      "${sdk_name}" STREQUAL "WATCHOS_SIMULATOR")
-    set(${out_var} TRUE PARENT_SCOPE)
-  else()
-    set(${out_var} FALSE PARENT_SCOPE)
-  endif()
-endfunction()
-
 # Usage:
 # _add_host_variant_c_compile_link_flags(name)
 function(_add_host_variant_c_compile_link_flags name)
-  is_darwin_based_sdk("${SWIFT_HOST_VARIANT_SDK}" IS_DARWIN)
-  if(IS_DARWIN)
+  if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
     set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
   endif()
 
@@ -107,7 +92,7 @@ function(_add_host_variant_c_compile_link_flags name)
 
   set(_sysroot
     "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
-  if(IS_DARWIN)
+  if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
     target_compile_options(${name} PRIVATE -isysroot;${_sysroot})
   elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${_sysroot}" STREQUAL "/")
     target_compile_options(${name} PRIVATE --sysroot=${_sysroot})
@@ -122,7 +107,7 @@ function(_add_host_variant_c_compile_link_flags name)
     endif()
   endif()
 
-  if(IS_DARWIN)
+  if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
     # We collate -F with the framework path to avoid unwanted deduplication
     # of options by target_compile_options -- this way no undesired
     # side effects are introduced should a new search path be added.
@@ -466,20 +451,16 @@ function(add_swift_host_library name)
       LIBRARY_DIR ${SWIFT_LIBRARY_OUTPUT_INTDIR})
 
   if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
-    set_target_properties(${name}
-      PROPERTIES
+    set_target_properties(${name} PROPERTIES
       INSTALL_NAME_DIR "@rpath")
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL LINUX)
-    set_target_properties(${name}
-      PROPERTIES
+    set_target_properties(${name} PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/linux")
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL CYGWIN)
-    set_target_properties(${name}
-      PROPERTIES
+    set_target_properties(${name} PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/cygwin")
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "ANDROID")
-    set_target_properties(${name}
-      PROPERTIES
+    set_target_properties(${name} PROPERTIES
       INSTALL_RPATH "$ORIGIN")
   endif()
 

docs/ABI/Mangling.rst

@@ -589,7 +589,7 @@ mangled in to disambiguate.
   impl-function-type ::= type* 'I' FUNC-ATTRIBUTES '_'
   impl-function-type ::= type* generic-signature 'I' FUNC-ATTRIBUTES '_'
 
-  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION)?
+  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
 
   PATTERN-SUBS ::= 's'                       // has pattern substitutions
   INVOCATION-SUB ::= 'I'                     // has invocation substitutions
@@ -634,6 +634,8 @@ mangled in to disambiguate.
   RESULT-CONVENTION ::= 'u'                  // unowned inner pointer
   RESULT-CONVENTION ::= 'a'                  // auto-released
 
+  RESULT-DIFFERENTIABILITY ::= 'w'            // @noDerivative
+
 For the most part, manglings follow the structure of formal language
 types.  However, in some cases it is more useful to encode the exact
 implementation details of a function type.

docs/Branches.md

@@ -58,15 +58,22 @@ You can use any of the branch names as the argument to `--scheme`, such as `mast
 
 - LLVM Project: the destination branch depends on the kind of change that must be made:
 
-  1) LLVM Project changes that don't depend on Swift: New commits go to `master` in the upstream [llvm-project](https://github.com/llvm/llvm-project).
+  1) LLVM Project changes that don't depend on Swift
+
+     - New commits go to `master` in the upstream [llvm-project](https://github.com/llvm/llvm-project).
 
-  ... then these commits can be cherry-picked to an appropriate, `swift/master` aligned `apple/stable/*` branch in Apple's fork of [llvm-project](https://github.com/apple/llvm-project). Please see
-  [Apple's branching scheme](https://github.com/apple/llvm-project/blob/apple/master/apple-docs/AppleBranchingScheme.md)
-  document to determine which `apple/stable/*` branch you should cherry-pick to.
+     - Then cherry-pick these commits to an appropriate, `swift/master` aligned `apple/stable/*` branch in Apple's fork of [llvm-project](https://github.com/apple/llvm-project). Please see [Apple's branching scheme](https://github.com/apple/llvm-project/blob/apple/master/apple-docs/AppleBranchingScheme.md) document to determine which `apple/stable/*` branch you should cherry-pick to.
+
+     Note that **no new changes should be submitted directly to `apple/master`**. We are actively working on eliminating the differences from upstream LLVM.
 
-  2) Changes that depend on Swift (this only applies to LLDB): new commits go to `swift/master-next`
+  2) Changes that depend on Swift (this only applies to LLDB)
+     - New commits go to `swift/master` (_not_ an `apple/stable/*` branch, as these shouldn't contain changes that depend on Swift).
 
-  ...then cherry-pick to the release branch (`swift/swift-x.y-branch`) if necessary, following the appropriate release   process. (Usually this means filling out a standard template, finding someone to review your code if that hasn't already happened, and getting approval from that repo's *release manager.)*
+     - Then cherry-pick these commits to `swift/master-next`.
+
+     - If necessary, cherry-pick to the release branch (`swift/release/x.y`), following the appropriate release process. (Usually this means filling out a standard template, finding someone to review your code if that hasn't already happened, and getting approval from that repo's *release manager.)*
+
+  In the long term we want to eliminate the differences from upstream LLVM for these changes as well, but for now there is no concrete plan. So, submitting to `swift/master-next` continues to be allowed.
 
 ## Automerging
 

docs/DebuggingTheCompiler.md

@@ -64,19 +64,19 @@ Here is how to dump the IR after the main phases of the Swift compiler
 
 * **Parser** To print the AST after parsing:
 
-```bash
+```sh
 swiftc -dump-ast -O file.swift
 ```
 
 * **SILGen** To print the SIL immediately after SILGen:
 
-```bash
+```sh
 swiftc -emit-silgen -O file.swift
 ```
 
 * **Mandatory SIL passes** To print the SIL after the mandatory passes:
 
-```bash
+```sh
 swiftc -emit-sil -Onone file.swift
 ```
 
@@ -87,25 +87,25 @@ swiftc -emit-sil -Onone file.swift
 * **Performance SIL passes** To print the SIL after the complete SIL
    optimization pipeline:
 
-```bash
+```sh
 swiftc -emit-sil -O file.swift
 ```
 
 * **IRGen** To print the LLVM IR after IR generation:
 
-```bash
+```sh
 swiftc -emit-ir -Xfrontend -disable-llvm-optzns -O file.swift
 ```
 
 * **LLVM passes** To print the LLVM IR after LLVM passes:
 
-```bash
+```sh
 swiftc -emit-ir -O file.swift
 ```
 
 * **Code generation** To print the final generated code:
 
-```bash
+```sh
 swiftc -S -O file.swift
 ```