Merge branch 'main' into problem/63410196

Author: al45tair

CMakeLists.txt

@@ -191,9 +191,10 @@ set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
     option only affects the tools that run on the host (the compiler), and has
     no effect on the target libraries (the standard library and the runtime).")
 
-option(SWIFT_TOOLS_ENABLE_LIBSWIFT
-  "Enable building libswift and linking libswift into the compiler itself."
-  FALSE)
+# NOTE: We do not currently support building libswift with the Xcode generator.
+cmake_dependent_option(SWIFT_TOOLS_ENABLE_LIBSWIFT
+  "Enable building libswift and linking libswift into the compiler itself." FALSE
+  "NOT CMAKE_GENERATOR STREQUAL \"Xcode\"" FALSE)
 
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
@@ -511,8 +512,6 @@ message(STATUS "C Compiler (${CMAKE_C_COMPILER}) Version: ${CMAKE_C_COMPILER_VER
 message(STATUS "C++ Compiler (${CMAKE_CXX_COMPILER}) Version: ${CMAKE_CXX_COMPILER_VERSION}")
 if (CMAKE_Swift_COMPILER)
   message(STATUS "Swift Compiler (${CMAKE_Swift_COMPILER}) Version: ${CMAKE_Swift_COMPILER_VERSION}")
-elseif (SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER)
-  message(FATAL_ERROR "Swift Compiler not found and SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER is set")
 else()
   message(STATUS "Swift Compiler (None).")
 endif()
@@ -1060,9 +1059,7 @@ if(SWIFT_INCLUDE_TOOLS)
   # which is used in add_swift_host_tool for the lldb workaround.
   #
   # NOTE: We do not currently support libswift with the Xcode generator.
-  if (NOT CMAKE_GENERATOR STREQUAL "Xcode")
-    add_subdirectory(libswift)
-  endif()
+  add_subdirectory(libswift)
 
   # Always include this after including stdlib/!
   # Refer to the large comment above the add_subdirectory(stdlib) call.

benchmark/single-source/ChaCha.swift

@@ -361,6 +361,7 @@ func checkResult(_ plaintext: [UInt8]) {
 }
 
 @inline(never)
+@_assemblyVision
 public func run_ChaCha(_ N: Int) {
   let key = Array(repeating: UInt8(1), count: 32)
   let nonce = Array(repeating: UInt8(2), count: 12)

docs/DebuggingTheCompiler.md

@@ -922,7 +922,7 @@ One of the first steps is an invocation of the driver's
 In order to create a Swift compiler installation (`--install-swift`), the
 standalone driver must be built as a separate build product using the
 *just-built* Swift compiler and toolchain (the ones built in the same
-`build-script` invocation, preceeding the SwiftDriver build product). The
+`build-script` invocation, preceding the SwiftDriver build product). The
 additional build product is added to the build by specifying the
 `--swift-driver` option of the `build-script`. The driver product is istalled
 into the resulting toolchain installation by specifying the

docs/HowToGuides/GettingStarted.md

@@ -151,35 +151,18 @@ Double-check that running `pwd` prints a path ending with `swift`.
 [Homebrew]: https://brew.sh/
 [Homebrew Bundle]: https://github.com/Homebrew/homebrew-bundle
 
-### Ubuntu Linux
-
-1. For Ubuntu 16.04 LTS and 18.04 LTS, run the following:
-
-   ```sh
-   sudo apt-get install    \
-     clang                 \
-     cmake                 \
-     git                   \
-     icu-devtools          \
-     libcurl4-openssl-dev  \
-     libedit-dev           \
-     libicu-dev            \
-     libncurses5-dev       \
-     libpython3-dev        \
-     libsqlite3-dev        \
-     libxml2-dev           \
-     ninja-build           \
-     pkg-config            \
-     python                \
-     python-six            \
-     rsync                 \
-     swig                  \
-     systemtap-sdt-dev     \
-     tzdata                \
-     uuid-dev
+### Linux
+
+1. The latest Linux dependencies are listed in the respective Dockerfiles:
+   * [Ubuntu 20.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/20.04/Dockerfile)
+   * [CentOS 7](https://github.com/apple/swift-docker/blob/main/swift-ci/master/centos/7/Dockerfile)
+   * [CentOS 8](https://github.com/apple/swift-docker/blob/main/swift-ci/master/centos/8/Dockerfile)
+   * [Amazon Linux 2](https://github.com/apple/swift-docker/blob/main/swift-ci/master/amazon-linux/2/Dockerfile)
+   
+2. To install sccache (optional):
+   ```
    sudo snap install sccache --candidate --classic
    ```
-
    **Note:** LLDB currently requires at least `swig-1.3.40` but will
    successfully build with version 2 shipped with Ubuntu.
 

include/swift/AST/DiagnosticsSema.def

@@ -4357,6 +4357,8 @@ ERROR(async_objc_dynamic_self,none,
 ERROR(actor_inheritance,none,
       "%select{actor|distributed actor}0 types do not support inheritance",
       (bool))
+NOTE(actor_inheritance_nsobject,none,
+      "use '@objc' to expose actor %0 to Objective-C", (DeclName))
 
 ERROR(actor_protocol_illegal_inheritance,none,
       "non-actor type %0 cannot conform to the 'Actor' protocol",

include/swift/DependencyScan/DependencyScanningTool.h

@@ -31,7 +31,7 @@ class DependencyScanningTool {
   /// Construct a dependency scanning tool.
   DependencyScanningTool();
 
-  /// Collect the full module depenedency graph for the input, ignoring any
+  /// Collect the full module dependency graph for the input, ignoring any
   /// placeholder modules.
   ///
   /// \returns a \c StringError with the diagnostic output if errors
@@ -47,11 +47,11 @@ class DependencyScanningTool {
   llvm::ErrorOr<swiftscan_import_set_t>
   getImports(ArrayRef<const char *> Command);
 
-  /// Collect the full module depenedency graph for the input collection of
+  /// Collect the full module dependency graph for the input collection of
   /// module names (batch inputs) and output them to the
   /// BatchScanInput-specified output locations.
   ///
-  /// \returns a \c std::error_code if errors occured during scan.
+  /// \returns a \c std::error_code if errors occurred during scan.
   std::vector<llvm::ErrorOr<swiftscan_dependency_graph_t>>
   getDependencies(ArrayRef<const char *> Command,
                   const std::vector<BatchScanInput> &BatchInput,

include/swift/Reflection/ReflectionContext.h

@@ -1361,9 +1361,7 @@ class ReflectionContext
     if (!AsyncTaskObj)
       return std::string("failure reading async task");
 
-    auto *Allocator = reinterpret_cast<const StackAllocator *>(
-        &AsyncTaskObj->AllocatorPrivate);
-    StoredPointer SlabPtr = Allocator->FirstSlab;
+    StoredPointer SlabPtr = AsyncTaskObj->PrivateStorage.Allocator.FirstSlab;
     while (SlabPtr) {
       auto SlabBytes = getReader().readBytes(
           RemoteAddress(SlabPtr), sizeof(typename StackAllocator::Slab));

include/swift/Reflection/RuntimeInternals.h

@@ -68,7 +68,12 @@ struct HeapObject {
 
 template <typename Runtime>
 struct Job {
-  typename Runtime::StoredPointer Opaque[4];
+  HeapObject<Runtime> HeapObject;
+  typename Runtime::StoredPointer SchedulerPrivate[2];
+  uint32_t Flags;
+  uint32_t Id;
+  typename Runtime::StoredPointer Reserved[2];
+  typename Runtime::StoredPointer RunJob;
 };
 
 template <typename Runtime>
@@ -86,12 +91,19 @@ struct StackAllocator {
 };
 
 template <typename Runtime>
-struct AsyncTask {
-  HeapObject<Runtime> HeapObject;
-  Job<Runtime> Job;
-  typename Runtime::StoredPointer ResumeContext;
+struct AsyncTaskPrivateStorage {
   typename Runtime::StoredSize Status;
-  typename Runtime::StoredPointer AllocatorPrivate[4];
+  StackAllocator<Runtime> Allocator;
+  typename Runtime::StoredPointer Local;
+};
+
+template <typename Runtime>
+struct AsyncTask: Job<Runtime> {
+  // On 64-bit, there's a Reserved64 after ResumeContext.  
+  typename Runtime::StoredPointer ResumeContextAndReserved[
+    sizeof(typename Runtime::StoredPointer) == 8 ? 2 : 1];
+
+  AsyncTaskPrivateStorage<Runtime> PrivateStorage;
 };
 
 } // end namespace reflection

include/swift/Runtime/ThreadLocal.h

@@ -18,9 +18,15 @@
 #ifndef SWIFT_RUNTIME_THREADLOCAL_H
 #define SWIFT_RUNTIME_THREADLOCAL_H
 
+#include <type_traits>
+#include "ThreadLocalStorage.h"
+
 /// SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL - Does the current configuration
 /// allow the use of SWIFT_RUNTIME_ATTRIBUTE_THREAD_LOCAL?
-#if defined(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
+#if defined(__APPLE__)
+// The pthread TLS APIs work better than C++ TLS on Apple platforms.
+#define SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL 0
+#elif defined(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
 // We define SWIFT_RUNTIME_ATTRIBUTE_THREAD_LOCAL to nothing in this
 // configuration and just use a global variable, so this is okay.
 #define SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL 1
@@ -57,6 +63,17 @@
 #endif
 
 namespace swift {
+// Validate a type stored in thread-local storage, using static asserts. Such
+// types must fit in a pointer and be trivially copyable/destructible.
+#define VALIDATE_THREAD_LOCAL_TYPE(T)                                          \
+  static_assert(sizeof(T) <= sizeof(void *),                                   \
+                "cannot store more than a pointer");                           \
+  static_assert(std::is_trivially_copyable<T>::value,                          \
+                "ThreadLocal values must be trivially copyable");              \
+  static_assert(std::is_trivially_destructible<T>::value,                      \
+                "ThreadLocal cleanup is not supported, stored types must be "  \
+                "trivially destructible");
+
 // A wrapper class for thread-local storage.
 //
 // - On platforms that report SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
@@ -72,50 +89,70 @@ namespace swift {
 // - On platforms that don't report SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL,
 //   we have to simulate thread-local storage.  Fortunately, all of
 //   these platforms (at least for now) support pthread_getspecific.
+#if SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
 template <class T>
 class ThreadLocal {
-  static_assert(sizeof(T) <= sizeof(void*), "cannot store more than a pointer");
+  VALIDATE_THREAD_LOCAL_TYPE(T)
 
-#if SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
   T value;
+
+public:
+  constexpr ThreadLocal() {}
+
+  T get() { return value; }
+
+  void set(T newValue) { value = newValue; }
+};
 #else
+// A wrapper around a pthread_key_t that is lazily initialized using
+// dispatch_once.
+class ThreadLocalKey {
   // We rely on the zero-initialization of objects with static storage
   // duration.
   dispatch_once_t once;
   pthread_key_t key;
 
+public:
   pthread_key_t getKey() {
-    dispatch_once_f(&once, this, [](void *ctx) {
-      pthread_key_create(&reinterpret_cast<ThreadLocal*>(ctx)->key, nullptr);
+    dispatch_once_f(&once, &key, [](void *ctx) {
+      pthread_key_create(reinterpret_cast<pthread_key_t *>(ctx), nullptr);
     });
     return key;
   }
-#endif
+};
+
+// A type representing a constant pthread_key_t, for use on platforms that
+// provide reserved keys.
+template <pthread_key_t constantKey>
+class ConstantThreadLocalKey {
+public:
+  pthread_key_t getKey() { return constantKey; }
+};
+
+template <class T, class Key>
+class ThreadLocal {
+  VALIDATE_THREAD_LOCAL_TYPE(T)
+
+  Key key;
 
 public:
   constexpr ThreadLocal() {}
 
   T get() {
-#if SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
-    return value;
-#else
-    void *storedValue = pthread_getspecific(getKey());
+    void *storedValue = SWIFT_THREAD_GETSPECIFIC(key.getKey());
     T value;
     memcpy(&value, &storedValue, sizeof(T));
     return value;
-#endif
   }
 
   void set(T newValue) {
-#if SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
-    value = newValue;
-#else
     void *storedValue;
     memcpy(&storedValue, &newValue, sizeof(T));
-    pthread_setspecific(getKey(), storedValue);
-#endif
+    SWIFT_THREAD_SETSPECIFIC(key.getKey(), storedValue);
   }
 };
+#endif
+
 } // end namespace swift
 
 /// SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME) - Declare a variable
@@ -124,13 +161,16 @@ class ThreadLocal {
 ///
 /// Because of the fallback path, the default-initialization of the
 /// type must be equivalent to a bitwise zero-initialization, and the
-/// type must be small and trivially copyable.
+/// type must be small and trivially copyable and destructible.
 #if SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
-#define SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME) \
+#define SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME, KEY) \
   SWIFT_RUNTIME_ATTRIBUTE_THREAD_LOCAL swift::ThreadLocal<TYPE> NAME
+#elif SWIFT_TLS_HAS_RESERVED_PTHREAD_SPECIFIC
+#define SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME, KEY) \
+  swift::ThreadLocal<TYPE, ConstantThreadLocalKey<KEY>> NAME
 #else
-#define SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME) \
-  swift::ThreadLocal<TYPE> NAME
+#define SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(TYPE, NAME, KEY) \
+  swift::ThreadLocal<TYPE, ThreadLocalKey> NAME
 #endif
 
 #endif

stdlib/public/runtime/ThreadLocalStorage.h renamed to include/swift/Runtime/ThreadLocalStorage.h

@@ -48,12 +48,33 @@ extern "C" int pthread_key_init_np(int key, void (*destructor)(void *));
 # ifndef __PTK_FRAMEWORK_SWIFT_KEY3
 #  define __PTK_FRAMEWORK_SWIFT_KEY3 103
 # endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY4
+#  define __PTK_FRAMEWORK_SWIFT_KEY4 104
+# endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY5
+#  define __PTK_FRAMEWORK_SWIFT_KEY5 105
+# endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY6
+#  define __PTK_FRAMEWORK_SWIFT_KEY6 106
+# endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY7
+#  define __PTK_FRAMEWORK_SWIFT_KEY7 107
+# endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY8
+#  define __PTK_FRAMEWORK_SWIFT_KEY8 108
+# endif
+# ifndef __PTK_FRAMEWORK_SWIFT_KEY9
+#  define __PTK_FRAMEWORK_SWIFT_KEY9 109
+# endif
 
 
 # define SWIFT_RUNTIME_TLS_KEY __PTK_FRAMEWORK_SWIFT_KEY0
 # define SWIFT_STDLIB_TLS_KEY __PTK_FRAMEWORK_SWIFT_KEY1
 # define SWIFT_COMPATIBILITY_50_TLS_KEY __PTK_FRAMEWORK_SWIFT_KEY2
 # define SWIFT_CONCURRENCY_TASK_KEY __PTK_FRAMEWORK_SWIFT_KEY3
+# define SWIFT_CONCURRENCY_EXECUTOR_TRACKING_INFO_KEY __PTK_FRAMEWORK_SWIFT_KEY4
+# define SWIFT_CONCURRENCY_FALLBACK_TASK_LOCAL_STORAGE_KEY \
+  __PTK_FRAMEWORK_SWIFT_KEY5
 
 #endif
 

include/swift/SIL/OptimizationRemark.h

@@ -153,6 +153,7 @@ enum class SourceLocInferenceBehavior : unsigned {
   BackwardsThenForwards = BackwardScan | ForwardScan2nd,
   ForwardScanAlwaysInfer = ForwardScan | AlwaysInfer,
   BackwardScanAlwaysInfer = BackwardScan | AlwaysInfer,
+  BackwardThenForwardAlwaysInfer = BackwardScan | ForwardScan2nd | AlwaysInfer,
 };
 
 inline SourceLocInferenceBehavior operator&(SourceLocInferenceBehavior lhs,