Fix CUDA cross-compilation and Windows support (#17365)

- Enable CUDA language in CMake for proper .cu file compilation
- Fix compiler flag conditions to use COMPILE_LANGUAGE for
multi-language targets
- Use WIN32 instead of MSVC for MinGW cross-compilation dllexport
symbols
- Add MSVC-specific object library linking to preserve AOTI symbols
- Implement proper Windows error formatting in platform.cpp
- Add PAL initialization in CUDA memory shims for Windows DLL isolation
- Implement missing AOTI tensor shim APIs (create_tensor_from_blob,
clone)
- Add logging helper function for AOTI-generated code
- Add TORCH_CUDA_ARCH_LIST detection and warning for non-cross-compile
scenarios
- Add explicit 'configuration' field to CMake build presets for
consistency
- Fix ET_CHECK_TK_OK_OR_RETURN_ERROR macro to use do-while instead of
statement expression

This enables CUDA backend compilation on Windows with proper symbol
visibility and device architecture detection during cross-compilation
scenarios.

Author: larryliu0820

.github/workflows/cuda-windows.yml

@@ -32,6 +32,8 @@ jobs:
         model:
           - repo: "mistralai"
             name: "Voxtral-Mini-3B-2507"
+          - repo: "nvidia"
+            name: "parakeet-tdt"
         quant:
             - "non-quantized"
             - "quantized-int4-weight-only"

CMakePresets.json

@@ -197,9 +197,9 @@
         "EXECUTORCH_BUILD_CUDA": "ON"
       },
       "condition": {
-        "lhs": "${hostSystemName}",
-        "type": "equals",
-        "rhs": "Linux"
+        "type": "inList",
+        "string": "${hostSystemName}",
+        "list": ["Linux", "Windows"]
       }
     },
     {
@@ -289,6 +289,7 @@
       "name": "llm-release-install",
       "displayName": "Build and install LLM extension release artifacts",
       "configurePreset": "llm-release",
+      "configuration": "Release",
       "targets": [
         "install"
       ],
@@ -298,6 +299,7 @@
       "name": "llm-release-cuda-install",
       "displayName": "Build and install LLM extension release artifacts (CUDA)",
       "configurePreset": "llm-release-cuda",
+      "configuration": "Release",
       "targets": [
         "install"
       ],
@@ -307,6 +309,7 @@
       "name": "llm-release-metal-install",
       "displayName": "Build and install LLM extension release artifacts (Metal)",
       "configurePreset": "llm-release-metal",
+      "configuration": "Release",
       "targets": [
         "install"
       ],

backends/aoti/CMakeLists.txt

@@ -38,8 +38,10 @@ target_include_directories(
 )
 target_compile_options(
   aoti_common
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC
+    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/EHsc /GR>
+    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fexceptions
+    -frtti -fPIC>
 )
 target_compile_definitions(
   aoti_common PRIVATE $<$<PLATFORM_ID:Windows>:EXPORT_AOTI_FUNCTIONS>
@@ -107,15 +109,41 @@ endif()
 add_library(aoti_common_shims_slim STATIC ${_aoti_common_shims_slim_sources})
 target_compile_options(
   aoti_common_shims_slim
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC
+    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/EHsc /GR>
+    $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fexceptions
+    -frtti -fPIC>
 )
 target_compile_definitions(
   aoti_common_shims_slim PUBLIC $<$<PLATFORM_ID:Windows>:EXPORT_AOTI_FUNCTIONS>
 )
 
 target_link_libraries(aoti_common_shims_slim PUBLIC slimtensor ${CMAKE_DL_LIBS})
 
+if(MSVC)
+  # MSVC drops unreferenced symbols from static libs; export symbols by
+  # including the objects directly in the CUDA shims DLL.
+  add_library(
+    aoti_common_shims_slim_obj OBJECT ${_aoti_common_shims_slim_sources}
+  )
+  target_compile_options(
+    aoti_common_shims_slim_obj
+    PUBLIC
+      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/EHsc
+      /GR>
+      $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fexceptions
+      -frtti
+      -fPIC>
+  )
+  target_compile_definitions(
+    aoti_common_shims_slim_obj
+    PUBLIC $<$<PLATFORM_ID:Windows>:EXPORT_AOTI_FUNCTIONS>
+  )
+  target_link_libraries(
+    aoti_common_shims_slim_obj PUBLIC slimtensor ${CMAKE_DL_LIBS}
+  )
+endif()
+
 install(
   TARGETS aoti_common_shims_slim
   EXPORT ExecuTorchTargets

backends/cuda/CMakeLists.txt

@@ -33,6 +33,47 @@ set(CUDA_USE_STATIC_CUDA_RUNTIME OFF)
 
 find_package(CUDAToolkit REQUIRED)
 
+# Try to enable CUDA language when a working CUDA compiler toolchain is
+# available. Some CI environments (notably Windows packaging jobs) provide
+# CUDAToolkit headers/libs but cannot complete CUDA compiler identification. In
+# those cases, keep configuration working and skip CUDA-only sources below.
+if(NOT CMAKE_CUDA_COMPILER)
+  include(CheckLanguage)
+  check_language(CUDA)
+endif()
+
+if(CMAKE_CUDA_COMPILER)
+  enable_language(CUDA)
+endif()
+
+# Centralize Windows/MSVC checks used throughout this file.
+set(_cuda_is_msvc_toolchain OFF)
+if(MSVC)
+  set(_cuda_is_msvc_toolchain ON)
+endif()
+
+set(_cuda_is_windows_msvc OFF)
+if(WIN32 AND _cuda_is_msvc_toolchain)
+  set(_cuda_is_windows_msvc ON)
+endif()
+
+# Common C++ compile options for CUDA backend targets.
+if(_cuda_is_msvc_toolchain)
+  set(_cuda_cxx_compile_options /EHsc /GR)
+else()
+  set(_cuda_cxx_compile_options -fexceptions -frtti -fPIC)
+endif()
+
+# Platform-specific linker option for exporting symbols from shared libs.
+set(_cuda_export_dynamic_option "")
+if(NOT _cuda_is_msvc_toolchain)
+  if(APPLE)
+    set(_cuda_export_dynamic_option -Wl,-export_dynamic)
+  else()
+    set(_cuda_export_dynamic_option -Wl,--export-dynamic)
+  endif()
+endif()
+
 # Use ExecuTorch's standard way to find PyTorch libraries for AOTI
 include(${EXECUTORCH_ROOT}/tools/cmake/Utils.cmake)
 find_package_torch()
@@ -47,17 +88,11 @@ target_include_directories(
 )
 target_compile_options(
   cuda_tensor_maker
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC "$<$<COMPILE_LANGUAGE:CXX>:${_cuda_cxx_compile_options}>"
 )
 # Ensure symbols are exported properly
-if(APPLE)
-  target_link_options(cuda_tensor_maker PUBLIC -Wl,-export_dynamic)
-else()
-  target_link_options(
-    cuda_tensor_maker PUBLIC
-    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wl,--export-dynamic>
-  )
+if(_cuda_export_dynamic_option)
+  target_link_options(cuda_tensor_maker PUBLIC ${_cuda_export_dynamic_option})
 endif()
 
 # Link against ExecuTorch core libraries
@@ -84,8 +119,7 @@ target_include_directories(
 
 target_compile_options(
   cuda_platform
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC "$<$<COMPILE_LANGUAGE:CXX>:${_cuda_cxx_compile_options}>"
 )
 
 # Link against ExecuTorch core libraries
@@ -98,24 +132,30 @@ install(
 )
 
 # CUDA-specific AOTI shim symbols (dynamically linked)
-set(_aoti_cuda_shim_sources
-    runtime/shims/memory.cpp runtime/shims/cuda_guard.cpp
-    runtime/shims/int4mm.cu
+set(_aoti_cuda_shim_sources runtime/shims/memory.cpp
+                            runtime/shims/cuda_guard.cpp
 )
 
+# Only build int4mm shim when CUDA language/toolchain is available.
+if(CMAKE_CUDA_COMPILER)
+  list(APPEND _aoti_cuda_shim_sources runtime/shims/int4mm.cu)
+endif()
+
 add_library(aoti_cuda_shims SHARED ${_aoti_cuda_shim_sources})
 
 # Define CUDA_AVAILABLE to use SlimTensor on GPU in common_shims_slim.h
 target_compile_definitions(aoti_cuda_shims PRIVATE CUDA_AVAILABLE=1)
 
-# Define export macros for shared library
-if(MSVC)
+# Define export macros for shared library. Use WIN32 (not just MSVC) so MinGW
+# cross-compiles also emit dllexport symbols for AOTI shims.
+if(WIN32)
   target_compile_definitions(aoti_cuda_shims PRIVATE EXPORT_AOTI_FUNCTIONS)
-
-  # Ensure proper DLL import/export library naming on Windows
-  set_target_properties(
-    aoti_cuda_shims PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS OFF
-  )
+  if(_cuda_is_windows_msvc)
+    # Ensure proper DLL import/export library naming on Windows
+    set_target_properties(
+      aoti_cuda_shims PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS OFF
+    )
+  endif()
 endif()
 
 target_include_directories(
@@ -126,30 +166,35 @@ target_include_directories(
 
 target_compile_options(
   aoti_cuda_shims
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC "$<$<COMPILE_LANGUAGE:CXX>:${_cuda_cxx_compile_options}>"
 )
 
 # Ensure symbols are exported properly
-target_link_options(
-  aoti_cuda_shims PUBLIC $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wl,--export-dynamic>
-)
+if(_cuda_export_dynamic_option)
+  target_link_options(aoti_cuda_shims PUBLIC ${_cuda_export_dynamic_option})
+endif()
 
 # Link against CUDA::cudart, common AOTI library, cuda_tensor_maker, and
-# platform utilities. Use --whole-archive for aoti_common_shims_slim to ensure
-# all symbols are exported from this shared library.
-target_link_libraries(
-  aoti_cuda_shims
-  PRIVATE cuda_platform
-  PUBLIC $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wl,--whole-archive>
-         aoti_common_shims_slim
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wl,--no-whole-archive>
-         cuda_tensor_maker
-         CUDA::cudart
-         ${CMAKE_DL_LIBS}
-)
+# platform utilities. On non-MSVC, use --whole-archive for
+# aoti_common_shims_slim to force shim symbol retention.
+if(_cuda_is_msvc_toolchain)
+  target_link_libraries(
+    aoti_cuda_shims PRIVATE cuda_platform cuda_tensor_maker CUDA::cudart
+                            ${CMAKE_DL_LIBS}
+  )
+  # Link object library directly so symbols are pulled exactly once while
+  # avoiding duplicate static/object inclusion and interface leakage.
+  target_link_libraries(aoti_cuda_shims PRIVATE aoti_common_shims_slim_obj)
+else()
+  target_link_libraries(
+    aoti_cuda_shims
+    PRIVATE cuda_platform
+    PUBLIC -Wl,--whole-archive aoti_common_shims_slim -Wl,--no-whole-archive
+           cuda_tensor_maker CUDA::cudart ${CMAKE_DL_LIBS}
+  )
+endif()
 
-if(NOT MSVC)
+if(NOT _cuda_is_msvc_toolchain)
   executorch_target_link_options_shared_lib(aoti_cuda_shims)
 endif()
 
@@ -172,14 +217,12 @@ target_include_directories(
 )
 target_compile_options(
   aoti_cuda_backend
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/EHsc /GR>
-         $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-fexceptions -frtti -fPIC>
+  PUBLIC "$<$<COMPILE_LANGUAGE:CXX>:${_cuda_cxx_compile_options}>"
 )
 # Ensure symbols are exported properly
-target_link_options(
-  aoti_cuda_backend PUBLIC
-  $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wl,--export-dynamic>
-)
+if(_cuda_export_dynamic_option)
+  target_link_options(aoti_cuda_backend PUBLIC ${_cuda_export_dynamic_option})
+endif()
 
 # Link against shims library and other dependencies On Windows (MSVC), use
 # PRIVATE linkage for aoti_cuda_shims since the DLL is copied to the executable
@@ -190,8 +233,15 @@ target_link_libraries(
                            CUDA::cudart ${CMAKE_DL_LIBS}
 )
 
-if(MSVC)
-  target_link_libraries(aoti_cuda_backend PRIVATE aoti_cuda_shims)
+if(_cuda_is_msvc_toolchain)
+  # cuda_backend.cpp uses SlimTensor CUDA utilities (e.g. getCurrentCUDAStream)
+  # from aoti_common_shims_slim via headers; propagate the static lib so final
+  # MSVC links (e.g. parakeet_runner) can resolve those C++ symbols.
+  target_link_libraries(
+    aoti_cuda_backend
+    PRIVATE aoti_cuda_shims
+    PUBLIC aoti_common_shims_slim
+  )
 else()
   target_link_libraries(aoti_cuda_backend PUBLIC aoti_cuda_shims)
 endif()