[SVE] Take constant fold fast path for splatted vscale vectors

[ctetreau]

Summary

This should be a perfectly reasonable operation for scalable vectors.
Currently, it only works for zeroinitializer values of
ScalableVectorType, but the fundamental operation is sound and it should
be possible to make it work for other splats

[efriedma]

Please add test coverage in llvm/test/Analysis/ConstantFolding/

[ctetreau]

rebase

[ctetreau]

add test

[ctetreau]

By the way, this test case was generated via a script. Should I commit the script also? If so, where should I put it?

[spatel]

In D77442#2027808, @ctetreau wrote:

By the way, this test case was generated via a script. Should I commit the script also? If so, where should I put it?

Not sure if you mean the test code itself or the assertion for the tests? llvm/utils/ is probably the spot to find/add scripts that help with testing.

llvm/test/Analysis/ConstantFolding/cmp-vec-fast-path.ll

7

This should be handled more specifically with "-constprop" (don't need the full power of -instcombine).

Use the standard "utils/update_test_checks.py" to auto-generate the CHECK lines? Can also pre-commit the baseline tests, then update here so we just have diffs for the assertion lines.

[ctetreau]

rebase

[ctetreau]

fix tests, use new support for getSplatValue workikng with scalable vectors from D82416

[ctetreau]

rebase

[ctetreau]

Necro patch. address code review issues.

[ctetreau]

Ping?

[ctetreau]

Fix broken test

[david-arm]

LGTM

llvm/lib/IR/ConstantFold.cpp

if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
     case FCmpInst::FCMP_UGE:
       return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
     case FCmpInst::FCMP_OGE:
       return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
                                         R==APFloat::cmpEqual);
     }
   } else if (auto *C1VTy = dyn_cast<VectorType>(C1->getType())) {
 
-    // Do not iterate on scalable vector. The number of elements is unknown at
-    // compile-time.
-    if (isa<ScalableVectorType>(C1VTy))
-      return nullptr;
-
     // Fast path for splatted constants.
     if (Constant *C1Splat = C1->getSplatValue())
       if (Constant *C2Splat = C2->getSplatValue())
         return ConstantVector::getSplat(
             C1VTy->getElementCount(),
             ConstantExpr::getCompare(pred, C1Splat, C2Splat));
 
+    // Do not iterate on scalable vector. The number of elements is unknown at
+    // compile-time.
+    if (isa<ScalableVectorType>(C1VTy))
+      return nullptr;
+
     // If we can constant fold the comparison of each element, constant fold
     // the whole vector comparison.
     SmallVector<Constant*, 4> ResElts;
     Type *Ty = IntegerType::get(C1->getContext(), 32);
     // Compare the elements, producing an i1 result or constant expr.
     for (unsigned i = 0, e = C1VTy->getNumElements(); i != e; ++i) {
       Constant *C1E =
         ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, i));

llvm/lib/IR/Constants.cpp

 Constant *Constant::getSplatValue(bool AllowUndefs) const {
   assert(this->getType()->isVectorTy() && "Only valid for vectors!");
   if (isa<ConstantAggregateZero>(this))
     return getNullValue(cast<VectorType>(getType())->getElementType());
   if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this))
     return CV->getSplatValue();
   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
     return CV->getSplatValue(AllowUndefs);
