cmake/build-script: rename the libswift option to "bootstrapping"

In cmake, rename LIBSWIFT_BUILD_MODE to BOOTSTRAPPING_MODE.
Also, rename the lit feature "libswift" to "swift_in_compiler".

Author: eeckstein

CMakeLists.txt

@@ -187,17 +187,17 @@ 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).")
 
-# NOTE: We do not currently support building libswift with the Xcode generator.
-cmake_dependent_option(LIBSWIFT_BUILD_MODE [=[
-How to build libswift. Possible values are
-    OFF:           the compiler is built without libswift
-    HOSTTOOLS:     libswift is built with a pre-installed toolchain
-    BOOTSTRAPPING: libswift is built with a 2-stage bootstrapping process
-    BOOTSTRAPPING-WITH-HOSTLIBS:   libswift is built with a 2-stage bootstrapping process,
+# NOTE: We do not currently support building the swift compiler modules with the Xcode generator.
+cmake_dependent_option(BOOTSTRAPPING_MODE [=[
+How to build the swift compiler modules. Possible values are
+    OFF:           build without swift modules
+    HOSTTOOLS:     build with a pre-installed toolchain
+    BOOTSTRAPPING: build with a 2-stage bootstrapping process
+    BOOTSTRAPPING-WITH-HOSTLIBS:   build with a 2-stage bootstrapping process,
                    but the compiler links against the host system swift libs (macOS only)
-    CROSSCOMPILE:  libswift is cross-compiled with a native host compiler, provided in
+    CROSSCOMPILE:  cross-compiledwith a native host compiler, provided in
                    `SWIFT_NATIVE_SWIFT_TOOLS_PATH` (non-Darwin only)
-    CROSSCOMPILE-WITH-HOSTLIBS:    libswift is built with a bootstrapping-with-hostlibs compiled
+    CROSSCOMPILE-WITH-HOSTLIBS:    build with a bootstrapping-with-hostlibs compiled
                                    compiler, provided in `SWIFT_NATIVE_SWIFT_TOOLS_PATH`
 ]=]  OFF "NOT CMAKE_GENERATOR STREQUAL \"Xcode\"" OFF)
 
@@ -615,24 +615,24 @@ set(SWIFT_RUNTIME_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin")
 set(SWIFT_LIBRARY_OUTPUT_INTDIR "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib")
 if("${SWIFT_NATIVE_SWIFT_TOOLS_PATH}" STREQUAL "")
   set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
-  set(SWIFT_EXEC_FOR_LIBSWIFT "${CMAKE_Swift_COMPILER}")
-elseif(LIBSWIFT_BUILD_MODE MATCHES "BOOTSTRAPPING.*")
-  # If cross-compiling we don't have to bootstrap. We can just use the previously
-  # built native swiftc to build libswift.
-  message(STATUS "Building libswift with previously built tools instead of bootstrapping")
-  set(SWIFT_EXEC_FOR_LIBSWIFT "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")
-  if(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
-    set(LIBSWIFT_BUILD_MODE "CROSSCOMPILE-WITH-HOSTLIBS")
-  elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
-    set(LIBSWIFT_BUILD_MODE "CROSSCOMPILE")
+  set(SWIFT_EXEC_FOR_SWIFT_MODULES "${CMAKE_Swift_COMPILER}")
+elseif(BOOTSTRAPPING_MODE MATCHES "BOOTSTRAPPING.*")
+  # If cross-compiling, we don't have to bootstrap. We can just use the previously
+  # built native swiftc to build the swift compiler modules.
+  message(STATUS "Building swift modules with previously built tools instead of bootstrapping")
+  set(SWIFT_EXEC_FOR_SWIFT_MODULES "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")
+  if(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
+    set(BOOTSTRAPPING_MODE "CROSSCOMPILE-WITH-HOSTLIBS")
+  elseif(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING")
+    set(BOOTSTRAPPING_MODE "CROSSCOMPILE")
   else()
-    set(LIBSWIFT_BUILD_MODE "HOSTTOOLS")
+    set(BOOTSTRAPPING_MODE "HOSTTOOLS")
   endif()
 endif()
 
-if(LIBSWIFT_BUILD_MODE MATCHES "HOSTTOOLS|.*-WITH-HOSTLIBS")
+if(BOOTSTRAPPING_MODE MATCHES "HOSTTOOLS|.*-WITH-HOSTLIBS")
   if(SWIFT_ENABLE_ARRAY_COW_CHECKS)
-    message(STATUS "array COW checks disabled when building libswift with host libraries")
+    message(STATUS "array COW checks disabled when building the swift modules with host libraries")
     set(SWIFT_ENABLE_ARRAY_COW_CHECKS FALSE)
   endif()
 endif()
@@ -999,7 +999,7 @@ if(SWIFT_INCLUDE_TOOLS)
   message(STATUS "  Build type:     ${CMAKE_BUILD_TYPE}")
   message(STATUS "  Assertions:     ${LLVM_ENABLE_ASSERTIONS}")
   message(STATUS "  LTO:            ${SWIFT_TOOLS_ENABLE_LTO}")
-  message(STATUS "  libswift:       ${LIBSWIFT_BUILD_MODE}")
+  message(STATUS "  Bootstrapping:  ${BOOTSTRAPPING_MODE}")
   message(STATUS "")
 else()
   message(STATUS "Not building host Swift tools")
@@ -1118,11 +1118,11 @@ add_subdirectory(include)
 if(SWIFT_INCLUDE_TOOLS)
   add_subdirectory(lib)
 
-  # "libswift" must come before "tools".
-  # It adds libswift module names to the global property "libswift_modules"
+  # SwiftCompilerSources must come before "tools".
+  # It adds swift module names to the global property "swift_compiler_modules"
   # which is used in add_swift_host_tool for the lldb workaround.
   #
-  # NOTE: We do not currently support libswift with the Xcode generator.
+  # NOTE: We do not currently support SwiftCompilerSources with the Xcode generator.
   add_subdirectory(SwiftCompilerSources)
 
   # Always include this after including stdlib/!

SwiftCompilerSources/CMakeLists.txt

@@ -92,14 +92,14 @@ function(add_swift_compiler_modules_library name)
     set(deployment_version "10.15") # TODO: once #38675 lands, replace this with
 #   set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
     set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
-    if(${LIBSWIFT_BUILD_MODE} STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
+    if(${BOOTSTRAPPING_MODE} STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
       # Let the cross-compiled compile don't pick up the compiled stdlib by providing
       # an (almost) empty resource dir.
       # The compiler will instead pick up the stdlib from the SDK.
       get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
       set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../bootstrapping0/lib/swift")
     endif()
-  elseif(${LIBSWIFT_BUILD_MODE} STREQUAL "CROSSCOMPILE")
+  elseif(${BOOTSTRAPPING_MODE} STREQUAL "CROSSCOMPILE")
     set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
     get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
     set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../lib/swift")
@@ -160,7 +160,7 @@ endfunction()
 # A dummy library if swift in the compiler is disabled
 add_swift_host_library(swiftCompilerStub OBJECT stubs.cpp)
 
-if (NOT LIBSWIFT_BUILD_MODE)
+if (NOT BOOTSTRAPPING_MODE)
 
   add_library(swiftCompilerModules ALIAS swiftCompilerStub)
 
@@ -171,20 +171,20 @@ else()
 
   add_subdirectory(Sources)
 
-  if(${LIBSWIFT_BUILD_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
+  if(${BOOTSTRAPPING_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
 
-    if (NOT SWIFT_EXEC_FOR_LIBSWIFT)
+    if (NOT SWIFT_EXEC_FOR_SWIFT_MODULES)
       message(FATAL_ERROR "Need a swift toolchain building swift compiler sources")
     endif()
 
     add_swift_compiler_modules_library(swiftCompilerModules
-      SWIFT_EXEC "${SWIFT_EXEC_FOR_LIBSWIFT}")
+      SWIFT_EXEC "${SWIFT_EXEC_FOR_SWIFT_MODULES}")
 
-  elseif(${LIBSWIFT_BUILD_MODE} MATCHES "BOOTSTRAPPING.*")
+  elseif(${BOOTSTRAPPING_MODE} MATCHES "BOOTSTRAPPING.*")
 
     set(b0_deps swift-frontend-bootstrapping0 symlink-headers-bootstrapping0)
     set(b1_deps swift-frontend-bootstrapping1 symlink-headers-bootstrapping1)
-    if(${LIBSWIFT_BUILD_MODE} STREQUAL "BOOTSTRAPPING")
+    if(${BOOTSTRAPPING_MODE} STREQUAL "BOOTSTRAPPING")
       list(APPEND b0_deps swiftCore-bootstrapping0)
       list(APPEND b1_deps swiftCore-bootstrapping1)
       if(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -221,15 +221,15 @@ else()
         SWIFT_EXEC $<TARGET_FILE_DIR:swift-frontend-bootstrapping1>/swiftc${CMAKE_EXECUTABLE_SUFFIX}
         DEPENDS ${b1_deps})
 
-    if(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
+    if(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
       file(GLOB module_dirs "${CMAKE_BINARY_DIR}/bootstrapping*/lib/swift/macosx/*.swiftmodule")
       foreach(module_dir ${module_dirs})
         message(WARNING "${module_dir} found from a previous 'bootstrapping' build: removing")
         file(REMOVE_RECURSE "${module_dir}")
       endforeach()
     endif()
   else()
-    message(FATAL_ERROR "Unknown LIBSWIFT_BUILD_MODE '${LIBSWIFT_BUILD_MODE}'")
+    message(FATAL_ERROR "Unknown BOOTSTRAPPING_MODE '${BOOTSTRAPPING_MODE}'")
   endif()
 
 endif()

cmake/modules/AddSwift.cmake

@@ -630,7 +630,7 @@ macro(add_swift_lib_subdirectory name)
 endmacro()
 
 function(add_swift_host_tool executable)
-  set(options HAS_LIBSWIFT)
+  set(options HAS_SWIFT_MODULES)
   set(single_parameter_options SWIFT_COMPONENT BOOTSTRAPPING)
   set(multiple_parameter_options LLVM_LINK_COMPONENTS)
 
@@ -696,11 +696,11 @@ function(add_swift_host_tool executable)
     # If we found a swift compiler and are going to use swift code in swift
     # host side tools but link with clang, add the appropriate -L paths so we
     # find all of the necessary swift libraries on Darwin.
-    if (ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE)
+    if (ASHT_HAS_SWIFT_MODULES AND BOOTSTRAPPING_MODE)
 
-      if(LIBSWIFT_BUILD_MODE STREQUAL "HOSTTOOLS")
+      if(BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS")
         # Add in the toolchain directory so we can grab compatibility libraries
-        get_filename_component(TOOLCHAIN_BIN_DIR ${SWIFT_EXEC_FOR_LIBSWIFT} DIRECTORY)
+        get_filename_component(TOOLCHAIN_BIN_DIR ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
         get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/macosx" ABSOLUTE)
         target_link_directories(${executable} PUBLIC ${TOOLCHAIN_LIB_DIR})
 
@@ -710,7 +710,7 @@ function(add_swift_host_tool executable)
         # Include the abi stable system stdlib in our rpath.
         list(APPEND RPATH_LIST "/usr/lib/swift")
 
-      elseif(LIBSWIFT_BUILD_MODE STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
+      elseif(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
 
         # Intentinally don't add the lib dir of the cross-compiled compiler, so that
         # the stdlib is not picked up from there, but from the SDK.
@@ -726,7 +726,7 @@ function(add_swift_host_tool executable)
         # Include the abi stable system stdlib in our rpath.
         list(APPEND RPATH_LIST "/usr/lib/swift")
 
-      elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
+      elseif(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
         # Add the SDK directory for the host platform.
         target_link_directories(${executable} PRIVATE "${sdk_dir}")
 
@@ -737,7 +737,7 @@ function(add_swift_host_tool executable)
         # Include the abi stable system stdlib in our rpath.
         list(APPEND RPATH_LIST "/usr/lib/swift")
 
-      elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
+      elseif(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING")
         # At build time link against the built swift libraries from the
         # previous bootstrapping stage.
         get_bootstrapping_swift_lib_dir(bs_lib_dir "${ASHT_BOOTSTRAPPING}")
@@ -751,7 +751,7 @@ function(add_swift_host_tool executable)
         # bootstrapping stage.
         list(APPEND RPATH_LIST "@executable_path/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
       else()
-        message(FATAL_ERROR "Unknown LIBSWIFT_BUILD_MODE '${LIBSWIFT_BUILD_MODE}'")
+        message(FATAL_ERROR "Unknown BOOTSTRAPPING_MODE '${BOOTSTRAPPING_MODE}'")
       endif()
 
       # Workaround to make lldb happy: we have to explicitly add all swift compiler modules
@@ -770,26 +770,26 @@ function(add_swift_host_tool executable)
       set_property(TARGET ${executable} APPEND_STRING PROPERTY
                    LINK_FLAGS " -lobjc ")
 
-    endif() # ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE
+    endif() # ASHT_HAS_SWIFT_MODULES AND BOOTSTRAPPING_MODE
 
     set_target_properties(${executable} PROPERTIES
       BUILD_WITH_INSTALL_RPATH YES
       INSTALL_RPATH "${RPATH_LIST}")
 
-  elseif(SWIFT_HOST_VARIANT_SDK MATCHES "LINUX|ANDROID|OPENBSD" AND ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE)
+  elseif(SWIFT_HOST_VARIANT_SDK MATCHES "LINUX|ANDROID|OPENBSD" AND ASHT_HAS_SWIFT_MODULES AND BOOTSTRAPPING_MODE)
     set(swiftrt "swiftImageRegistrationObject${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}-${SWIFT_HOST_VARIANT_ARCH}")
-    if(${LIBSWIFT_BUILD_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
+    if(${BOOTSTRAPPING_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
       # At build time and and run time, link against the swift libraries in the
       # installed host toolchain.
-      get_filename_component(swift_bin_dir ${SWIFT_EXEC_FOR_LIBSWIFT} DIRECTORY)
+      get_filename_component(swift_bin_dir ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
       get_filename_component(swift_dir ${swift_bin_dir} DIRECTORY)
       set(host_lib_dir "${swift_dir}/lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
 
       target_link_libraries(${executable} PRIVATE ${swiftrt})
       target_link_libraries(${executable} PRIVATE "swiftCore")
 
       target_link_directories(${executable} PRIVATE ${host_lib_dir})
-      if(LIBSWIFT_BUILD_MODE STREQUAL "HOSTTOOLS")
+      if(BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS")
         set_target_properties(${executable} PROPERTIES
           BUILD_WITH_INSTALL_RPATH YES
           INSTALL_RPATH  "${host_lib_dir}")
@@ -799,7 +799,7 @@ function(add_swift_host_tool executable)
           INSTALL_RPATH  "$ORIGIN/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
       endif()
 
-    elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
+    elseif(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING")
       # At build time link against the built swift libraries from the
       # previous bootstrapping stage.
       if (NOT "${ASHT_BOOTSTRAPPING}" STREQUAL "0")
@@ -815,10 +815,10 @@ function(add_swift_host_tool executable)
         BUILD_WITH_INSTALL_RPATH YES
         INSTALL_RPATH  "$ORIGIN/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
 
-    elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
-      message(FATAL_ERROR "LIBSWIFT_BUILD_MODE 'BOOTSTRAPPING-WITH-HOSTLIBS' not supported on Linux")
+    elseif(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
+      message(FATAL_ERROR "BOOTSTRAPPING_MODE 'BOOTSTRAPPING-WITH-HOSTLIBS' not supported on Linux")
     else()
-      message(FATAL_ERROR "Unknown LIBSWIFT_BUILD_MODE '${LIBSWIFT_BUILD_MODE}'")
+      message(FATAL_ERROR "Unknown BOOTSTRAPPING_MODE '${BOOTSTRAPPING_MODE}'")
     endif()
   endif()
 

cmake/modules/SwiftConfig.cmake.in

@@ -17,7 +17,7 @@ set(SWIFT_LIBRARY_DIR "@SWIFT_LIBRARY_DIRS@")
 set(SWIFT_CMAKE_DIR "@SWIFT_CMAKE_DIR@")
 set(SWIFT_BINARY_DIR "@SWIFT_BINARY_DIR@")
 
-set(LIBSWIFT_BUILD_MODE "@LIBSWIFT_BUILD_MODE@")
+set(BOOTSTRAPPING_MODE "@BOOTSTRAPPING_MODE@")
 
 set(CMARK_TARGETS_FILE @SWIFT_PATH_TO_CMARK_BUILD@/src/cmarkTargets.cmake)
 if(NOT TARGET libcmark_static AND EXISTS ${CMARK_TARGETS_FILE})

cmake/modules/SwiftUtils.cmake

@@ -96,7 +96,7 @@ endfunction()
 # from the previous bootstrapping stage.
 function(get_bootstrapping_swift_lib_dir bs_lib_dir bootstrapping)
   set(bs_lib_dir "")
-  if(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
+  if(BOOTSTRAPPING_MODE STREQUAL "BOOTSTRAPPING")
     set(lib_dir
         "${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
     # If building the stdlib with bootstrapping, the compiler has to pick up

stdlib/public/Platform/CMakeLists.txt

@@ -42,7 +42,7 @@ set(swiftDarwin_common_options
       DEPENDS ${darwin_depends})
 
 
-if(${LIBSWIFT_BUILD_MODE} STREQUAL "BOOTSTRAPPING" AND
+if(${BOOTSTRAPPING_MODE} STREQUAL "BOOTSTRAPPING" AND
    ${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_DARWIN_PLATFORMS)
 
   set(swiftDarwin_common_bootstrapping_options

stdlib/public/SwiftOnoneSupport/CMakeLists.txt

@@ -10,7 +10,7 @@ set(swiftOnoneSupport_common_options
   SWIFT_COMPILE_FLAGS "-parse-stdlib" "-Xllvm" "-sil-inline-generics=false" "-Xfrontend" "-validate-tbd-against-ir=none" "-Xfrontend" "-check-onone-completeness" "-Xfrontend" "-disable-access-control" "${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS}" "${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}"
   LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}")
 
-if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${LIBSWIFT_BUILD_MODE} STREQUAL "BOOTSTRAPPING")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${BOOTSTRAPPING_MODE} STREQUAL "BOOTSTRAPPING")
 
   set(swiftOnoneSupport_common_bootstrapping_options
     SHARED

stdlib/public/SwiftShims/CMakeLists.txt

@@ -155,7 +155,7 @@ if(NOT SWIFT_BUILT_STANDALONE)
   endforeach()
 endif()
 
-if(${LIBSWIFT_BUILD_MODE} MATCHES "BOOTSTRAPPING.*")
+if(${BOOTSTRAPPING_MODE} MATCHES "BOOTSTRAPPING.*")
   foreach(bootstrapping "0" "1")
     get_bootstrapping_path(outdir ${SWIFTLIB_DIR} ${bootstrapping})
     set(target_name "symlink-headers-bootstrapping${bootstrapping}")

stdlib/public/core/CMakeLists.txt

@@ -315,7 +315,7 @@ set(swiftCore_common_options
 set(swiftCore_common_dependencies
     copy_shim_headers "${SWIFTLIB_DIR}/shims" ${GROUP_INFO_JSON_FILE})
 
-if(${LIBSWIFT_BUILD_MODE} STREQUAL "BOOTSTRAPPING")
+if(${BOOTSTRAPPING_MODE} STREQUAL "BOOTSTRAPPING")
 
   set(b0_deps symlink-headers-bootstrapping0)
   set(b1_deps symlink-headers-bootstrapping1)

test/CMakeLists.txt

@@ -173,9 +173,9 @@ if(NOT CMAKE_CFG_INTDIR STREQUAL ".")
        "--param" "build_mode=${CMAKE_CFG_INTDIR}")
 endif()
 
-if (LIBSWIFT_BUILD_MODE)
+if (BOOTSTRAPPING_MODE)
   list(APPEND SWIFT_LIT_ARGS
-       "--param" "libswift_build_mode=${LIBSWIFT_BUILD_MODE}")
+       "--param" "bootstrapping_mode=${BOOTSTRAPPING_MODE}")
 endif()
 
 if (LLVM_USE_SANITIZER STREQUAL "Address")