Merge pull request #2436 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

CMakeLists.txt

@@ -486,10 +486,12 @@ if(SWIFT_PATH_TO_CMARK_BUILD)
 endif()
 message(STATUS "")
 
-if("${SWIFT_NATIVE_LLVM_TOOLS_PATH}" STREQUAL "")
-  set(SWIFT_CROSS_COMPILING FALSE)
+# Check if a prebuilt clang path was passed in, as this variable will be
+# assigned if not, in SwiftSharedCMakeConfig.
+if("${SWIFT_NATIVE_CLANG_TOOLS_PATH}" STREQUAL "")
+  set(SWIFT_PREBUILT_CLANG FALSE)
 else()
-  set(SWIFT_CROSS_COMPILING TRUE)
+  set(SWIFT_PREBUILT_CLANG TRUE)
 endif()
 
 include(SwiftSharedCMakeConfig)

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -58,7 +58,7 @@ macro(swift_common_standalone_build_config_llvm product)
     fix_imported_targets_for_xcode("${LLVM_EXPORTED_TARGETS}")
   endif()
 
-  if(NOT CMAKE_CROSSCOMPILING AND NOT SWIFT_CROSS_COMPILING)
+  if(NOT CMAKE_CROSSCOMPILING)
     set(${product}_NATIVE_LLVM_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
   endif()
 
@@ -159,7 +159,7 @@ endmacro()
 macro(swift_common_standalone_build_config_clang product)
   find_package(Clang CONFIG REQUIRED NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 
-  if (NOT CMAKE_CROSSCOMPILING)
+  if (NOT CMAKE_CROSSCOMPILING AND NOT SWIFT_PREBUILT_CLANG)
     set(${product}_NATIVE_CLANG_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
   endif()
 

lib/ClangImporter/ClangImporter.cpp

@@ -555,23 +555,28 @@ importer::getNormalInvocationArguments(
     invocationArgStrs.push_back(
         "-Werror=non-modular-include-in-framework-module");
 
+  bool EnableCXXInterop = LangOpts.EnableCXXInterop;
+
   if (LangOpts.EnableObjCInterop) {
-    bool EnableCXXInterop = LangOpts.EnableCXXInterop;
-    invocationArgStrs.insert(
-        invocationArgStrs.end(),
-        {"-x", EnableCXXInterop ? "objective-c++" : "objective-c",
-         EnableCXXInterop ? "-std=gnu++17" : "-std=gnu11", "-fobjc-arc"});
+    invocationArgStrs.insert(invocationArgStrs.end(), {"-fobjc-arc"});
     // TODO: Investigate whether 7.0 is a suitable default version.
     if (!triple.isOSDarwin())
       invocationArgStrs.insert(invocationArgStrs.end(),
                                {"-fobjc-runtime=ios-7.0"});
+
+    invocationArgStrs.insert(invocationArgStrs.end(), {
+      "-x", EnableCXXInterop ? "objective-c++" : "objective-c",
+    });
   } else {
-    bool EnableCXXInterop = LangOpts.EnableCXXInterop;
-    invocationArgStrs.insert(invocationArgStrs.end(),
-                             {"-x", EnableCXXInterop ? "c++" : "c",
-                              EnableCXXInterop ? "-std=gnu++17" : "-std=gnu11"});
+    invocationArgStrs.insert(invocationArgStrs.end(), {
+      "-x", EnableCXXInterop ? "c++" : "c",
+    });
   }
 
+  invocationArgStrs.insert(invocationArgStrs.end(), {
+    EnableCXXInterop ? "-std=gnu++17" : "-std=gnu11",
+  });
+
   // Set C language options.
   if (triple.isOSDarwin()) {
     invocationArgStrs.insert(invocationArgStrs.end(), {

lib/SILOptimizer/Transforms/CSE.cpp

@@ -581,10 +581,6 @@ class CSE {
 
   SILOptFunctionBuilder &FuncBuilder;
 
-  SILOpenedArchetypesTracker &OpenedArchetypesTracker;
-
-  InstructionCloner &Cloner;
-
   DeadEndBlocks &DeadEndBBs;
 
   OwnershipFixupContext &FixupCtx;
@@ -594,16 +590,10 @@ class CSE {
   llvm::SmallVector<ApplyInst *, 8> lazyPropertyGetters;
 
   CSE(bool RunsOnHighLevelSil, SideEffectAnalysis *SEA,
-      SILOptFunctionBuilder &FuncBuilder,
-      SILOpenedArchetypesTracker &OpenedArchetypesTracker,
-      InstructionCloner &Cloner, DeadEndBlocks &DeadEndBBs,
+      SILOptFunctionBuilder &FuncBuilder, DeadEndBlocks &DeadEndBBs,
       OwnershipFixupContext &FixupCtx)
-      : SEA(SEA), FuncBuilder(FuncBuilder),
-        OpenedArchetypesTracker(OpenedArchetypesTracker), Cloner(Cloner),
-        DeadEndBBs(DeadEndBBs), FixupCtx(FixupCtx),
-        RunsOnHighLevelSil(RunsOnHighLevelSil) {
-    Cloner.getBuilder().setOpenedArchetypesTracker(&OpenedArchetypesTracker);
-  }
+      : SEA(SEA), FuncBuilder(FuncBuilder), DeadEndBBs(DeadEndBBs),
+        FixupCtx(FixupCtx), RunsOnHighLevelSil(RunsOnHighLevelSil) {}
 
   bool processFunction(SILFunction &F, DominanceInfo *DT);
 
@@ -843,11 +833,16 @@ bool CSE::processOpenExistentialRef(OpenExistentialRefInst *Inst,
   }
 
   // Now process candidates.
+  SILOpenedArchetypesTracker OpenedArchetypesTracker(Inst->getFunction());
   // Register the new archetype to be used.
   OpenedArchetypesTracker.registerOpenedArchetypes(VI);
+  // Use a cloner. It makes copying the instruction and remapping of
+  // opened archetypes trivial.
+  InstructionCloner Cloner(Inst->getFunction());
   Cloner.registerOpenedExistentialRemapping(
       OldOpenedArchetype->castTo<ArchetypeType>(), NewOpenedArchetype);
   auto &Builder = Cloner.getBuilder();
+  Builder.setOpenedArchetypesTracker(&OpenedArchetypesTracker);
 
   llvm::SmallPtrSet<SILInstruction *, 16> Processed;
   // Now clone each candidate and replace the opened archetype
@@ -1401,14 +1396,11 @@ class SILCSE : public SILFunctionTransform {
     SILOptFunctionBuilder FuncBuilder(*this);
 
     auto *Fn = getFunction();
-    SILOpenedArchetypesTracker OpenedArchetypesTracker(Fn);
-    InstructionCloner Cloner(Fn);
     DeadEndBlocks DeadEndBBs(Fn);
     JointPostDominanceSetComputer Computer(DeadEndBBs);
     InstModCallbacks callbacks;
     OwnershipFixupContext FixupCtx{callbacks, DeadEndBBs, Computer};
-    CSE C(RunsOnHighLevelSil, SEA, FuncBuilder, OpenedArchetypesTracker, Cloner,
-          DeadEndBBs, FixupCtx);
+    CSE C(RunsOnHighLevelSil, SEA, FuncBuilder, DeadEndBBs, FixupCtx);
     bool Changed = false;
 
     // Perform the traditional CSE.

stdlib/CMakeLists.txt

@@ -116,11 +116,11 @@ else()
   # If we use Clang-cl or MSVC, CMake provides default compiler and linker flags that are incompatible
   # with the frontend of Clang or Clang++.
   if(SWIFT_COMPILER_IS_MSVC_LIKE)
-    set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang-cl")
-    set(CMAKE_C_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang-cl")
+    set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
+    set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
   else()
-    set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang++")
-    set(CMAKE_C_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang")
+    set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang++")
+    set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang")
   endif()
 
   if(CMAKE_C_COMPILER_LAUNCHER MATCHES ".*distcc")

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -1658,7 +1658,8 @@ function(add_swift_target_library name)
     list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-warn-implicit-overrides")
   endif()
 
-  if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE)
+  if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE AND
+     NOT SWIFT_PREBUILT_CLANG)
     list(APPEND SWIFTLIB_DEPENDS clang)
   endif()
 

stdlib/public/SwiftShims/CMakeLists.txt

@@ -111,7 +111,8 @@ endif()
 # First extract the "version" used for Clang's resource directory.
 string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
   "${LLVM_PACKAGE_VERSION}")
-if(NOT SWIFT_INCLUDE_TOOLS AND SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER)
+if(NOT SWIFT_INCLUDE_TOOLS AND
+   (SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER OR SWIFT_PREBUILT_CLANG))
   if(SWIFT_COMPILER_IS_MSVC_LIKE)
     execute_process(COMMAND ${CMAKE_C_COMPILER} /clang:-print-resource-dir
       OUTPUT_VARIABLE clang_headers_location

test/SILOptimizer/cse.sil

@@ -1244,6 +1244,32 @@ bb3:
   return %20 : $()
 }
 
+// This test is not a repro but used to show why we need a local Cloner object in CSE::processOpenExistentialRef.
+// Discussion:
+// Since the CSE pass can delete instructions and allocate instructions whose state can be cached in the Cloner, we have to use local Cloner object so that we don't accidentally refer to stale state 
+// In this test users of %9 are all cloned and original instructions are deleted. Users of %13 are similarly cloned and original instructions are deleted so the types can be remapped.
+// Instructions can further get deleted in the main CSE pass as well as during SimplifyInstruction.
+// For some heap allocation patterns newly allocated instructions can get the same address of a previously allocated instruction, and can end up referring to a stale state in the Cloner.
+//
+// CHECK-LABEL: sil @cse_open_existential_ref_local_cloner :
+// CHECK: open_existential_ref
+// CHECK-NOT: open_existential_ref
+// CHECK-LABEL: } // end sil function 'cse_open_existential_ref_local_cloner'
+sil @cse_open_existential_ref_local_cloner : $@convention(thin) (@guaranteed Proto, Bool) -> () {
+bb0(%0 : $Proto, %1 : $Bool):
+  %4 = open_existential_ref %0 : $Proto to $@opened("1B68354A-4796-11E6-B7DF-B8E856428C60") Proto
+  %5 = witness_method $@opened("1B68354A-4796-11E6-B7DF-B8E856428C60") Proto, #Proto.doThis, %4 : $@opened("1B68354A-4796-11E6-B7DF-B8E856428C60") Proto : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %6 = apply %5<@opened("1B68354A-4796-11E6-B7DF-B8E856428C60") Proto>(%4) : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %9 = open_existential_ref %0 : $Proto to $@opened("1B685052-4796-11E6-B7DF-B8E856428C60") Proto
+  %10 = witness_method $@opened("1B685052-4796-11E6-B7DF-B8E856428C60") Proto, #Proto.doThat, %9 : $@opened("1B685052-4796-11E6-B7DF-B8E856428C60") Proto : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %11 = apply %10<@opened("1B685052-4796-11E6-B7DF-B8E856428C60") Proto>(%9) : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %13 = open_existential_ref %0 : $Proto to $@opened("1B6851A6-4796-11E6-B7DF-B8E856428C60") Proto
+  %14 = witness_method $@opened("1B6851A6-4796-11E6-B7DF-B8E856428C60") Proto, #Proto.doThis, %13 : $@opened("1B6851A6-4796-11E6-B7DF-B8E856428C60") Proto : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %15 = apply %14<@opened("1B6851A6-4796-11E6-B7DF-B8E856428C60") Proto>(%13) : $@convention(witness_method: Proto) <τ_0_0 where τ_0_0 : Proto> (@guaranteed τ_0_0) -> ()
+  %res = tuple ()
+  return %res : $()
+}
+
 // Check that we don't CSE open_existential_ref if they are not compeltely equal.
 // CHECK-LABEL: sil @dont_cse_open_existential_ref
 // CHECK: open_existential_ref

unittests/runtime/CMakeLists.txt

@@ -13,11 +13,11 @@ if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
     # If we use Clang-cl or MSVC, CMake provides default compiler and linker flags that are incompatible
     # with the frontend of Clang or Clang++.
     if(SWIFT_COMPILER_IS_MSVC_LIKE)
-      set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang-cl")
-      set(CMAKE_C_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang-cl")
+      set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
+      set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
     else()
-      set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang++")
-      set(CMAKE_C_COMPILER "${SWIFT_NATIVE_LLVM_TOOLS_PATH}/clang")
+      set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang++")
+      set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang")
     endif()
 
     if(CMAKE_C_COMPILER_LAUNCHER MATCHES ".*distcc")

utils/build-presets.ini

@@ -2283,10 +2283,9 @@ skip-build-cmark
 skip-build-benchmarks
 skip-test-cmark
 
-# This triggers the stdlib standalone build: Don't build tools (the compiler),
-# assume we are working with the host compiler.
+# This triggers the stdlib standalone build: don't build the native tools from
+# scratch, ie the compiler.
 build-swift-tools=0
-build-runtime-with-host-compiler=1
 
 # Then set the paths to our native tools. If compiling against a toolchain,
 # these should all be the ./usr/bin directory.

utils/build-script

@@ -720,6 +720,18 @@ class BuildScriptInvocation(object):
             impl_args += [
                 "--host-libtool", toolchain.libtool,
             ]
+        if args.native_clang_tools_path is not None:
+            impl_args += [
+                "--native-clang-tools-path=%s" % args.native_clang_tools_path
+            ]
+        if args.native_llvm_tools_path is not None:
+            impl_args += [
+                "--native-llvm-tools-path=%s" % args.native_llvm_tools_path
+            ]
+        if args.native_swift_tools_path is not None:
+            impl_args += [
+                "--native-swift-tools-path=%s" % args.native_swift_tools_path
+            ]
 
         # If we have extra_swift_args, combine all of them together and then
         # add them as one command.

utils/build-script-impl

@@ -1493,13 +1493,6 @@ for host in "${ALL_HOSTS[@]}"; do
         fi
     fi
 
-    if [[ "${NATIVE_CLANG_TOOLS_PATH}" ]] ; then
-        common_cmake_options_host+=(
-                -DCMAKE_C_COMPILER="${NATIVE_CLANG_TOOLS_PATH}/clang"
-                -DCMAKE_CXX_COMPILER="${NATIVE_CLANG_TOOLS_PATH}/clang++"
-            )
-    fi
-
     llvm_cmake_options=(
         "${llvm_cmake_options[@]}"
         -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})"

utils/build_swift/build_swift/driver_arguments.py

@@ -389,6 +389,15 @@ def create_argument_parser():
     option('--host-cxx', store_path(executable=True),
            help='the absolute path to CXX, the "clang++" compiler for the '
                 'host platform. Default is auto detected.')
+    option('--native-swift-tools-path', store_path,
+           help='the path to a directory that contains prebuilt Swift tools '
+                'that are executable on the host platform')
+    option('--native-clang-tools-path', store_path,
+           help='the path to a directory that contains prebuilt Clang tools '
+                'that are executable on the host platform')
+    option('--native-llvm-tools-path', store_path,
+           help='the path to a directory that contains prebuilt LLVM tools '
+                'that are executable on the host platform')
     option('--cmake-c-launcher', store_path(executable=True),
            default=os.environ.get('C_COMPILER_LAUNCHER', None),
            help='the absolute path to set CMAKE_C_COMPILER_LAUNCHER')

utils/build_swift/tests/expected_options.py

@@ -189,6 +189,9 @@
     'lto_type': None,
     'maccatalyst': False,
     'maccatalyst_ios_tests': False,
+    'native_clang_tools_path': None,
+    'native_llvm_tools_path': None,
+    'native_swift_tools_path': None,
     'dump_config': False,
     'show_sdks': False,
     'skip_build': False,
@@ -653,6 +656,9 @@ class BuildScriptImplOption(_BaseOption):
     PathOption('--install-symroot'),
     PathOption('--install-destdir'),
     EnableOption('--install-all'),
+    PathOption('--native-clang-tools-path'),
+    PathOption('--native-llvm-tools-path'),
+    PathOption('--native-swift-tools-path'),
     PathOption('--symbols-package'),
     PathOption('--cmake-c-launcher'),
     PathOption('--cmake-cxx-launcher'),

utils/swift_build_support/swift_build_support/products/product.py

@@ -167,8 +167,11 @@ def install_toolchain_path(self, host_target):
         """toolchain_path() -> string
 
         Returns the path to the toolchain that is being created as part of this
-        build.
+        build, or to a native prebuilt toolchain that was passed in.
         """
+        if self.args.native_swift_tools_path is not None:
+            return os.path.split(self.args.native_swift_tools_path)[0]
+
         install_destdir = self.args.install_destdir
         if self.args.cross_compile_hosts:
             build_root = os.path.dirname(self.build_dir)