[WIP] Experimenting building Windows runtimes when cross compiling LLVM toolchain

[haowei]

Summary

This is a working in progress patch, and it needs clean up and refactor. It is mainly for understanding what are needed to build windows runtime when the LLVM is being cross compiled for a different architecture. And to discuss the direction of refactoring the cmake configurations for the clang bootstrap build as well as LLVM runtimes build.

The use case is to include the Windows runtime build when cross compiling LLVM for an arch different from the host (e.g. building aarch64 on an x64 machine). This will be needed in the future when cross compile LLVM Windows toolchain for aarch64 on an x64 machine.

clang/CMakeLists.txt

 endif()
 
 add_subdirectory(cmake/modules)
 
 if(CLANG_STAGE)
   message(STATUS "Setting current clang stage to: ${CLANG_STAGE}")
 endif()
 
+message(NOTICE "CLANG_ENABLE_BOOTSTRAP is ${CLANG_ENABLE_BOOTSTRAP}")
 if (CLANG_ENABLE_BOOTSTRAP)
   include(ExternalProject)
 
   add_custom_target(clang-bootstrap-deps DEPENDS clang)
 
   if(NOT CLANG_STAGE)
     set(CLANG_STAGE stage1)
   endif()
if(BOOTSTRAP_LLVM_ENABLE_LLD)
     # adding lld to clang-bootstrap-deps without having it enabled in
     # LLVM_ENABLE_PROJECTS just generates a cryptic error message.
     if (NOT "lld" IN_LIST LLVM_ENABLE_PROJECTS)
       message(FATAL_ERROR "LLD is enabled in the bootstrap build, but lld is not in LLVM_ENABLE_PROJECTS")
     endif()
     add_dependencies(clang-bootstrap-deps lld)
   endif()
 
-  if (WIN32)
+  # message(NOTICE "CMAKE_CROSSCOMPILING is ${CMAKE_CROSSCOMPILING}")
+  # if (WIN32 OR CMAKE_CROSSCOMPILING)
     # Build llvm-rc and llvm-mt which are needed by the Windows build.
-    add_dependencies(clang-bootstrap-deps llvm-rc)
-    if(LLVM_ENABLE_LIBXML2)
-      add_dependencies(clang-bootstrap-deps llvm-mt)
-    endif()
-  endif()
+  add_dependencies(clang-bootstrap-deps llvm-rc llvm-lib)
+  # endif()
 
   # If the next stage is LTO we need to depend on LTO and possibly lld or LLVMgold
   if(BOOTSTRAP_LLVM_ENABLE_LTO OR LLVM_ENABLE_LTO AND NOT LLVM_BUILD_INSTRUMENTED)
     if(APPLE)
       add_dependencies(clang-bootstrap-deps LTO)
       # on Darwin we need to set DARWIN_LTO_LIBRARY so that -flto will work
       # using the just-built compiler, and we need to override DYLD_LIBRARY_PATH
       # so that the host object file tools will use the just-built libLTO.

llvm/cmake/modules/LLVMExternalProjectUtils.cmake

foreach(variableName ${variableNames})
       if(variableName MATCHES "^${prefix}")
         string(REPLACE ";" "|" value "${${variableName}}")
         list(APPEND PASSTHROUGH_VARIABLES
           -D${variableName}=${value})
       endif()
     endforeach()
   endforeach()
 
+  message(NOTICE "extproj ARG_USE_TOOLCHAIN is ${ARG_USE_TOOLCHAIN}")
+  message(NOTICE "extproj CMAKE_CROSSCOMPILING is ${CMAKE_CROSSCOMPILING}")
+  message(NOTICE "extproj CLANG_IN_TOOLCHAIN is ${CLANG_IN_TOOLCHAIN}")
   if(ARG_USE_TOOLCHAIN AND NOT CMAKE_CROSSCOMPILING)
     if(CLANG_IN_TOOLCHAIN)
       if(is_msvc_target)
         set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
                           -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
                           -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
       else()
         set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang${CMAKE_EXECUTABLE_SUFFIX}
