[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 ↗

(On Diff #262975)

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 (C1VTy->isScalable())
-      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 (C1VTy->isScalable())
+      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));