[ConstantFold][SVE] Do not iterate on scalable vector for ConstantFoldSelectInstruction.

[huihuiz]

Summary

Scanning through ConstantFoldSelectInstruction, we should not fold elementwise for scalable vectors.
Although I cannot create a crashing test case for select instruction, this will require select condition
to be a ConstantVector also scalable.

Add a positive test case, as the rest of the foldings in ConstantFoldSelectInstruction is harmless for scalable vector.

[efriedma]

It's impossible for a ConstantDataVector or a ConstantVector to be scalable at the moment. And I don't expect that will ever change: there isn't any incentive to make any new constant representation use those types, as opposed to making a new subclass of Constant. Given that, I don't think it's worth adding guards to code that's already explicitly looking for a ConstantVector/ConstantDataVector.

Test change looks fine.

[huihuiz]

Make sense, merge only the test case

llvm/lib/IR/ConstantFold.cpp

 }
 
 Constant *llvm::ConstantFoldSelectInstruction(Constant *Cond,
                                               Constant *V1, Constant *V2) {
   // Check for i1 and vector true/false conditions.
   if (Cond->isNullValue()) return V2;
   if (Cond->isAllOnesValue()) return V1;
 
-  // If the condition is a vector constant, fold the result elementwise.
-  if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
-    SmallVector<Constant*, 16> Result;
-    Type *Ty = IntegerType::get(CondV->getContext(), 32);
-    for (unsigned i = 0, e = V1->getType()->getVectorNumElements(); i != e;++i){
-      Constant *V;
-      Constant *V1Element = ConstantExpr::getExtractElement(V1,
-                                                    ConstantInt::get(Ty, i));
-      Constant *V2Element = ConstantExpr::getExtractElement(V2,
-                                                    ConstantInt::get(Ty, i));
-      auto *Cond = cast<Constant>(CondV->getOperand(i));
-      if (V1Element == V2Element) {
-        V = V1Element;
-      } else if (isa<UndefValue>(Cond)) {
-        V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
-      } else {
-        if (!isa<ConstantInt>(Cond)) break;
-        V = Cond->isNullValue() ? V2Element : V1Element;
+  // Do not iterate on scalable vector. The number of elements is unknown at
+  // compile-time.
+  if (!V1->getType()->getVectorIsScalable())
+    // If the condition is a vector constant, fold the result elementwise.
+    if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
+      SmallVector<Constant *, 16> Result;
+      Type *Ty = IntegerType::get(CondV->getContext(), 32);
+      for (unsigned i = 0, e = V1->getType()->getVectorNumElements(); i != e;
+           ++i) {
+        Constant *V;
+        Constant *V1Element =
+            ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, i));
+        Constant *V2Element =
+            ConstantExpr::getExtractElement(V2, ConstantInt::get(Ty, i));
+        auto *Cond = cast<Constant>(CondV->getOperand(i));
+        if (V1Element == V2Element) {
+          V = V1Element;
+        } else if (isa<UndefValue>(Cond)) {
+          V = isa<UndefValue>(V1Element) ? V1Element : V2Element;
+        } else {
+          if (!isa<ConstantInt>(Cond))
+            break;
+          V = Cond->isNullValue() ? V2Element : V1Element;
+        }
+        Result.push_back(V);
       }
-      Result.push_back(V);
-    }
 
       // If we were able to build the vector, return it.
       if (Result.size() == V1->getType()->getVectorNumElements())
         return ConstantVector::get(Result);
     }
 
   if (isa<UndefValue>(Cond)) {
     if (isa<UndefValue>(V1)) return V1;
     return V2;
   }
   if (isa<UndefValue>(V1)) return V2;
   if (isa<UndefValue>(V2)) return V1;
   if (V1 == V2) return V1;

llvm/test/Analysis/ConstantFolding/vscale.ll

 
 define <vscale x 4 x i32> @xor() {
 ; CHECK-LABEL: @xor(
 ; CHECK-NEXT:    ret <vscale x 4 x i32> zeroinitializer
 ;
   %r = xor <vscale x 4 x i32> undef, undef
   ret <vscale x 4 x i32> %r
 }
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Other Operations
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define <vscale x 4 x i32> @select() {
+; CHECK-LABEL: @select(
+; CHECK-NEXT:    ret <vscale x 4 x i32> undef
+;
+  %r = select <vscale x 4 x i1> undef, <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32> undef
+  ret <vscale x 4 x i32> %r
+}