Merge branch 'master' of github.com:swiftwasm/swift into maxd/master-merge

# Conflicts:
#	stdlib/public/stubs/ThreadLocalStorage.cpp
#	utils/build_swift/build_swift/driver_arguments.py

Author: MaxDesiatov

CMakeLists.txt

@@ -395,10 +395,6 @@ option(SWIFT_RUNTIME_ENABLE_LEAK_CHECKER
   "Should the runtime be built with support for non-thread-safe leak detecting entrypoints"
   FALSE)
 
-option(SWIFT_STDLIB_USE_NONATOMIC_RC
-    "Build the standard libraries and overlays with nonatomic reference count operations enabled"
-    FALSE)
-
 option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
   "Enable runtime function counters and expose the API."
   FALSE)
@@ -638,6 +634,22 @@ if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQU
   set(SWIFT_COMPILER_IS_MSVC_LIKE TRUE)
 endif()
 
+if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+  # CMake's default for CMAKE_CXX_FLAGS_RELEASE is "-O3 -DNDEBUG". Let's avoid "-O3" for consistency
+  # between Release and RelWithDebInfo. Dropping -DNDEBUG from this setting is blocked by triggering
+  # a test failure of Swift-Unit :: Syntax/./SwiftSyntaxTests/TypeSyntaxTests.MetatypeTypeWithAPIs
+  # because unit tests don't currently explicitly set -DNDEBUG/-UNDEBUG.
+  set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
+
+  _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
+  if(_lto_flag_out)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_RELEASE} -gline-tables-only")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -gline-tables-only")
+  endif()
+else()
+  
+endif()
+
 #
 # Configure SDKs.
 #
