Fix lossless casts of vector reduces down to bools (#9012)

Fixes #9011

Author: abadams

src/IROperator.cpp

@@ -544,12 +544,20 @@ Expr lossless_cast(Type t,
                     }
                 }
             } else if (const VectorReduce *op = e.as<VectorReduce>()) {
-                if (op->op == VectorReduce::Add ||
+                if ((t.bits() > 1 && op->op == VectorReduce::Add) ||
                     op->op == VectorReduce::Min ||
                     op->op == VectorReduce::Max) {
                     Expr v = lossless_cast(t.with_lanes(op->value.type().lanes()), op->value, scope, cache);
                     if (v.defined()) {
-                        return VectorReduce::make(op->op, v, op->type.lanes());
+                        auto reduce_op = op->op;
+                        if (t.bits() == 1) {
+                            // UInt(1) == Bool() is the only 1-bit type we expect to see
+                            internal_assert(t.is_uint()) << "Unexpected type: " << t << "\n";
+                            reduce_op = (op->op == VectorReduce::Min ?
+                                             VectorReduce::And :
+                                             VectorReduce::Or);
+                        }
+                        return VectorReduce::make(reduce_op, v, op->type.lanes());
                     }
                 }
             }

test/correctness/lossless_cast.cpp

@@ -81,6 +81,28 @@ int lossless_cast_test() {
     e = cast(i64, 1024) * cast(i64, 1024) * cast(i64, 1024);
     res |= check_lossless_cast(i32, e, (cast(i32, 1024) * 1024) * 1024);
 
+    // Check narrowing a vector reduction of something narrowable to bool ...
+    auto make_reduce = [&](Type t, VectorReduce::Operator op) {
+        return VectorReduce::make(op,
+                                  cast(t.with_lanes(4), Ramp::make(x, 1, 4) > 4), 2);
+    };
+
+    // It's OK to narrow it to 8-bit.
+    e = make_reduce(UInt(16), VectorReduce::Add);
+    res |= check_lossless_cast(UInt(8), e, make_reduce(UInt(8), VectorReduce::Add));
+
+    // ... but we can't reduce it all the way to bool if the operator isn't
+    // legal for bools (issue #9011)
+    e = make_reduce(UInt(8), VectorReduce::Add);
+    res |= check_lossless_cast(Bool(), e, Expr());
+
+    // Min or Max, however, can just become And and Or
+    e = make_reduce(UInt(8), VectorReduce::Min);
+    res |= check_lossless_cast(Bool(), e, make_reduce(Bool(), VectorReduce::And));
+
+    e = make_reduce(UInt(8), VectorReduce::Max);
+    res |= check_lossless_cast(Bool(), e, make_reduce(Bool(), VectorReduce::Or));
+
     return res;
 }