build: support cross-compiling to windows

Author: compnerd

CMakeLists.txt

@@ -193,7 +193,7 @@ set(SWIFT_ANDROID_DEPLOY_DEVICE_PATH "" CACHE STRING
 # User-configurable ICU specific options for Android, FreeBSD, Linux.
 #
 
-foreach(sdk ANDROID;FREEBSD;LINUX)
+foreach(sdk ANDROID;FREEBSD;LINUX;WINDOWS)
   set(SWIFT_${sdk}_ICU_UC "" CACHE STRING
       "Path to a directory containing the icuuc library for ${sdk}")
   set(SWIFT_${sdk}_ICU_UC_INCLUDE "" CACHE STRING
@@ -736,6 +736,12 @@ if("${SWIFT_PRIMARY_VARIANT_ARCH}" STREQUAL "")
   set(SWIFT_PRIMARY_VARIANT_ARCH "${SWIFT_PRIMARY_VARIANT_ARCH_default}")
 endif()
 
+# Should we cross-compile the standard library for Windows?
+is_sdk_requested(WINDOWS swift_build_windows)
+if(swift_build_windows)
+  configure_sdk_windows(WINDOWS "Windows" "msvc" i686)
+endif()
+
 if("${SWIFT_SDKS}" STREQUAL "")
   set(SWIFT_SDKS "${SWIFT_CONFIGURED_SDKS}")
 endif()

cmake/modules/AddSwift.cmake

@@ -101,6 +101,13 @@ function(_add_variant_c_compile_link_flags)
       "-B" "${SWIFT_ANDROID_NDK_PATH}/toolchains/arm-linux-androideabi-${SWIFT_ANDROID_NDK_GCC_VERSION}/prebuilt/linux-x86_64/arm-linux-androideabi/bin/")
   endif()
 
+  if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
+    list(APPEND result "-DLLVM_ON_WIN32")
+    list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
+    # TODO(compnerd) handle /MT
+    list(APPEND result "-D_DLL")
+    list(APPEND result "-fms-compatibility-version=1900")
+  endif()
 
   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
 
@@ -176,6 +183,18 @@ function(_add_variant_c_compile_flags)
     list(APPEND result "-g0")
   endif()
 
+  if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
+    list(APPEND result -Xclang;--dependent-lib=oldnames)
+    # TODO(compnerd) handle /MT, /MTd, /MD, /MDd
+    if("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
+      list(APPEND result "-D_MD")
+      list(APPEND result -Xclang;--dependent-lib=msvcrt)
+    else()
+      list(APPEND result "-D_MDd")
+      list(APPEND result -Xclang;--dependent-lib=msvcrtd)
+    endif()
+  endif()
+
   if(CFLAGS_ENABLE_ASSERTIONS)
     list(APPEND result "-UNDEBUG")
   else()
@@ -264,6 +283,10 @@ function(_add_variant_link_flags)
     list(APPEND result "-lpthread")
   elseif("${LFLAGS_SDK}" STREQUAL "CYGWIN")
     # No extra libraries required.
+  elseif("${LFLAGS_SDK}" STREQUAL "WINDOWS")
+    # NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
+    # options.  This causes conflicts.
+    list(APPEND result "-nostdlib")
   elseif("${LFLAGS_SDK}" STREQUAL "ANDROID")
     list(APPEND result
         "-ldl"
@@ -594,6 +617,16 @@ function(_add_swift_library_single target name)
     endif()
   endif()
 
+  if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
+    list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xfrontend;-autolink-library;-Xfrontend;oldnames)
+    # TODO(compnerd) handle /MT and /MTd
+    if("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
+      list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xfrontend;-autolink-library;-Xfrontend;msvcrt)
+    else()
+      list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xfrontend;-autolink-library;-Xfrontend;msvcrtd)
+    endif()
+  endif()
+
   # FIXME: don't actually depend on the libraries in SWIFTLIB_SINGLE_LINK_LIBRARIES,
   # just any swiftmodule files that are associated with them.
   handle_swift_sources(
@@ -649,6 +682,28 @@ function(_add_swift_library_single target name)
     endif()
   endif()
 
+  if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
+    if("${libkind}" STREQUAL "STATIC")
+      set_property(TARGET "${target}" PROPERTY PREFIX "lib")
+      set_property(TARGET "${target}" PROPERTY SUFFIX ".lib")
+    elseif("${libkind}" STREQUAL "SHARED")
+      set_property(TARGET "${target}" PROPERTY PREFIX "")
+      set_property(TARGET "${target}" PROPERTY SUFFIX ".dll")
+
+      # Each dll has an associated .lib (import library); since we may be
+      # building on a non-DLL platform (not windows), create an imported target
+      # for the library which created implicitly by the dll.
+      add_custom_command_target(${target}_IMPORT_LIBRARY
+                                OUTPUT "${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/${name}.lib"
+                                DEPENDS "${target}")
+      add_library(${target}_IMPLIB SHARED IMPORTED GLOBAL)
+      set_property(TARGET "${target}_IMPLIB" PROPERTY
+          IMPORTED_LOCATION "${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/${name}.lib")
+      add_dependencies(${target}_IMPLIB ${${target}_IMPORT_LIBRARY})
+    endif()
+    set_property(TARGET "${target}" PROPERTY NO_SONAME ON)
+  endif()
+
   # The section metadata objects are generated sources, and we need to tell CMake
   # not to expect to find them prior to their generation.
   if("${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
@@ -880,7 +935,9 @@ function(_add_swift_library_single target name)
      "${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
     list(APPEND link_flags "-fuse-ld=gold")
   endif()
-  if (SWIFT_ENABLE_LLD_LINKER)
+  if(SWIFT_ENABLE_LLD_LINKER OR
+     ("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS" AND
+      NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
     list(APPEND link_flags "-fuse-ld=lld")
   endif()
 
@@ -925,6 +982,34 @@ function(_add_swift_library_single target name)
       COMPILE_FLAGS " ${c_compile_flags}")
   set_property(TARGET "${target}" APPEND_STRING PROPERTY
     LINK_FLAGS " ${link_flags} -L${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR} -L${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFTLIB_SINGLE_SUBDIR} -L${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}")
+
+  # Adjust the linked libraries for windows targets.  On Windows, the link is
+  # performed against the import library, and the runtime uses the dll.  Not
+  # doing so will result in incorrect symbol resolution and linkage.  We created
+  # import library targets when the library was added.  Use that to adjust the
+  # link libraries.
+  if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
+    foreach(library_list LINK_LIBRARIES INTERFACE_LINK_LIBRARIES PRIVATE_LINK_LIBRARIES)
+      set(import_libraries)
+      foreach(library ${SWIFTLIB_SINGLE_${library_list}})
+        # Ensure that the library is a target.  If an absolute path was given,
+        # then we do not have an import library associated with it.  This occurs
+        # primarily with ICU (which will be an import library).  Import
+        # libraries are only associated with shared libraries, so add an
+        # additional check for that as well.
+        set(import_library ${library})
+        if(TARGET ${library})
+          get_target_property(type ${library} TYPE)
+          if(${type} STREQUAL "SHARED_LIBRARY")
+            set(import_library ${library}_IMPLIB)
+          endif()
+        endif()
+        list(APPEND import_libraries ${import_library})
+      endforeach()
+      set(SWIFTLIB_SINGLE_${library_list} ${import_libraries})
+    endforeach()
+  endif()
+
   if("${libkind}" STREQUAL "OBJECT")
     _require_empty_list(
         "${SWIFTLIB_SINGLE_PRIVATE_LINK_LIBRARIES}"
@@ -1329,14 +1414,23 @@ function(add_swift_library name)
       if(NOT SWIFTLIB_OBJECT_LIBRARY)
         # Determine the name of the universal library.
         if(SWIFTLIB_SHARED)
-          set(UNIVERSAL_LIBRARY_NAME
-            "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${name}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+          if("${sdk}" STREQUAL "WINDOWS")
+            set(UNIVERSAL_LIBRARY_NAME
+              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${name}.dll")
+          else()
+            set(UNIVERSAL_LIBRARY_NAME
+              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_SHARED_LIBRARY_PREFIX}${name}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+          endif()
         else()
-          set(UNIVERSAL_LIBRARY_NAME
-            "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+          if("${sdk}" STREQUAL "WINDOWS")
+            set(UNIVERSAL_LIBRARY_NAME
+              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/lib${name}.lib")
+          else()
+            set(UNIVERSAL_LIBRARY_NAME
+              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
+          endif()
         endif()
 
-
         set(lipo_target "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
         _add_swift_lipo_target(
             ${lipo_target}
@@ -1552,7 +1646,9 @@ function(_add_swift_executable_single name)
      "${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
     list(APPEND link_flags "-fuse-ld=gold")
   endif()
-  if(SWIFT_ENABLE_LLD_LINKER)
+  if(SWIFT_ENABLE_LLD_LINKER OR
+     ("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS" AND
+      NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
     list(APPEND link_flags "-fuse-ld=lld")
   endif()
 

cmake/modules/FindICU.cmake

@@ -25,7 +25,7 @@ foreach(MODULE ${ICU_FIND_COMPONENTS})
   endif()
 endforeach()
 
-foreach(sdk ANDROID;FREEBSD;LINUX)
+foreach(sdk ANDROID;FREEBSD;LINUX;WINDOWS)
   foreach(MODULE ${ICU_FIND_COMPONENTS})
     if("${SWIFT_${sdk}_ICU_${MODULE}_INCLUDE}" STREQUAL "")
       set(SWIFT_${sdk}_ICU_${MODULE}_INCLUDE ${ICU_${MODULE}_INCLUDE_DIRS})

cmake/modules/SwiftConfigureSDK.cmake

@@ -8,7 +8,12 @@ set(SWIFT_CONFIGURED_SDKS)
 # Report the given SDK to the user.
 function(_report_sdk prefix)
   message(STATUS "${SWIFT_SDK_${prefix}_NAME} SDK:")
-  message(STATUS "  Path: ${SWIFT_SDK_${prefix}_PATH}")
+  if("${prefix}" STREQUAL "WINDOWS")
+    message(STATUS "  INCLUDE: $ENV{INCLUDE}")
+    message(STATUS "  LIB: $ENV{LIB}")
+  else()
+    message(STATUS "  Path: ${SWIFT_SDK_${prefix}_PATH}")
+  endif()
   message(STATUS "  Version: ${SWIFT_SDK_${prefix}_VERSION}")
   message(STATUS "  Build number: ${SWIFT_SDK_${prefix}_BUILD_NUMBER}")
   message(STATUS "  Deployment version: ${SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION}")
@@ -138,6 +143,35 @@ macro(configure_sdk_unix
   _report_sdk("${prefix}")
 endmacro()
 
+macro(configure_sdk_windows prefix sdk_name environment architectures)
+  # Note: this has to be implemented as a macro because it sets global
+  # variables.
+
+  set(SWIFT_SDK_${prefix}_NAME "${sdk_name}")
+  # NOTE: set the path to / to avoid a spurious `--sysroot` from being passed
+  # to the driver -- rely on the `INCLUDE` AND `LIB` environment variables
+  # instead.
+  set(SWIFT_SDK_${prefix}_PATH "/")
+  set(SWIFT_SDK_${prefix}_VERSION "NOTFOUND")
+  set(SWIFT_SDK_${prefix}_BUILD_NUMBER "NOTFOUND")
+  set(SWIFT_SDK_${prefix}_DEPLOYMENT_VERSION "NOTFOUND")
+  set(SWIFT_SDK_${prefix}_LIB_SUBDIR "windows")
+  set(SWIFT_SDK_${prefix}_VERSION_MIN_NAME "NOTFOUND")
+  set(SWIFT_SDK_${prefix}_TRIPLE_NAME "NOTFOUND")
+  set(SWIFT_SDK_${prefix}_ARCHITECTURES "${architectures}")
+  set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "COFF")
+
+  foreach(arch ${architectures})
+    set(SWIFT_SDK_${prefix}_ARCH_${arch}_TRIPLE
+        "${arch}-unknown-windows-${environment}")
+  endforeach()
+
+  # Add this to the list of known SDKs.
+  list(APPEND SWIFT_CONFIGURED_SDKS "${prefix}")
+
+  _report_sdk("${prefix}")
+endmacro()
+
 # Configure a variant of a certain SDK
 #
 # In addition to the SDK and architecture, a variant determines build settings.

cmake/modules/SwiftSetIfArchBitness.cmake

@@ -7,10 +7,11 @@ function(set_if_arch_bitness var_name)
       ${ARGN})
 
   if("${SIA_ARCH}" STREQUAL "i386" OR
-      "${SIA_ARCH}" STREQUAL "armv6" OR
-      "${SIA_ARCH}" STREQUAL "armv7" OR
-      "${SIA_ARCH}" STREQUAL "armv7k" OR
-      "${SIA_ARCH}" STREQUAL "armv7s")
+     "${SIA_ARCH}" STREQUAL "i686" OR
+     "${SIA_ARCH}" STREQUAL "armv6" OR
+     "${SIA_ARCH}" STREQUAL "armv7" OR
+     "${SIA_ARCH}" STREQUAL "armv7k" OR
+     "${SIA_ARCH}" STREQUAL "armv7s")
     set("${var_name}" "${SIA_CASE_32_BIT}" PARENT_SCOPE)
   elseif("${SIA_ARCH}" STREQUAL "x86_64" OR
          "${SIA_ARCH}" STREQUAL "arm64" OR

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -91,6 +91,11 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   include(AddSwiftTableGen) # This imports TableGen from LLVM.
   include(HandleLLVMOptions)
 
+  # HACK: this ugly tweaking is to prevent the propogation of the flag from LLVM
+  # into swift.  The use of this flag pollutes all targets, and we are not able
+  # to remove it on a per-target basis which breaks cross-compilation.
+  string(REGEX REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
+
   set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
   string(REGEX REPLACE "([0-9]+)\\.[0-9]+(\\.[0-9]+)?" "\\1" PACKAGE_VERSION_MAJOR
     ${PACKAGE_VERSION})

stdlib/public/stubs/Stubs.cpp

@@ -384,7 +384,11 @@ __muloti4(ti_int a, ti_int b, int* overflow)
 
 #endif
 
-#if defined(__linux__) && defined(__arm__)
+// FIXME: ideally we would have a slow path here for Windows which would be
+// lowered to instructions as though MSVC had generated.  There does not seem to
+// be a MSVC provided multiply with overflow detection that I can see, but this
+// avoids an unncessary dependency on compiler-rt for a single function.
+#if (defined(__linux__) && defined(__arm__)) || defined(_MSC_VER)
 // Similar to above, but with mulodi4.  Perhaps this is
 // something that shouldn't be done, and is a bandaid over
 // some other lower-level architecture issue that I'm

test/CMakeLists.txt

@@ -59,7 +59,8 @@ function(get_test_dependencies SDK result_var_name)
      ("${SDK}" STREQUAL "LINUX") OR
      ("${SDK}" STREQUAL "CYGWIN") OR
      ("${SDK}" STREQUAL "FREEBSD") OR
-     ("${SDK}" STREQUAL "ANDROID"))
+     ("${SDK}" STREQUAL "ANDROID") OR
+     ("${SDK}" STREQUAL "WINDOWS"))
     # No extra dependencies.
   else()
     message(FATAL_ERROR "Unknown SDK: ${SDK}")