Merge branch 'sk/hlsl_6' of https://github.com/soufianekhiat/Halide into sk/hlsl_6

soufianekhiat · soufianekhiat · commit 263effe9257b · 2026-03-27T17:50:51.000+01:00
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
@@ -7,6 +7,7 @@ on:
       - '**.c'
       - '**.cpp'
       - 'run-clang-tidy.sh'
+      - 'tools/clang-tidy-filter.sh'
       - '**.clang-tidy'
       - '.github/workflows/clang-tidy.yml'
 
diff --git a/run-clang-tidy.sh b/run-clang-tidy.sh
@@ -128,32 +128,18 @@ jq -s 'add' "${CLANG_TIDY_BUILD_DIR}/compile_commands.json" \
     >"${CLANG_TIDY_BUILD_DIR}/compile_commands_merged.json"
 mv "${CLANG_TIDY_BUILD_DIR}/compile_commands_merged.json" "${CLANG_TIDY_BUILD_DIR}/compile_commands.json"
 
-# Wrapper filters noisy "N warnings generated." from each clang-tidy invocation.
-CLANG_TIDY_FILTER="${CLANG_TIDY_BUILD_DIR}/clang-tidy-filter.sh"
-cat >"${CLANG_TIDY_FILTER}" <<WRAPPER
-#!/usr/bin/env bash
-"${CLANG_TIDY_LLVM_INSTALL_DIR}/bin/clang-tidy" "\$@" 2>&1 | grep -v '^[[:digit:]]\+ warnings\? generated\.\$'
-exit "\${PIPESTATUS[0]}"
-WRAPPER
-chmod +x "${CLANG_TIDY_FILTER}"
+echo "Running clang-tidy..."
 
-echo Running clang-tidy...
 export PYTHONUNBUFFERED=1
+export CLANG_TIDY_REAL_BINARY="${CLANG_TIDY_LLVM_INSTALL_DIR}/bin/clang-tidy"
+export CLANG_TIDY_ROOT_DIR="${ROOT_DIR}"
 "${CLANG_TIDY_LLVM_INSTALL_DIR}/bin/run-clang-tidy" \
     ${FIX} \
     -j "${J}" \
     -quiet \
     -p "${CLANG_TIDY_BUILD_DIR}" \
-    -clang-tidy-binary "${CLANG_TIDY_FILTER}" \
+    -clang-tidy-binary "${ROOT_DIR}/tools/clang-tidy-filter.sh" \
     -clang-apply-replacements-binary "${CLANG_TIDY_LLVM_INSTALL_DIR}/bin/clang-apply-replacements" \
     "$@"
 
-CLANG_TIDY_EXIT_CODE=$?
-
-if [ "$CLANG_TIDY_EXIT_CODE" -eq 0 ]; then
-    echo "Success!"
-else
-    echo "clang-tidy failed with exit code $CLANG_TIDY_EXIT_CODE"
-fi
-
-exit "$CLANG_TIDY_EXIT_CODE"
+echo "Success!"
diff --git a/src/CodeGen_D3D12Compute_Dev.cpp b/src/CodeGen_D3D12Compute_Dev.cpp
@@ -148,6 +148,7 @@ class CodeGen_D3D12Compute_Dev : public CodeGen_GPU_Dev {
         void visit(const FloatImm *op) override;
 
         Scope<> groupshared_allocations;
+        bool emit_precise = false;
     };
 
     std::ostringstream src_stream;
