Build IndexStore together with the host toolchain

CMakeLists.txt

@@ -369,6 +369,10 @@ option(SWIFT_REPORT_STATISTICS
     "Create json files which contain internal compilation statistics"
     FALSE)
 
+option(SWIFT_DISABLE_OBJC_INTEROP
+    "Disable Objective-C interoperability even on platforms what would normally have it"
+    FALSE)
+
 # FIXME(wasm) Reflection tests are temporalily disabled due to lack of linker features
 option(SWIFTWASM_DISABLE_REFLECTION_TEST
     "Disable building swift-reflection-test for WebAssembly build"
@@ -391,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)
@@ -634,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.
 #
@@ -933,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

@@ -93,7 +93,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(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+  if(SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_USE_ISYSROOT)
     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})
@@ -130,13 +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)
-    target_compile_options(${target} PRIVATE -O2)
+  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)
@@ -145,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)

cmake/modules/DarwinSDKs.cmake

@@ -26,6 +26,24 @@ if(swift_build_osx)
   configure_target_variant(OSX-R  "OS X Release"         OSX R  "Release")
 endif()
 
+is_sdk_requested(FREESTANDING swift_build_freestanding)
+if(swift_build_freestanding)
+  set(SWIFT_FREESTANDING_SDK "" CACHE STRING
+      "Which SDK to use when building the FREESTANDING stdlib")
+  set(SWIFT_FREESTANDING_TRIPLE_NAME "" CACHE STRING
+      "Which triple name (e.g. 'none-macho') to use when building the FREESTANDING stdlib")
+  set(SWIFT_FREESTANDING_ARCHS "" CACHE STRING
+      "Which architectures to build when building the FREESTANDING stdlib")
+  configure_sdk_darwin(
+      FREESTANDING "FREESTANDING" ""
+      "${SWIFT_FREESTANDING_SDK}" freestanding "${SWIFT_FREESTANDING_TRIPLE_NAME}" freestanding "${SWIFT_FREESTANDING_ARCHS}")
+  set(SWIFT_SDK_FREESTANDING_LIB_SUBDIR "freestanding")
+  configure_target_variant(FREESTANDING-DA "FREESTANDING Debug+Asserts"   FREESTANDING DA "Debug+Asserts")
+  configure_target_variant(FREESTANDING-RA "FREESTANDING Release+Asserts" FREESTANDING RA "Release+Asserts")
+  configure_target_variant(FREESTANDING-R  "FREESTANDING Release"         FREESTANDING R  "Release")
+  configure_target_variant(FREESTANDING-S  "FREESTANDING MinSizeRelease"  FREESTANDING S  "MinSizeRelease")
+endif()
+
 # Compatible cross-compile SDKS for Darwin OSes: IOS, IOS_SIMULATOR, TVOS,
 #   TVOS_SIMULATOR, WATCHOS, WATCHOS_SIMULATOR (archs hardcoded below).
 

cmake/modules/SwiftConfigureSDK.cmake

@@ -145,6 +145,8 @@ endfunction()
 #   SWIFT_SDK_${prefix}_LIB_SUBDIR          Library subdir for this SDK
 #   SWIFT_SDK_${prefix}_VERSION_MIN_NAME    Version min name for this SDK
 #   SWIFT_SDK_${prefix}_TRIPLE_NAME         Triple name for this SDK
+#   SWIFT_SDK_${prefix}_OBJECT_FORMAT       The object file format (e.g. MACHO)
+#   SWIFT_SDK_${prefix}_USE_ISYSROOT        Whether to use -isysroot
 #   SWIFT_SDK_${prefix}_ARCHITECTURES       Architectures (as a list)
 #   SWIFT_SDK_${prefix}_IS_SIMULATOR        Whether this is a simulator target.
 #   SWIFT_SDK_${prefix}_ARCH_${ARCH}_TRIPLE Triple name
@@ -187,6 +189,7 @@ macro(configure_sdk_darwin
   set(SWIFT_SDK_${prefix}_VERSION_MIN_NAME "${version_min_name}")
   set(SWIFT_SDK_${prefix}_TRIPLE_NAME "${triple_name}")
   set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "MACHO")
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT TRUE)
 
   set(SWIFT_SDK_${prefix}_ARCHITECTURES ${architectures})
   if(SWIFT_DARWIN_SUPPORTED_ARCHS)
@@ -270,6 +273,7 @@ macro(configure_sdk_unix name architectures)
   else()
     set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "ELF")
   endif()
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT FALSE)
 
   foreach(arch ${architectures})
     if("${prefix}" STREQUAL "ANDROID")
@@ -432,6 +436,7 @@ macro(configure_sdk_windows name environment architectures)
   set(SWIFT_SDK_${prefix}_LIB_SUBDIR "windows")
   set(SWIFT_SDK_${prefix}_ARCHITECTURES "${architectures}")
   set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "COFF")
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT FALSE)
 
   foreach(arch ${architectures})
     if(arch STREQUAL armv7)

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
@@ -1107,3 +1112,40 @@ nominal type descriptor symbol for ``CxxStruct`` while compiling the ``main`` mo
 .. code::
 
   sSo9CxxStructVMn // -> nominal type descriptor for __C.CxxStruct
+
+Importing C++ class template instantiations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A class template instantiation is imported as a struct named
+``__CxxTemplateInst`` plus Itanium mangled type of the instantiation (see the
+``type`` production in the Itanium specification). Note that Itanium mangling is
+used on all platforms, regardless of the ABI of the C++ toolchain, to ensure
+that the mangled name is a valid Swift type name (this is not the case for MSVC
+mangled names). A prefix with a double underscore (to ensure we have a reserved
+C++ identifier) is added to limit the possibility for conflicts with names of
+user-defined structs. The struct is notionally defined in the ``__C`` module,
+similarly to regular C and C++ structs and classes. Consider the following C++
+module:
+
+.. code-block:: c++
+
+  template<class T>
+  struct MagicWrapper {
+    T t;
+  };
+
+  struct MagicNumber {};
+
+  typedef MagicWrapper<MagicNumber> WrappedMagicNumber;
+
+``WrappedMagicNumber`` is imported as a typealias for struct
+``__CxxTemplateInst12MagicWrapperI11MagicNumberE``. Interface of the imported
+module looks as follows:
+
+.. code-block:: swift
+
+  struct __CxxTemplateInst12MagicWrapperI11MagicNumberE {
+    var t: MagicNumber
+  }
+  struct MagicNumber {}
+  typealias WrappedMagicNumber = __CxxTemplateInst12MagicWrapperI11MagicNumberE