Support building ONNX runtime with clang on Windows for Windows ML

cmake/CMakeLists.txt

@@ -366,6 +366,21 @@ if("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_
 endif()
 
 include(detect_onnxruntime_target_platform.cmake)
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+  if(NOT WIN32 OR NOT onnxruntime_target_platform STREQUAL "x64")
+    message(FATAL_ERROR "Building with clang-cl is supported only for Windows x64 targets "
+                        "(target platform: '${onnxruntime_target_platform}').")
+  endif()
+  # The Visual Studio ClangCL toolset defaults to lld-link. Link with MSVC link.exe instead, which binary analysis
+  # tooling such as BinSkim supports.
+  if(NOT DEFINED CMAKE_LINKER_TYPE)
+    if(CMAKE_VERSION VERSION_LESS 3.29)
+      message(FATAL_ERROR "Building with clang-cl requires CMake 3.29 or newer to select the MSVC linker.")
+    endif()
+    set(CMAKE_LINKER_TYPE MSVC)
+  endif()
+endif()
 include(onnxruntime_msvc_runtime.cmake)
 
 # OneCore builds link the Windows umbrella libraries (onecoreuap.lib, onecoreuap_apiset.lib) instead of CMake's default

cmake/onnxruntime_msvc_runtime.cmake

@@ -25,13 +25,50 @@ function(onnxruntime_msvc_spectre_enabled flags result_var)
   set(${result_var} ${spectre_enabled} PARENT_SCOPE)
 endfunction()
 
+# Returns the MSVC tools root (VC/Tools/MSVC/<version>) that provides the MSVC runtime libraries.
+function(onnxruntime_get_msvc_tools_root result_var)
+  if (NOT (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC"))
+    # CMAKE_C_COMPILER is <MSVC tools root>/bin/Host<arch>/<arch>/cl.exe.
+    cmake_path(SET msvc_tools_root NORMALIZE "${CMAKE_C_COMPILER}/../../../..")
+    set(${result_var} "${msvc_tools_root}" PARENT_SCOPE)
+    return()
+  endif()
+
+  # clang-cl lives under VC/Tools/Llvm, so the runtime cannot be found relative to it. The VS ClangCL toolset links
+  # the MSVC runtime of the MSVC tools version MSBuild selects: the generator toolset's version= field if given,
+  # otherwise the instance's default.
+  if (NOT CMAKE_GENERATOR_INSTANCE)
+    message(FATAL_ERROR "Linking the OneCore MSVC runtime with clang-cl requires a Visual Studio generator.")
+  endif()
+  set(msvc_tools_dir "${CMAKE_GENERATOR_INSTANCE}/VC/Tools/MSVC")
+  if (CMAKE_VS_PLATFORM_TOOLSET_VERSION)
+    file(GLOB msvc_tools_versions LIST_DIRECTORIES true RELATIVE "${msvc_tools_dir}"
+         "${msvc_tools_dir}/${CMAKE_VS_PLATFORM_TOOLSET_VERSION}*")
+    list(SORT msvc_tools_versions COMPARE NATURAL ORDER DESCENDING)
+    if (msvc_tools_versions)
+      list(GET msvc_tools_versions 0 msvc_tools_version)
+    endif()
+  else()
+    set(msvc_tools_version_file "${CMAKE_GENERATOR_INSTANCE}/VC/Auxiliary/Build/Microsoft.VCToolsVersion.default.txt")
+    if (EXISTS "${msvc_tools_version_file}")
+      file(STRINGS "${msvc_tools_version_file}" msvc_tools_version LIMIT_COUNT 1)
+      string(STRIP "${msvc_tools_version}" msvc_tools_version)
+    endif()
+  endif()
+  if (NOT msvc_tools_version OR NOT IS_DIRECTORY "${msvc_tools_dir}/${msvc_tools_version}")
+    message(FATAL_ERROR "Unable to locate the MSVC tools for clang-cl under ${msvc_tools_dir} "
+                        "(requested version: '${CMAKE_VS_PLATFORM_TOOLSET_VERSION}').")
+  endif()
+  set(${result_var} "${msvc_tools_dir}/${msvc_tools_version}" PARENT_SCOPE)
+endfunction()
+
 function(onnxruntime_configure_msvc_onecore_runtime)
   # GDK builds are skipped because gdk_toolchain.cmake configures the runtime, WINAPI_FAMILY and related flags.
   if (onnxruntime_BUILD_FOR_ONECORE AND NOT GDK_PLATFORM AND NOT CMAKE_CROSSCOMPILING)
     # OneCore builds must link the OneCore flavor of the MSVC runtime. Its lib directory is prepended to the
     # linker search path below so it takes precedence over the desktop runtime libraries found via LIB.
-    # CMAKE_C_COMPILER is <MSVC tools root>/bin/Host<arch>/<arch>/cl.exe.
-    cmake_path(SET msvc_lib_root NORMALIZE "${CMAKE_C_COMPILER}/../../../../lib")
+    onnxruntime_get_msvc_tools_root(msvc_tools_root)
+    set(msvc_lib_root "${msvc_tools_root}/lib")
     set(msvc_onecore_platform "${onnxruntime_target_platform}")
     if (msvc_onecore_platform STREQUAL "ARM64EC")
       # MSVC ships no ARM64EC runtime directory; ARM64EC uses the ARM64 hybrid CRT libraries.
@@ -41,7 +78,9 @@ function(onnxruntime_configure_msvc_onecore_runtime)
 
     onnxruntime_msvc_spectre_enabled("${CMAKE_C_FLAGS}" msvc_c_spectre_enabled)
     onnxruntime_msvc_spectre_enabled("${CMAKE_CXX_FLAGS}" msvc_cxx_spectre_enabled)
-    if (msvc_c_spectre_enabled OR msvc_cxx_spectre_enabled)
+    # onnxruntime_USE_MSVC_SPECTRE_RUNTIME requests the Spectre-mitigated runtime for compilers such as clang-cl
+    # that do not implement /Qspectre.
+    if (msvc_c_spectre_enabled OR msvc_cxx_spectre_enabled OR onnxruntime_USE_MSVC_SPECTRE_RUNTIME)
       set(msvc_onecore_lib_dir "${msvc_lib_root}/spectre/onecore/${msvc_onecore_platform}")
       # Only the release libraries are required: debug CRT libraries are not Spectre-mitigated by design, and
       # BinSkim BA2024 skips modules that link them.

cmake/onnxruntime_unittests.cmake

@@ -2231,7 +2231,7 @@ if (NOT onnxruntime_ENABLE_TRAINING_TORCH_INTEROP)
     file(GLOB onnxruntime_perf_test_src CONFIGURE_DEPENDS
       ${onnxruntime_perf_test_src_patterns}
       )
-    onnxruntime_add_executable(onnxruntime_perf_test ${onnxruntime_perf_test_src} ${ONNXRUNTIME_ROOT}/core/platform/path_lib.cc)
+    onnxruntime_add_executable(onnxruntime_perf_test ${onnxruntime_perf_test_src})
 
     # ABSL_FLAGS_STRIP_NAMES is set to 1 by default to disable flag registration when building for Android, iPhone, and "embedded devices".
     # See the issue: https://github.com/abseil/abseil-cpp/issues/1875

include/onnxruntime/core/common/float16.h

@@ -79,8 +79,11 @@ struct MLFloat16 : onnxruntime_float16::Float16Impl<MLFloat16> {
 
   operator float() const noexcept { return ToFloat(); }
 
-  using Base::operator==;
-  using Base::operator!=;
+  // Compare on the derived type (as BFloat16 does). With the inherited Float16Impl-typed operator==, C++20's
+  // reversed candidates make MLFloat16 == MLFloat16 ambiguous, which clang reports as
+  // -Wambiguous-reversed-operator. operator< is not rewritten in C++20, so the inherited one is unambiguous.
+  bool operator==(const MLFloat16& rhs) const noexcept { return Base::operator==(rhs); }
+  bool operator!=(const MLFloat16& rhs) const noexcept { return Base::operator!=(rhs); }
   using Base::operator<;
 };
 

onnxruntime/contrib_ops/cpu/quantization/gguf_vec_dot_cpu.h

@@ -121,7 +121,8 @@ inline void QuantizeBlockQ8Scalar(const float* x, GgufQ8Block* blk) noexcept {
   blk->bsum = bsum;
 }
 
-#if (defined(__x86_64__) || defined(_M_X64)) && (defined(__GNUC__) || defined(__clang__))
+// clang-cl is excluded: __builtin_cpu_supports needs compiler-rt's __cpu_model, which clang-cl does not link.
+#if (defined(__x86_64__) || defined(_M_X64)) && (defined(__GNUC__) || defined(__clang__)) && !defined(_MSC_VER)
 #define ORT_GGUF_CPU_HAS_AVX2_TARGET 1
 #else
 #define ORT_GGUF_CPU_HAS_AVX2_TARGET 0

onnxruntime/core/common/spin_pause.cc

@@ -26,6 +26,26 @@
 namespace onnxruntime {
 namespace concurrency {
 
+// TPAUSE is compiled in on x64 Windows and on other x64 targets built with WAITPKG; it is still used only when
+// CPUIDInfo::HasTPAUSE() reports support at runtime.
+#if (defined(_M_AMD64) || defined(__x86_64__)) && \
+    !defined(_M_ARM64EC) &&                       \
+    !defined(__ANDROID__) &&                      \
+    !defined(__APPLE__) &&                        \
+    (defined(_WIN32) || defined(__WAITPKG__))
+#define ORT_USE_TPAUSE
+
+// clang (including clang-cl) refuses to emit _tpause from a function not compiled with the 'waitpkg' target
+// feature, so isolate it in a non-inlined helper carrying that feature. MSVC does not feature-gate intrinsics.
+#if defined(__clang__)
+__attribute__((target("waitpkg"), noinline))
+#endif
+static void
+OrtTPause(uint64_t deadline) {
+  _tpause(0x0, deadline);
+}
+#endif
+
 // Intrinsic to use in spin-loops
 void SpinPause() {
 #if (defined(_M_AMD64) || defined(__x86_64__)) && \
@@ -35,9 +55,9 @@ void SpinPause() {
 
   static const bool has_tpause = CPUIDInfo::GetCPUIDInfo().HasTPAUSE();
   if (has_tpause) {
-#if (defined(_WIN32) && !defined(__clang__)) || defined(__WAITPKG__)
+#if defined(ORT_USE_TPAUSE)
     static constexpr uint64_t tpause_spin_delay_cycles = 1000;
-    _tpause(0x0, __rdtsc() + tpause_spin_delay_cycles);
+    OrtTPause(__rdtsc() + tpause_spin_delay_cycles);
 #else
     _mm_pause();
 #endif

onnxruntime/core/providers/dml/DmlExecutionProvider/src/External/DirectMLHelpers/AbstractOperatorDesc.h

@@ -3,69 +3,111 @@
 
 #pragma once
 
+#include <utility>
+#include <vector>
+
 class OperatorField;
 
 struct AbstractOperatorDesc
 {
     const DML_OPERATOR_SCHEMA* schema = nullptr;
     std::vector<OperatorField> fields;
 
-    AbstractOperatorDesc() = default;
-    AbstractOperatorDesc(const DML_OPERATOR_SCHEMA* schema, std::vector<OperatorField>&& fields)
-        : schema(schema)
-        , fields(std::move(fields))
-    {}
+    // NOTE (clang-cl / two-phase name lookup):
+    // OperatorField and AbstractOperatorDesc are mutually recursive - OperatorField holds a
+    // std::optional<AbstractOperatorDesc> (see GeneratedSchemaTypes.h) - so OperatorField is
+    // necessarily an incomplete type at this point. Any member function that instantiates
+    // std::vector<OperatorField> operations requiring a complete element type - the special
+    // member functions (which may need to destroy the vector) and the GetTensors iteration -
+    // must therefore be declared here and defined out of line below, after OperatorField has
+    // been completed. MSVC's cl.exe defers these instantiations and tolerates inline
+    // definitions, but conforming two-phase compilers such as clang-cl instantiate them at
+    // definition time and fail with "incomplete type 'OperatorField'".
+    AbstractOperatorDesc();
+    AbstractOperatorDesc(const DML_OPERATOR_SCHEMA* schema, std::vector<OperatorField>&& fields);
+    AbstractOperatorDesc(const AbstractOperatorDesc&);
+    AbstractOperatorDesc(AbstractOperatorDesc&&) noexcept;
+    AbstractOperatorDesc& operator=(const AbstractOperatorDesc&);
+    AbstractOperatorDesc& operator=(AbstractOperatorDesc&&) noexcept;
+    ~AbstractOperatorDesc();
 
-    std::vector<DmlBufferTensorDesc*> GetInputTensors()
-    {
-        return GetTensors<DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_INPUT_TENSOR>();
-    }
+    std::vector<DmlBufferTensorDesc*> GetInputTensors();
+    std::vector<const DmlBufferTensorDesc*> GetInputTensors() const;
+    std::vector<DmlBufferTensorDesc*> GetOutputTensors();
+    std::vector<const DmlBufferTensorDesc*> GetOutputTensors() const;
 
-    std::vector<const DmlBufferTensorDesc*> GetInputTensors() const
-    {
-        return GetTensors<const DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_INPUT_TENSOR>();
-    }
+private:
+    template <typename TensorType, DML_SCHEMA_FIELD_KIND Kind>
+    std::vector<TensorType*> GetTensors() const;
+};
 
-    std::vector<DmlBufferTensorDesc*> GetOutputTensors()
-    {
-        return GetTensors<DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR>();
-    }
+// Complete OperatorField before defining the members that require it. GeneratedSchemaTypes.h is
+// guarded by #pragma once, so its subsequent include from precomp.h is a no-op and the
+// established include order is preserved.
+#include "GeneratedSchemaTypes.h"
 
-    std::vector<const DmlBufferTensorDesc*> GetOutputTensors() const
-    {
-        return GetTensors<const DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR>();
-    }
+inline AbstractOperatorDesc::AbstractOperatorDesc() = default;
 
-private:
-    template <typename TensorType, DML_SCHEMA_FIELD_KIND Kind>
-    std::vector<TensorType*> GetTensors() const
+inline AbstractOperatorDesc::AbstractOperatorDesc(const DML_OPERATOR_SCHEMA* schema, std::vector<OperatorField>&& fields)
+    : schema(schema)
+    , fields(std::move(fields))
+{
+}
+
+inline AbstractOperatorDesc::AbstractOperatorDesc(const AbstractOperatorDesc&) = default;
+inline AbstractOperatorDesc::AbstractOperatorDesc(AbstractOperatorDesc&&) noexcept = default;
+inline AbstractOperatorDesc& AbstractOperatorDesc::operator=(const AbstractOperatorDesc&) = default;
+inline AbstractOperatorDesc& AbstractOperatorDesc::operator=(AbstractOperatorDesc&&) noexcept = default;
+inline AbstractOperatorDesc::~AbstractOperatorDesc() = default;
+
+inline std::vector<DmlBufferTensorDesc*> AbstractOperatorDesc::GetInputTensors()
+{
+    return GetTensors<DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_INPUT_TENSOR>();
+}
+
+inline std::vector<const DmlBufferTensorDesc*> AbstractOperatorDesc::GetInputTensors() const
+{
+    return GetTensors<const DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_INPUT_TENSOR>();
+}
+
+inline std::vector<DmlBufferTensorDesc*> AbstractOperatorDesc::GetOutputTensors()
+{
+    return GetTensors<DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR>();
+}
+
+inline std::vector<const DmlBufferTensorDesc*> AbstractOperatorDesc::GetOutputTensors() const
+{
+    return GetTensors<const DmlBufferTensorDesc, DML_SCHEMA_FIELD_KIND_OUTPUT_TENSOR>();
+}
+
+template <typename TensorType, DML_SCHEMA_FIELD_KIND Kind>
+std::vector<TensorType*> AbstractOperatorDesc::GetTensors() const
+{
+    std::vector<TensorType*> tensors;
+    for (auto& field : fields)
     {
-        std::vector<TensorType*> tensors;
-        for (auto& field : fields)
+        const DML_SCHEMA_FIELD* fieldSchema = field.GetSchema();
+        if (fieldSchema->Kind != Kind)
         {
-            const DML_SCHEMA_FIELD* fieldSchema = field.GetSchema();
-            if (fieldSchema->Kind != Kind)
-            {
-                continue;
-            }
+            continue;
+        }
 
-            if (fieldSchema->Type == DML_SCHEMA_FIELD_TYPE_TENSOR_DESC)
-            {
-                auto& tensor = field.AsTensorDesc();
-                tensors.push_back(tensor ? const_cast<TensorType*>(&*tensor) : nullptr);
-            }
-            else if (fieldSchema->Type == DML_SCHEMA_FIELD_TYPE_TENSOR_DESC_ARRAY)
+        if (fieldSchema->Type == DML_SCHEMA_FIELD_TYPE_TENSOR_DESC)
+        {
+            auto& tensor = field.AsTensorDesc();
+            tensors.push_back(tensor ? const_cast<TensorType*>(&*tensor) : nullptr);
+        }
+        else if (fieldSchema->Type == DML_SCHEMA_FIELD_TYPE_TENSOR_DESC_ARRAY)
+        {
+            auto& tensorArray = field.AsTensorDescArray();
+            if (tensorArray)
             {
-                auto& tensorArray = field.AsTensorDescArray();
-                if (tensorArray)
+                for (auto& tensor : *tensorArray)
                 {
-                    for (auto& tensor : *tensorArray)
-                    {
-                        tensors.push_back(const_cast<TensorType*>(&tensor));
-                    }
+                    tensors.push_back(const_cast<TensorType*>(&tensor));
                 }
             }
         }
-        return tensors;
     }
-};
+    return tensors;
+}

onnxruntime/core/providers/dml/DmlExecutionProvider/src/MLOperatorAuthorImpl.cpp

@@ -3148,7 +3148,7 @@ namespace Windows::AI::MachineLearning::Adapter
 
 #define CASE_PROTO(X, Y, Z)                                                                        \
   case ONNX_NAMESPACE::TensorProto_DataType::TensorProto_DataType_##X: {                           \
-    size_t elementCount = initializer.##Z();                                                       \
+    size_t elementCount = initializer.Z();                                                         \
     tensorByteSize = elementCount * sizeof(Y);                                                     \
     unpackedTensor.reset(new std::byte[tensorByteSize]);                                           \
     ORT_THROW_HR_IF(E_FAIL, !onnxruntime::utils::UnpackTensor(                                     \

onnxruntime/core/providers/dml/DmlExecutionProvider/src/Operators/DmlDFT.h

@@ -920,7 +920,7 @@ class GpuDFTOperator : public WRL::Base<IMLOperatorKernel>
         return dims;
     }
 
-    template <typename TConstants, uint32_t TSize>
+    template <typename TConstants, size_t TSize>
     void Dispatch(
         std::array<ID3D12Resource*, TSize>& resources,
         TConstants& constants,

onnxruntime/core/providers/dml/DmlExecutionProvider/src/Operators/DmlGridSample.h

@@ -645,7 +645,7 @@ class DmlGridSampleOperator : public WRL::Base<IMLOperatorKernel>
         return dims;
     }
 
-    template <typename TConstants, uint32_t TSize>
+    template <typename TConstants, size_t TSize>
     void Dispatch(
         std::array<ID3D12Resource*, TSize>& resources,
         TConstants& constants,

onnxruntime/test/providers/cpu/math/element_wise_ops_test.cc

@@ -4093,13 +4093,7 @@ TEST(MathOpTest, Mean_8) {
   test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});  // TensorRT: Input batch size is inconsistent
 }
 
-#ifdef _LIBCPP_VERSION
-#define MATH_NO_EXCEPT
-#else
-#define MATH_NO_EXCEPT noexcept
-#endif
-
-template <float (&op)(float value) MATH_NO_EXCEPT>
+template <float (&op)(float value)>
 void TrigFloatTest(OpTester& test, std::initializer_list<float> input, float abs_error = -1.0f) {
   std::vector<int64_t> dims{static_cast<int64_t>(input.size())};
 
@@ -4117,7 +4111,7 @@ void TrigFloatTest(OpTester& test, std::initializer_list<float> input, float abs
   test.Run();
 }
 
-template <double (&op)(double value) MATH_NO_EXCEPT>
+template <double (&op)(double value)>
 void TrigDoubleTest(OpTester& test, std::initializer_list<double> input,
                     const std::unordered_set<std::string> excluded_provider_types = {}) {
   std::vector<int64_t> dims{static_cast<int64_t>(input.size())};
@@ -4131,7 +4125,7 @@ void TrigDoubleTest(OpTester& test, std::initializer_list<double> input,
   test.Run(OpTester::ExpectResult::kExpectSuccess, "", excluded_provider_types);
 }
 
-template <float (&op)(float value) MATH_NO_EXCEPT>
+template <float (&op)(float value)>
 void TrigFloat16Test(OpTester& test, std::initializer_list<float> input) {
   std::vector<int64_t> dims{static_cast<int64_t>(input.size())};