if(ARG_EXCLUDE_FROM_ALL)
     set(exclude EXCLUDE_FROM_ALL 1)
   endif()
 
   if(CMAKE_SYSROOT)
     set(sysroot_arg -DCMAKE_SYSROOT=${CMAKE_SYSROOT})
   endif()
 
   if(CMAKE_CROSSCOMPILING OR _cmake_system_name STREQUAL AIX)
+    if (ARG_USE_TOOLCHAIN AND CLANG_IN_TOOLCHAIN AND is_msvc_target)
+      get_filename_component(HOST_TOOLCHAIN_DIR ${CMAKE_C_COMPILER} DIRECTORY)
+      set(compiler_args -DCMAKE_C_COMPILER=${HOST_TOOLCHAIN_DIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
+                        -DCMAKE_CXX_COMPILER=${HOST_TOOLCHAIN_DIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
+                        -DCMAKE_ASM_COMPILER=${HOST_TOOLCHAIN_DIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+      if(lld IN_LIST TOOLCHAIN_TOOLS)
+        list(APPEND compiler_args -DCMAKE_LINKER=${HOST_TOOLCHAIN_DIR}/lld-link${CMAKE_EXECUTABLE_SUFFIX})
+      endif()
+      if(llvm-ar IN_LIST TOOLCHAIN_TOOLS)
+        list(APPEND compiler_args -DCMAKE_AR=${HOST_TOOLCHAIN_DIR}/llvm-lib${CMAKE_EXECUTABLE_SUFFIX})
+      endif()
+      if(llvm-mt IN_LIST TOOLCHAIN_TOOLS)
+        list(APPEND compiler_args -DCMAKE_MT=${HOST_TOOLCHAIN_DIR}/llvm-mt${CMAKE_EXECUTABLE_SUFFIX})
+      endif()
+      if(llvm-rc IN_LIST TOOLCHAIN_TOOLS)
+        list(APPEND compiler_args -DCMAKE_RC_COMPILER=${HOST_TOOLCHAIN_DIR}/llvm-rc${CMAKE_EXECUTABLE_SUFFIX})
+      endif()
+    else()
       set(compiler_args -DCMAKE_ASM_COMPILER=${CMAKE_ASM_COMPILER}
                         -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
                         -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
                         -DCMAKE_LINKER=${CMAKE_LINKER}
                         -DCMAKE_AR=${CMAKE_AR}
                         -DCMAKE_RANLIB=${CMAKE_RANLIB}
                         -DCMAKE_NM=${CMAKE_NM}
                         -DCMAKE_OBJCOPY=${CMAKE_OBJCOPY}
                         -DCMAKE_OBJDUMP=${CMAKE_OBJDUMP}
                         -DCMAKE_STRIP=${CMAKE_STRIP}
-                      -DCMAKE_READELF=${CMAKE_READELF})
+                        -DCMAKE_READELF=${CMAKE_READELF}
+                        -DCMAKE_RC_COMPILER=${CMAKE_RC_COMPILER}
+                        -DCMAKE_MT=${CMAKE_MT})
+    endif()
   endif()
+  message(NOTICE "extproj compiler_args is ${compiler_args}")
   if(CMAKE_CROSSCOMPILING)
     set(llvm_config_path ${LLVM_CONFIG_PATH})
 
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
       string(REGEX MATCH "^[0-9]+" CLANG_VERSION_MAJOR
              ${PACKAGE_VERSION})
       set(resource_dir "${LLVM_LIBRARY_DIR}/clang/${CLANG_VERSION_MAJOR}")
       set(flag_types ASM C CXX MODULE_LINKER SHARED_LINKER EXE_LINKER)

llvm/runtimes/CMakeLists.txt

macro(set_enable_per_target_runtime_dir)
   endif()
 endmacro()
 
 function(builtin_default_target compiler_rt_path)
   cmake_parse_arguments(ARG "" "" "DEPENDS" ${ARGN})
 
   set_enable_per_target_runtime_dir()
 
+  message(NOTICE "builtin target for default")
+  #message(NOTICE "cmake args ${CMAKE_ARGS}")
+  message(NOTICE "cmake common args ${COMMON_CMAKE_ARGS}")
+  message(NOTICE "extra args:")
+  message(NOTICE ${BUILTINS_CMAKE_ARGS})
+
   llvm_ExternalProject_Add(builtins
                            ${compiler_rt_path}/lib/builtins
                            DEPENDS ${ARG_DEPENDS}
                            CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                       -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                       -DLLVM_DEFAULT_TARGET_TRIPLE=${LLVM_TARGET_TRIPLE}
                                       -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=${LLVM_ENABLE_PER_TARGET_RUNTIME_DIR}
                                       -DCMAKE_C_COMPILER_WORKS=ON
foreach(variableName ${variableNames})
     string(FIND "${variableName}" "BUILTINS_${target}" out)
     if("${out}" EQUAL 0)
       string(REPLACE "BUILTINS_${target}_" "" new_name ${variableName})
       string(REPLACE ";" "|" new_value "${${variableName}}")
       list(APPEND ${target}_extra_args "-D${new_name}=${new_value}")
     endif()
   endforeach()
 
+  message(NOTICE "builtin target for ${target}")
+  #message(NOTICE "cmake args ${CMAKE_ARGS}")
+  message(NOTICE "cmake common args ${COMMON_CMAKE_ARGS}")
+  message(NOTICE "extra args:")
+  message(NOTICE ${${target}_extra_args})
+
   llvm_ExternalProject_Add(builtins-${target}
                            ${compiler_rt_path}/lib/builtins
                            DEPENDS ${ARG_DEPENDS}
                            CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                       -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                       -DLLVM_DEFAULT_TARGET_TRIPLE=${target}
                                       -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON
                                       -DCMAKE_C_COMPILER_WORKS=ON
function(runtime_default_target)
 
   if(LLVM_INCLUDE_TESTS)
     set_property(GLOBAL APPEND PROPERTY LLVM_ALL_LIT_TESTSUITES "@${LLVM_BINARY_DIR}/runtimes/runtimes-bins/lit.tests")
     list(APPEND test_targets runtimes-test-depends check-runtimes)
   endif()
 
   set_enable_per_target_runtime_dir()
 
+  message(NOTICE "runtime target for default")
+  #message(NOTICE "cmake args ${CMAKE_ARGS}")
+  message(NOTICE "cmake common args ${COMMON_CMAKE_ARGS}")
+  message(NOTICE "extra args:")
+  message(NOTICE ${RUNTIMES_CMAKE_ARGS})
+  message(NOTICE ${ARG_CMAKE_ARGS})
+
   llvm_ExternalProject_Add(runtimes
                            ${CMAKE_CURRENT_SOURCE_DIR}/../../runtimes
                            DEPENDS ${ARG_DEPENDS}
                            # Builtins were built separately above
                            CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
                                       -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                       -DLLVM_DEFAULT_TARGET_TRIPLE=${LLVM_TARGET_TRIPLE}
                                       -DLLVM_ENABLE_PROJECTS_USED=${LLVM_ENABLE_PROJECTS_USED}
function(runtime_register_target name target)
   endif()
 
   if(NOT RUNTIMES_${name}_LLVM_USE_LINKER AND NOT RUNTIMES_${target}_LLVM_USE_LINKER)
     list(APPEND ${name}_extra_args -DLLVM_USE_LINKER=${LLVM_USE_LINKER})
   endif()
 
   set_enable_per_target_runtime_dir()
 
+  message(NOTICE "runtime target for ${target}")
+  #message(NOTICE "cmake args ${CMAKE_ARGS}")
+  message(NOTICE "cmake common args ${COMMON_CMAKE_ARGS}")
+  message(NOTICE "extra args:")
+  message(NOTICE ${${name}_extra_args})
+
   llvm_ExternalProject_Add(runtimes-${name}
                            ${CMAKE_CURRENT_SOURCE_DIR}/../../runtimes
                            DEPENDS ${${name}_deps}
                            # Builtins were built separately above
                            CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
                                       -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                       -DLLVM_DEFAULT_TARGET_TRIPLE=${target}
                                       -DLLVM_ENABLE_PROJECTS_USED=${LLVM_ENABLE_PROJECTS_USED}