@@ -937,7 +949,6 @@ if(NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   endif()
 endif()
 
-find_package(Python2 COMPONENTS Interpreter REQUIRED)
 find_package(Python3 COMPONENTS Interpreter REQUIRED)
 
 #

README.md

@@ -115,6 +115,14 @@ The required version of Xcode changes frequently, and is often a beta release.
 Check this document or the host information on <https://ci.swift.org> for the
 current required version.
 
+Swift's build tooling is meant to support spaces in the paths passed to them,
+but using spaces sometimes tickles bugs in Swift's build scripts or the tools
+they rely on. For example, [SR-13441](https://bugs.swift.org/browse/SR-13441)
+is caused by a space in the Xcode path used on macOS. If you see Swift's build
+tooling misbehave due to a space in a path, please
+[report the bug on the Swift bug tracker](https://swift.org/contributing/#reporting-bugs)
+and then change the path to work around it.
+
 You will also need [CMake](https://cmake.org) and [Ninja](https://ninja-build.org),
 which can be installed via a package manager:
 

benchmark/CMakeLists.txt

@@ -136,6 +136,7 @@ set(SWIFT_BENCH_MODULES
     single-source/PrefixWhile
     single-source/Prims
     single-source/PrimsNonStrongRef
+    single-source/ProtocolConformance
     single-source/ProtocolDispatch
     single-source/ProtocolDispatch2
     single-source/Queue

benchmark/single-source/ProtocolConformance.swift

@@ -0,0 +1,76 @@
+//===--- ProtocolDispatch.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+public let ProtocolConformance = BenchmarkInfo (
+  name: "ProtocolConformance",
+  runFunction: run_ProtocolConformance,
+  tags: [.validation, .runtime])
+
+protocol P {}
+
+struct One: P {}
+struct Two {}
+
+struct Cat<T, U> {}
+
+extension Cat: P where T: P, U: P {}
+
+protocol Growable {}
+extension Growable {
+  func grow() -> (Growable, Growable) {
+    return (Cat<Self, One>(), Cat<Self, Two>())
+  }
+}
+
+extension One: Growable {}
+extension Two: Growable {}
+extension Cat: Growable {}
+
+@inline(never)
+public func run_ProtocolConformance(_ N: Int) {
+  var array: [Growable] = [One(), Two()]
+  var i = 0
+  var checks = 0
+
+  // The expected number of times we expect `elt is P` to be true.
+  var expectedConforms = 0
+
+  // The expected number of times we expect `elt is P` to be true
+  // per iteration, at the current time.
+  var expectedConformsPerIter = 1
+
+  // The number of times we've actually seen `elt is P` be true.
+  var conforms = 0
+  while checks < N * 500 {
+    let (a, b) = array[i].grow()
+    array.append(a)
+    array.append(b)
+
+    // The number of times `elt is P` is true per outer iteration
+    // goes up by 1 when the array's count is a power of 2.
+    if array.count & (array.count - 1) == 0 {
+      expectedConformsPerIter += 1
+    }
+    expectedConforms += expectedConformsPerIter
+
+    for elt in array {
+      if elt is P {
+        conforms += 1
+      }
+      checks += 1
+    }
+    i += 1
+  }
+  CheckResults(expectedConforms == conforms)
+}

benchmark/utils/main.swift

@@ -131,6 +131,7 @@ import PrefixWhile
 import Prims
 import PrimsNonStrongRef
 import PrimsSplit
+import ProtocolConformance
 import ProtocolDispatch
 import ProtocolDispatch2
 import Queue
@@ -317,6 +318,7 @@ registerBenchmark(PrefixWhile)
 registerBenchmark(Prims)
 registerBenchmark(PrimsNonStrongRef)
 registerBenchmark(PrimsSplit)
+registerBenchmark(ProtocolConformance)
 registerBenchmark(ProtocolDispatch)
 registerBenchmark(ProtocolDispatch2)
 registerBenchmark(QueueGeneric)

cmake/modules/AddSwift.cmake

@@ -130,17 +130,18 @@ function(_add_host_variant_c_compile_flags target)
   _add_host_variant_c_compile_link_flags(${target})
 
   is_build_type_optimized("${CMAKE_BUILD_TYPE}" optimized)
-  if(optimized)
-    if("${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
-      target_compile_options(${target} PRIVATE -Os)
-    else()
-      target_compile_options(${target} PRIVATE -O2)
-    endif()
+  is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
+
+  # Add -O0/-O2/-O3/-Os/-g/-momit-leaf-frame-pointer/... based on CMAKE_BUILD_TYPE.
+  target_compile_options(${target} PRIVATE "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}")
 
+  if(optimized)
     # Omit leaf frame pointers on x86 production builds (optimized, no debug
     # info, and no asserts).
-    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debug)
-    if(NOT debug AND NOT LLVM_ENABLE_ASSERTIONS)
+    if(NOT debuginfo AND NOT LLVM_ENABLE_ASSERTIONS)
+      # Unfortunately, this cannot be folded into the standard
+      # CMAKE_CXX_FLAGS_... because Apple multi-SDK builds use different
+      # architectures for different SDKs.
       if(SWIFT_HOST_VARIANT_ARCH MATCHES "i?86")
         if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
           target_compile_options(${target} PRIVATE -momit-leaf-frame-pointer)
@@ -149,27 +150,6 @@ function(_add_host_variant_c_compile_flags target)
         endif()
       endif()
     endif()
-  else()
-    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-      target_compile_options(${target} PRIVATE -O0)
-    else()
-      target_compile_options(${target} PRIVATE /Od)
-    endif()
-  endif()
-
-  # CMake automatically adds the flags for debug info if we use MSVC/clang-cl.
-  if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
-    if(debuginfo)
-      _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
-      if(_lto_flag_out)
-        target_compile_options(${target} PRIVATE -gline-tables-only)
-      else()
-        target_compile_options(${target} PRIVATE -g)
-      endif()
-    else()
-      target_compile_options(${target} PRIVATE -g0)
-    endif()
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)

docs/ABI/Mangling.rst

@@ -176,6 +176,11 @@ Globals
   global ::= global 'MJ'                 // noncanonical specialized generic type metadata instantiation cache associated with global
   global ::= global 'MN'                 // noncanonical specialized generic type metadata for global
 
+  #if SWIFT_RUNTIME_VERSION >= 5.4
+    global ::= context (decl-name '_')+ 'WZ' // global variable one-time initialization function
+    global ::= context (decl-name '_')+ 'Wz' // global variable one-time initialization token
+  #endif
+
 A direct symbol resolves directly to the address of an object.  An
 indirect symbol resolves to the address of a pointer to the object.
 They are distinct manglings to make a certain class of bugs