tests: update ARM/SVE2 coverage and LLVM-version-specific skips

alexreinking · alexreinking · commit 04d9dd12159b · 2026-03-05T05:33:51.000-05:00
diff --git a/cmake/HalideTestHelpers.cmake b/cmake/HalideTestHelpers.cmake
@@ -69,9 +69,12 @@ function(add_halide_test TARGET)
     #
     # target_link_libraries("${TARGET}" PRIVATE Halide::TerminateHandler)
 
+    # Resolve the "cmake" meta-target
+    string(REGEX REPLACE "^cmake" "${Halide_CMAKE_TARGET}" _resolved_target "${Halide_TARGET}")
+
     set_tests_properties(${TARGET} PROPERTIES
                          LABELS "${args_GROUPS}"
-                         ENVIRONMENT "HL_TARGET=${Halide_TARGET};HL_JIT_TARGET=${Halide_TARGET}"
+                         ENVIRONMENT "HL_TARGET=${_resolved_target};HL_JIT_TARGET=${_resolved_target}"
                          SKIP_REGULAR_EXPRESSION "\\[SKIP\\]"
                          WILL_FAIL ${args_EXPECT_FAILURE})
 
diff --git a/test/autoschedulers/mullapudi2016/max_filter.cpp b/test/autoschedulers/mullapudi2016/max_filter.cpp
@@ -128,6 +128,16 @@ int main(int argc, char **argv) {
         return 0;
     }
 
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     if (argc != 2) {
         fprintf(stderr, "Usage: %s <autoscheduler-lib>\n", argv[0]);
         return 1;
diff --git a/test/correctness/align_bounds.cpp b/test/correctness/align_bounds.cpp
@@ -23,6 +23,16 @@ int my_trace(JITUserContext *user_context, const halide_trace_event_t *e) {
 }
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     // Force the bounds of an intermediate pipeline stage to be even to remove a select
     {
         Func f, g, h;
diff --git a/test/correctness/bound_small_allocations.cpp b/test/correctness/bound_small_allocations.cpp
@@ -10,6 +10,16 @@ Expr calc(Expr a) {
 }
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     Var x, y;
     Func f, g, h;
 
diff --git a/test/correctness/fit_function.cpp b/test/correctness/fit_function.cpp
@@ -7,6 +7,16 @@
 using namespace Halide;
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     // Fit an odd polynomial to sin from 0 to pi/2 using Halide's derivative support
     ImageParam coeffs(Float(64), 1);
     Param<double> learning_rate;
diff --git a/test/correctness/interleave_rgb.cpp b/test/correctness/interleave_rgb.cpp
@@ -103,6 +103,16 @@ bool test_deinterleave(int x_stride) {
 }
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     for (int x_stride : {3, 4}) {
         if (!test_interleave<uint8_t>(x_stride)) return 1;
         if (!test_interleave<uint16_t>(x_stride)) return 1;
diff --git a/test/correctness/logical.cpp b/test/correctness/logical.cpp
@@ -12,6 +12,15 @@ Expr u16(Expr a) {
 }
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
 
     Buffer<uint8_t> input(128, 64);
 
diff --git a/test/correctness/mul_div_mod.cpp b/test/correctness/mul_div_mod.cpp
@@ -541,6 +541,18 @@ void add_test_div_mod(int vector_width, ScheduleVariant scheduling, Target targe
 int main(int argc, char **argv) {
     Target target = get_jit_target_from_environment();
 
+    // LLVM's performSignExtendInRegCombine in the AArch64 backend asserts
+    // when it encounters SIGN_EXTEND_INREG from i1 on SVE vectors. Halide's
+    // division lowering produces select(cond, -1, 0) which LLVM canonicalizes
+    // to sext i1, triggering the assertion. Fixed on LLVM main by:
+    // https://github.com/llvm/llvm-project/commit/ffb7a9f0ec80 (PR #177976)
+    if (target.has_feature(Target::SVE2) &&
+        Internal::get_llvm_version() < 230) {
+        printf("[SKIP] LLVM %d has a known SVE bug in performSignExtendInRegCombine (PR #177976).\n",
+               Internal::get_llvm_version());
+        return 0;
+    }
+
     ScheduleVariant scheduling = CPU;
     if (target.has_gpu_feature()) {
         scheduling = TiledGPU;
diff --git a/test/correctness/predicated_store_load.cpp b/test/correctness/predicated_store_load.cpp
@@ -487,6 +487,16 @@ int predicated_atomic_store_test(const Target &t) {
 int main(int argc, char **argv) {
     Target t = get_jit_target_from_environment();
 
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        t.has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     printf("Running vectorized dense load test\n");
     if (predicated_tail_test(t) != 0) {
         return 1;
diff --git a/test/correctness/stage_strided_loads.cpp b/test/correctness/stage_strided_loads.cpp
@@ -56,6 +56,16 @@ class CheckForStridedLoads : public IRMutator {
 } checker;
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     ImageParam buf(Float(32), 1, "buf");
 
     {
diff --git a/test/correctness/truncated_pyramid.cpp b/test/correctness/truncated_pyramid.cpp
@@ -6,6 +6,16 @@ using std::pair;
 using std::vector;
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     Func input;
     Var x, y;
     input(x, y) = random_float();
diff --git a/test/correctness/vector_reductions.cpp b/test/correctness/vector_reductions.cpp
@@ -160,6 +160,16 @@ void add_tasks(const Target &target, std::vector<Task> &tasks) {
 int main(int argc, char **argv) {
     Target target = get_jit_target_from_environment();
 
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        target.has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     std::vector<Task> tasks;
     add_tasks(target, tasks);
 
diff --git a/test/correctness/vectorize_nested.cpp b/test/correctness/vectorize_nested.cpp
@@ -277,6 +277,16 @@ int vectorize_inner_of_scalarization() {
 }
 
 int main(int argc, char **argv) {
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        get_jit_target_from_environment().has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     if (vectorize_2d_round_up()) {
         printf("vectorize_2d_round_up failed\n");
         return 1;
diff --git a/test/performance/const_division.cpp b/test/performance/const_division.cpp
@@ -125,6 +125,16 @@ int main(int argc, char **argv) {
         return 0;
     }
 
+    // LLVM 21 calls getFixedValue() on scalable TypeSize objects in the
+    // AArch64 backend, triggering an assertion. Fixed in LLVM 22 by:
+    // https://github.com/llvm/llvm-project/commit/d1500d12be60 (PR #169764)
+    if (Internal::get_llvm_version() >= 210 &&
+        Internal::get_llvm_version() < 220 &&
+        target.has_feature(Target::SVE2)) {
+        printf("[SKIP] LLVM 21 has known getFixedValue() assertions on SVE scalable types.\n");
+        return 0;
+    }
+
     int seed = argc > 1 ? atoi(argv[1]) : time(nullptr);
     rng.seed(seed);
     std::cout << "const_division test seed: " << seed << std::endl;
diff --git a/test/performance/fast_inverse.cpp b/test/performance/fast_inverse.cpp
@@ -20,6 +20,17 @@ int main(int argc, char **argv) {
         return 0;
     }
 
+    // SVE2-capable cores (e.g. Neoverse V1/V2, Ampere Altra) have fast
+    // enough fdiv that the frecpe+frecps approximation used by fast_inverse
+    // is not reliably faster. Additionally, Halide generates wide scalable
+    // vectors (e.g. <vscale x 32 x float>) that LLVM (at time of writing)
+    // cannot optimize through llvm.vector.insert/extract, causing register
+    // spilling and overhead that does not occur with fixed NEON vectors.
+    if (target.has_feature(Target::SVE2)) {
+        printf("[SKIP] SVE2-capable cores typically have fast division; fast_inverse is not expected to win.\n");
+        return 0;
+    }
+
     Func slow, fast;
     Var x;
     Param<float> p(1.0f);