@@ -527,6 +528,12 @@ void CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::visit(const Call *op) {
         // directly.
         Expr equiv = Call::make(op->type, "pow", op->args, Call::PureExtern);
         equiv.accept(this);
+    } else if (op->is_strict_float_intrinsic()) {
+        ScopedValue old_emit_precise(emit_precise, true);
+        Expr equiv = op->is_intrinsic(Call::strict_fma) ?
+                         Call::make(op->type, "fma", op->args, Call::PureExtern) :
+                         unstrictify_float(op);
+        equiv.accept(this);
     } else if (op->is_intrinsic(Call::round)) {
         // HLSL's round intrinsic has the correct semantics for our rounding.
         Expr equiv = Call::make(op->type, "round", op->args, Call::PureExtern);
@@ -942,8 +949,12 @@ void CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::visit(const Store *op) {
             // Detect min/max/bitwise patterns by examining the expression structure.
             // Each has the form op(load, rhs) where rhs is independent of the buffer.
             auto detect_rhs = [&](const Expr &a, const Expr &b) -> Expr {
-                if (equal(a, equiv_load) && !expr_uses_var(b, op->name)) { return b; }
-                if (equal(b, equiv_load) && !expr_uses_var(a, op->name)) { return a; }
+                if (equal(a, equiv_load) && !expr_uses_var(b, op->name)) {
+                    return b;
+                }
+                if (equal(b, equiv_load) && !expr_uses_var(a, op->name)) {
+                    return a;
+                }
                 return Expr();
             };
             Expr rhs;
@@ -1108,6 +1119,14 @@ void CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::visit(const Store *op) {
 }
 
 void CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::visit(const Select *op) {
+    if (op->type.is_vector()) {
+        // A vector of bool was recursively introduced while
+        // performing codegen. Eliminate it.
+        Expr equiv = eliminate_bool_vectors(op);
+        equiv.accept(this);
+        return;
+    }
+
     ostringstream rhs;
     string true_val = print_expr(op->true_value);
     string false_val = print_expr(op->false_value);
@@ -1177,7 +1196,25 @@ void CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::visit(const Free *op) {
 
 string CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::print_assignment(Type type, const string &rhs) {
     string rhs_modified = print_reinforced_cast(type, rhs);
-    return CodeGen_GPU_C::print_assignment(type, rhs_modified);
+    const char *precise_flag = (type.is_float() && emit_precise) ? "precise " : "";
+    const string cache_key = precise_flag + rhs_modified;
+
+    auto cached = cache.find(cache_key);
+    if (cached == cache.end()) {
+        id = unique_name('_');
+        const char *const_flag = output_kind == CPlusPlusImplementation ? " const " : "";
+        if (type.is_handle()) {
+            // Don't print void *, which might lose useful type information. just use auto.
+            stream << get_indent() << "auto *";
+        } else {
+            stream << get_indent() << precise_flag << print_type(type, AppendSpace);
+        }
+        stream << const_flag << id << " = " << rhs_modified << ";\n";
+        cache[cache_key] = id;
+    } else {
+        id = cached->second;
+    }
+    return id;
 }
 
 string CodeGen_D3D12Compute_Dev::CodeGen_D3D12Compute_C::print_vanilla_cast(Type type, const string &value_expr) {
@@ -1826,13 +1863,12 @@ void CodeGen_D3D12Compute_Dev::init_module() {
 #endif
         // DXC (SM 6.x) rejects FXC-specific float literals 1.#IND / 1.#INF.
         // Use asfloat() with IEEE 754 bit patterns instead.
-        << (sm >= 60
-                ? "float nan_f32()     { return asfloat(0x7fc00000u); } \n"
-                  "float neg_inf_f32() { return asfloat(0xff800000u); } \n"
-                  "float inf_f32()     { return asfloat(0x7f800000u); } \n"
-                : "float nan_f32()     { return  1.#IND; } \n"
-                  "float neg_inf_f32() { return -1.#INF; } \n"
-                  "float inf_f32()     { return +1.#INF; } \n")
+        << (sm >= 60 ? "float nan_f32()     { return asfloat(0x7fc00000u); } \n"
+                       "float neg_inf_f32() { return asfloat(0xff800000u); } \n"
+                       "float inf_f32()     { return asfloat(0x7f800000u); } \n" :
+                       "float nan_f32()     { return  1.#IND; } \n"
+                       "float neg_inf_f32() { return -1.#INF; } \n"
+                       "float inf_f32()     { return +1.#INF; } \n")
         << "#define float_from_bits asfloat \n"
         // pow() in HLSL has the same semantics as C if
         // x > 0.  Otherwise, we need to emulate C
diff --git a/src/runtime/d3d12compute.cpp b/src/runtime/d3d12compute.cpp
@@ -76,13 +76,13 @@
 
 WEAK void d3d12_debug_dump();
 
-#define d3d12_panic(...)                                                         \
-    do {                                                                         \
-        /* Print the fatal message via halide_print (non-aborting) FIRST so it  \
-           is always visible, even though d3d12_debug_dump() aborts below. */   \
+#define d3d12_panic(...)                                                       \
+    do {                                                                       \
+        /* Print the fatal message via halide_print (non-aborting) FIRST so it \
+           is always visible, even though d3d12_debug_dump() aborts below. */  \
         BasicPrinter<4096>(nullptr) << "D3D12 FATAL: " << __VA_ARGS__ << "\n"  \
-                                    << "vvvvv D3D12 Begin Debug Dump vvvvv\n";  \
-        d3d12_debug_dump(); /* aborts via halide_error inside */                 \
+                                    << "vvvvv D3D12 Begin Debug Dump vvvvv\n"; \
+        d3d12_debug_dump(); /* aborts via halide_error inside */               \
     } while (0)
 
 // v trace and logging utilities for debugging v
@@ -2032,7 +2032,9 @@ WEAK bool D3D12LoadDXC(void *uc) {
         // Trim to the directory portion (last backslash).
         char *last_sep = path;
         for (char *p = path; *p; p++) {
-            if (*p == '\\' || *p == '/') last_sep = p;
+            if (*p == '\\' || *p == '/') {
+                last_sep = p;
+            }
         }
         char *dst = last_sep + 1;
         for (const char *src = "dxcompiler.dll"; *src;) {
diff --git a/src/runtime/mini_dxc.h b/src/runtime/mini_dxc.h
@@ -289,13 +289,13 @@ MIDL_INTERFACE("E5204DC7-D18C-4C3C-BDFB-851673980FE7")
 IDxcLibrary : public IUnknown {
 public:
     virtual HRESULT STDMETHODCALLTYPE SetMalloc(void *pMalloc) = 0;
-    virtual HRESULT STDMETHODCALLTYPE CreateBlobFromBlob(IDxcBlob *pBlob, UINT32 offset, UINT32 length,
-                                                         _COM_Outptr_ IDxcBlob **ppResult) = 0;
-    virtual HRESULT STDMETHODCALLTYPE CreateBlobFromFile(LPCWSTR pFileName, UINT32 *pCodePage,
-                                                         _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+    virtual HRESULT STDMETHODCALLTYPE CreateBlobFromBlob(IDxcBlob * pBlob, UINT32 offset, UINT32 length,
+                                                         _COM_Outptr_ IDxcBlob * *ppResult) = 0;
+    virtual HRESULT STDMETHODCALLTYPE CreateBlobFromFile(LPCWSTR pFileName, UINT32 * pCodePage,
+                                                         _COM_Outptr_ IDxcBlobEncoding * *pBlobEncoding) = 0;
     virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingFromPinned(
         LPCVOID pText, UINT32 size, UINT32 codePage,
-        _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+        _COM_Outptr_ IDxcBlobEncoding * *pBlobEncoding) = 0;
 };
 
 #endif /* C++ only — C-style vtable omitted (not used) */
@@ -311,11 +311,11 @@ MIDL_INTERFACE("8C210BF3-011F-4422-8D70-6F9ACB374E6F")
 IDxcCompiler : public IUnknown {
 public:
     virtual HRESULT STDMETHODCALLTYPE Compile(
-        IDxcBlob *pSource,
+        IDxcBlob * pSource,
         _In_opt_ LPCWSTR pSourceName,
         LPCWSTR pEntryPoint,
         LPCWSTR pTargetProfile,
-        _In_opt_count_(argCount) LPCWSTR *pArguments,
+        _In_opt_count_(argCount) LPCWSTR * pArguments,
         UINT32 argCount,
         _In_opt_ const void *pDefines,
         UINT32 defineCount,
diff --git a/tools/clang-tidy-filter.sh b/tools/clang-tidy-filter.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+
+set -o pipefail
+
+if [[ -z ${CLANG_TIDY_REAL_BINARY:-} ]]; then
+    echo "CLANG_TIDY_REAL_BINARY must be set" 1>&2
+    exit 1
+fi
+
+if [[ -z ${CLANG_TIDY_ROOT_DIR:-} ]]; then
+    echo "CLANG_TIDY_ROOT_DIR must be set" 1>&2
+    exit 1
+fi
+
+escape_github_annotation_value() {
+    local value="$1"
+    value="${value//'%'/%25}"
+    value="${value//$'\r'/%0D}"
+    value="${value//$'\n'/%0A}"
+    value="${value//','/%2C}"
+    value="${value//':'/%3A}"
+    printf '%s' "${value}"
+}
+
+OUTPUT_FILE=$(mktemp)
+"${CLANG_TIDY_REAL_BINARY}" "$@" >"${OUTPUT_FILE}" 2>&1
+CLANG_TIDY_STATUS=$?
+
+grep -v '^[[:digit:]]\+ warnings\? generated\.$' "${OUTPUT_FILE}"
+
+if [[ ${GITHUB_ACTIONS} == "true" ]]; then
+    while IFS= read -r line; do
+        if [[ ${line} =~ ^(.+):([0-9]+):([0-9]+):[[:space:]](warning|error|note):[[:space:]](.*)\ \[([^][]+)\]$ ]]; then
+            file="${BASH_REMATCH[1]}"
+            line_no="${BASH_REMATCH[2]}"
+            col_no="${BASH_REMATCH[3]}"
+            severity="${BASH_REMATCH[4]}"
+            message="${BASH_REMATCH[5]}"
+            check_name="${BASH_REMATCH[6]}"
+        elif [[ ${line} =~ ^(.+):([0-9]+):([0-9]+):[[:space:]](warning|error|note):[[:space:]](.*)$ ]]; then
+            file="${BASH_REMATCH[1]}"
+            line_no="${BASH_REMATCH[2]}"
+            col_no="${BASH_REMATCH[3]}"
+            severity="${BASH_REMATCH[4]}"
+            message="${BASH_REMATCH[5]}"
+            check_name="clang-tidy"
+        else
+            continue
+        fi
+
+        if [[ ${file} == "${CLANG_TIDY_ROOT_DIR}/"* ]]; then
+            file="${file#"${CLANG_TIDY_ROOT_DIR}/"}"
+        fi
+
+        file="$(escape_github_annotation_value "${file}")"
+        title="$(escape_github_annotation_value "${check_name}")"
+        message="$(escape_github_annotation_value "${message}")"
+
+        echo "::${severity} file=${file},line=${line_no},col=${col_no},title=${title}::${message}"
+    done <"${OUTPUT_FILE}"
+fi
+
+rm -f "${OUTPUT_FILE}"
+exit "${CLANG_TIDY_STATUS}"
