Build fixes for Windows (#42138)

* cmake: Windows, adjust compiler identification on compiler swap

The latest CMake on Windows doesn't add `_CRT_USE_BUILTIN_OFFSETOF`
flag after we swap the compiler to clang-cl for targets like SourceKit. Also
`_add_host_variant_c_compile_flags` doesn't do so, because compiler
identification still points to MSVC compiler.

`_CRT_USE_BUILTIN_OFFSETOF` flag is necessary for `offsetof` calls to be
accepted as an integral constant expression.

This patch adjusts compiler identification on compiler swap and also
addresses some configuration issues related to clang-cl.

* [cmake] Add support for external clang/clang-cl

We need an option to pass external host clang location in case
we can't use just-built clang, e.g. when we are building for
different target architecture.

Also, this adds target options for clang-cl, enabling us to
build for arm64 on Windows@amd64.

* build: adjust the flags addition for the standard library

The standard library cannot be built with MSVC's compiler.  However, if
it is built with the toolchain which uses MSVC, it would fail to add
this flag.  With recent VS2022 toolsets, this is a problem as we would
fail to be able to use the `offsetof` macro.  Unconditionally apply the
definition when building the standard library.

Co-authored-by: Alexander Smarus <[email protected]>

Author: compnerd

cmake/modules/AddSwift.cmake

@@ -118,13 +118,19 @@ function(_add_host_variant_c_compile_link_flags name)
     set(DEPLOYMENT_VERSION ${SWIFT_ANDROID_API_LEVEL})
   endif()
 
-  # MSVC, clang-cl, gcc don't understand -target.
-  if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+  # MSVC and gcc don't understand -target.
+  # clang-cl understands --target.
+  if(CMAKE_C_COMPILER_ID MATCHES "Clang")
     get_target_triple(target target_variant "${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}"
       MACCATALYST_BUILD_FLAVOR ""
       DEPLOYMENT_VERSION "${DEPLOYMENT_VERSION}")
-    target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-target;${target}>)
-    target_link_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-target;${target}>)
+    if("${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC") # clang-cl options
+      target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:--target=${target}>)
+      target_link_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:--target=${target}>)
+    else()
+      target_compile_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-target;${target}>)
+      target_link_options(${name} PRIVATE $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-target;${target}>)
+    endif()
   endif()
 
   if (CMAKE_Swift_COMPILER)
@@ -558,16 +564,24 @@ function(add_swift_host_library name)
 
     if(NOT ${CMAKE_C_COMPILER_ID} STREQUAL MSVC)
       swift_windows_get_sdk_vfs_overlay(ASHL_VFS_OVERLAY)
