[InstSimplify] teach SimplifySelectInst() to fold more vector selects

[haicheng]

Summary

Call ConstantExpr::getSelect() to fold cases like below

select <2 x i1><i1 true, i1 false>, <2 x i8> <i8 0, i8 1>, <2 x i8> <i8 2, i8 3>

All operands are constants and the condition has mixed true and false conditions

[spatel]

lib/Analysis/InstructionSimplify.cpp

3585

I think we should use ConstantFoldSelectInstruction() here (to be more efficient?). That's the interface for other opcodes from what I can see in other parts of the file.

[haicheng]

lib/Analysis/InstructionSimplify.cpp

3585

I think I cannot use ConstantFoldSelectInstruction() which is declared in IR/ConstantFold.h rather than llvm/Analysis/ConstantFolding.h. From the comments in IR/ConstantFold.h, ConstantFoldSelectInstruction() is used internal to ConstantExpr::get* methods.

Many ConstantFoldxxx methods used in this file are declared in llvm/Analysis/ConstantFolding.h. I also find several places in this file calling ConstantExpr::get* methods.

[spatel]

lib/Analysis/InstructionSimplify.cpp

3585

Why not just add a line to ConstantFolding.h with the definition of ConstantFoldSelectInstruction()?

I'm looking at:
SimplifyExtractValueInst
SimplifyInsertValueInst
SimplifyExtractElementInst
SimplifyCastInst
etc.

They are all using this pattern, so why should SimplifySelectInst() be different? I think your way is fine too, but if we do that, then we should change everything else to be consistent.

[haicheng]

Switch to use ConstantFoldSelectInstruction().

[spatel]

LGTM.

include/llvm/Analysis/ConstantFolding.h

ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
                                 const TargetLibraryInfo *TLI = nullptr);
 
 /// \brief Attempt to constant fold a binary operation with the specified
 /// operands.  If it fails, it returns a constant expression of the specified
 /// operands.
 Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
                                        Constant *RHS, const DataLayout &DL);
 
+/// \brief Attempt to constant fold a select instruction with the specified
+/// operands. The constant result is returned if successful; if not, null is
+/// returned.
+Constant *ConstantFoldSelectInstruction(Constant *Cond, Constant *V1,
+                                        Constant *V2);
+
 /// \brief Attempt to constant fold a cast with the specified operand.  If it
 /// fails, it returns a constant expression of the specified operand.
 Constant *ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy,
                                   const DataLayout &DL);
 
 /// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue
 /// instruction with the specified operands and indices.  The constant result is
 /// returned if successful; if not, null is returned.

lib/Analysis/InstructionSimplify.cpp

 /// Given operands for a SelectInst, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifySelectInst(Value *CondVal, Value *TrueVal,
                                  Value *FalseVal, const SimplifyQuery &Q,
                                  unsigned MaxRecurse) {
   // select true, X, Y  -> X
   // select false, X, Y -> Y
   if (Constant *CB = dyn_cast<Constant>(CondVal)) {
+    if (Constant *CT = dyn_cast<Constant>(TrueVal))
+      if (Constant *CF = dyn_cast<Constant>(FalseVal))
+        return ConstantFoldSelectInstruction(CB, CT, CF);
     if (CB->isAllOnesValue())
       return TrueVal;
     if (CB->isNullValue())
       return FalseVal;
   }
 
   // select C, X, X -> X
   if (TrueVal == FalseVal)

test/Transforms/InstSimplify/select.ll

 define <2 x i8> @vsel_fvec(<2 x i8> %x, <2 x i8> %y) {
 ; CHECK-LABEL: @vsel_fvec(
 ; CHECK-NEXT:    ret <2 x i8> %y
 ;
   %s = select <2 x i1><i1 false, i1 false>, <2 x i8> %x, <2 x i8> %y
   ret <2 x i8> %s
 }
 
+define <2 x i8> @vsel_mixedvec() {
+; CHECK-LABEL: @vsel_mixedvec(
+; CHECK-NEXT:    ret <2 x i8> <i8 0, i8 3>
+;
+  %s = select <2 x i1><i1 true, i1 false>, <2 x i8> <i8 0, i8 1>, <2 x i8> <i8 2, i8 3>
+  ret <2 x i8> %s
+}
+
 define i32 @test1(i32 %x) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    ret i32 %x
 ;
   %and = and i32 %x, 1
   %cmp = icmp eq i32 %and, 0
   %and1 = and i32 %x, -2
   %and1.x = select i1 %cmp, i32 %and1, i32 %x