+  // FIXME: this should be able to get a splat value from scalable vector splats
+  // of the form returned by ConstantVector::getSplat()
   return nullptr;
 }
 
 Constant *ConstantVector::getSplatValue(bool AllowUndefs) const {
   // Check out first element.
   Constant *Elt = getOperand(0);
   // Then make sure all remaining elements point to the same value.
   for (unsigned I = 1, E = getNumOperands(); I < E; ++I) {

llvm/test/Analysis/ConstantFolding/cmp-vec-fast-path.ll

+
+; Check that cmp's of scalable vector splats are constant folded
+; FIXME: Constant::getSplatValue() only knows how to get the splat value of
+;        ConstantAggregateZero values with scalable vector type. Once it is
+;        extended to support arbitrary splats, this test should be updated
+
+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+
+; CHECK-LABEL: i32cmp_eq_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @i32cmp_eq_fixed() {
+  %res = icmp eq <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_eq_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @i32cmp_eq_scalable() {
+  %res = icmp eq <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ne_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @i32cmp_ne_fixed() {
+  %res = icmp ne <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ne_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @i32cmp_ne_scalable() {
+  %res = icmp ne <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ugt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @i32cmp_ugt_fixed() {
+  %res = icmp ugt <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ugt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @i32cmp_ugt_scalable() {
+  %res = icmp ugt <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_uge_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @i32cmp_uge_fixed() {
+  %res = icmp uge <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_uge_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @i32cmp_uge_scalable() {
+  %res = icmp uge <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ult_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @i32cmp_ult_fixed() {
+  %res = icmp ult <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ult_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @i32cmp_ult_scalable() {
+  %res = icmp ult <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ule_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @i32cmp_ule_fixed() {
+  %res = icmp ule <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_ule_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @i32cmp_ule_scalable() {
+  %res = icmp ule <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sgt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @i32cmp_sgt_fixed() {
+  %res = icmp sgt <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sgt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @i32cmp_sgt_scalable() {
+  %res = icmp sgt <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sge_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @i32cmp_sge_fixed() {
+  %res = icmp sge <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sge_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @i32cmp_sge_scalable() {
+  %res = icmp sge <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_slt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @i32cmp_slt_fixed() {
+  %res = icmp slt <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_slt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @i32cmp_slt_scalable() {
+  %res = icmp slt <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sle_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @i32cmp_sle_fixed() {
+  %res = icmp sle <2 x i32> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: i32cmp_sle_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @i32cmp_sle_scalable() {
+  %res = icmp sle <vscale x 2 x i32> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_false_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_false_fixed() {
+  %res = fcmp false <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_false_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_false_scalable() {
+  %res = fcmp false <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_oeq_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_oeq_fixed() {
+  %res = fcmp oeq <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_oeq_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_oeq_scalable() {
+  %res = fcmp oeq <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ogt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_ogt_fixed() {
+  %res = fcmp ogt <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ogt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_ogt_scalable() {
+  %res = fcmp ogt <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_oge_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_oge_fixed() {
+  %res = fcmp oge <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_oge_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_oge_scalable() {
+  %res = fcmp oge <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_olt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_olt_fixed() {
+  %res = fcmp olt <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_olt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_olt_scalable() {
+  %res = fcmp olt <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ole_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_ole_fixed() {
+  %res = fcmp ole <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ole_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_ole_scalable() {
+  %res = fcmp ole <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_one_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_one_fixed() {
+  %res = fcmp one <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_one_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_one_scalable() {
+  %res = fcmp one <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ord_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_ord_fixed() {
+  %res = fcmp ord <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ord_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_ord_scalable() {
+  %res = fcmp ord <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ueq_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_ueq_fixed() {
+  %res = fcmp ueq <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ueq_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_ueq_scalable() {
+  %res = fcmp ueq <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ugt_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_ugt_fixed() {
+  %res = fcmp ugt <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ugt_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_ugt_scalable() {
+  %res = fcmp ugt <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_uge_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_uge_fixed() {
+  %res = fcmp uge <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_uge_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_uge_scalable() {
+  %res = fcmp uge <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ult_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_ult_fixed() {
+  %res = fcmp ult <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ult_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_ult_scalable() {
+  %res = fcmp ult <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ule_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_ule_fixed() {
+  %res = fcmp ule <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_ule_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_ule_scalable() {
+  %res = fcmp ule <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_une_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_une_fixed() {
+  %res = fcmp une <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_une_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_une_scalable() {
+  %res = fcmp une <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_uno_fixed
+; CHECK: ret <2 x i1> zeroinitializer
+define <2 x i1> @floatcmp_uno_fixed() {
+  %res = fcmp uno <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_uno_scalable
+; CHECK: ret <vscale x 2 x i1> zeroinitializer
+define <vscale x 2 x i1> @floatcmp_uno_scalable() {
+  %res = fcmp uno <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_true_fixed
+; CHECK: ret <2 x i1> shufflevector (<vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0), <vscale x 2 x i1> undef, <vscale x 2 x i32> zeroinitializer)
+define <2 x i1> @floatcmp_true_fixed() {
+  %res = fcmp true <2 x float> zeroinitializer, zeroinitializer
+  ret <2 x i1> %res
+}
+
+
+; CHECK-LABEL: floatcmp_true_scalable
+; CHECK: ret <vscale x 2 x i1> <i1 true, i1 true>
+define <vscale x 2 x i1> @floatcmp_true_scalable() {
+  %res = fcmp true <vscale x 2 x float> zeroinitializer, zeroinitializer
+  ret <vscale x 2 x i1> %res
+}
+