-      target_compile_options(${name} PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang -ivfsoverlay -Xclang ${ASHL_VFS_OVERLAY}">)
-
-      # MSVC doesn't support -Xclang. We don't need to manually specify
-      # the dependent libraries as `cl` does so.
-      target_compile_options(${name} PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang --dependent-lib=oldnames">
-        # TODO(compnerd) handle /MT, /MTd
-        $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang --dependent-lib=msvcrt$<$<CONFIG:Debug>:d>">
-        )
+      # Both clang and clang-cl on Windows set CMAKE_C_SIMULATE_ID to MSVC.
+      # We are using CMAKE_C_COMPILER_FRONTEND_VARIANT to detect the correct
+      # way to pass -Xclang arguments.
+      if ("${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC")
+        target_compile_options(${name} PRIVATE
+          $<$<COMPILE_LANGUAGE:C,CXX>:SHELL:/clang:-Xclang /clang:-ivfsoverlay /clang:-Xclang /clang:${ASHL_VFS_OVERLAY}>)
+      else()
+        target_compile_options(${name} PRIVATE
+          $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang -ivfsoverlay -Xclang ${ASHL_VFS_OVERLAY}">)
+
+          # MSVC doesn't support -Xclang. We don't need to manually specify
+          # the dependent libraries as `cl`/`clang-cl` does so.
+          target_compile_options(${name} PRIVATE
+            $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang --dependent-lib=oldnames">
+            # TODO(compnerd) handle /MT, /MTd
+            $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang --dependent-lib=msvcrt$<$<CONFIG:Debug>:d>">
+            )
+      endif()
     endif()
 
     set_target_properties(${name} PROPERTIES
@@ -978,9 +992,12 @@ function(add_swift_host_tool executable)
     target_include_directories(${executable} SYSTEM PRIVATE
       ${${SWIFT_HOST_VARIANT_ARCH}_INCLUDE})
 
-    if(NOT ${CMAKE_C_COMPILER_ID} STREQUAL MSVC)
+    # On Windows both clang-cl and clang simulate MSVC.
+    # We are using CMAKE_C_COMPILER_FRONTEND_VARIANT to distinguish
+    # clang from clang-cl.
+    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" AND NOT "${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC")
       # MSVC doesn't support -Xclang. We don't need to manually specify
-      # the dependent libraries as `cl` does so.
+      # the dependent libraries as `cl`/`clang-cl` does so.
       target_compile_options(${executable} PRIVATE
         $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:"SHELL:-Xclang --dependent-lib=oldnames">
         # TODO(compnerd) handle /MT, /MTd

cmake/modules/SwiftWindowsSupport.cmake

@@ -83,21 +83,30 @@ macro(swift_swap_compiler_if_needed target)
   if(NOT CMAKE_C_COMPILER_ID MATCHES Clang)
     if(CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME AND CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
       if(SWIFT_BUILT_STANDALONE)
-        get_target_property(CLANG_LOCATION clang LOCATION)
-        get_filename_component(CLANG_LOCATION ${CLANG_LOCATION} DIRECTORY)
+        get_target_property(SWIFT_CLANG_LOCATION clang LOCATION)
+        get_filename_component(SWIFT_CLANG_LOCATION ${SWIFT_CLANG_LOCATION} DIRECTORY)
       else()
-        set(CLANG_LOCATION ${LLVM_RUNTIME_OUTPUT_INTDIR})
+        set(SWIFT_CLANG_LOCATION ${LLVM_RUNTIME_OUTPUT_INTDIR})
       endif()
+    endif()
 
+    if (DEFINED SWIFT_CLANG_LOCATION)
       if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC")
-        set(CMAKE_C_COMPILER ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-        set(CMAKE_CXX_COMPILER ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_C_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_CXX_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_C_SIMULATE_ID MSVC)
+        set(CMAKE_C_COMPILER_FRONTEND_VARIANT MSVC)
+        set(CMAKE_CXX_SIMULATE_ID MSVC)
+        set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT MSVC)
       else()
-        set(CMAKE_C_COMPILER ${CLANG_LOCATION}/clang${CMAKE_EXECUTABLE_SUFFIX})
-        set(CMAKE_CXX_COMPILER ${CLANG_LOCATION}/clang++${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_C_COMPILER ${SWIFT_CLANG_LOCATION}/clang${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_CXX_COMPILER ${SWIFT_CLANG_LOCATION}/clang++${CMAKE_EXECUTABLE_SUFFIX})
       endif()
+      set(CMAKE_C_COMPILER_ID Clang)
+      set(CMAKE_CXX_COMPILER_ID Clang)
+      message(STATUS "C/C++ compiler for ${target} is set to: ${CMAKE_C_COMPILER}")
     else()
-      message(SEND_ERROR "${target} requires a clang based compiler")
+      message(SEND_ERROR "${target} requires a clang based compiler. Please set SWIFT_CLANG_LOCATION.")
     endif()
   endif()
 endmacro()

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -215,9 +215,7 @@ function(_add_target_variant_c_compile_flags)
     list(APPEND result "-DLLVM_ON_WIN32")
     list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
     list(APPEND result "-D_CRT_NONSTDC_NO_WARNINGS")
-    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-      list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
-    endif()
+    list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
     # TODO(compnerd) permit building for different families
     list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
     if("${CFLAGS_ARCH}" MATCHES arm)