[llvm-commits] [llvm] r108422 - in /llvm/trunk: lib/Transforms/InstCombine/InstCombineAndOrXor.cpp lib/Transforms/InstCombine/InstCombineSelect.cpp test/Transforms/InstCombine/bit-checks.ll

[Chris Lattner]

On Jul 15, 2010, at 8:00 AM, Owen Anderson wrote:

> Author: resistor
> Date: Thu Jul 15 10:00:23 2010
> New Revision: 108422
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=108422&view=rev
> Log:
> Reapply r108378, with bugfixes, testcase, and improved comment formatting.
> This now passes LIT, nighty test, and llvm-gcc bootstrap on my machine.

Hi Owen,

Is there a reason not to make the corresponding "or" pattern?  Handling the or pattern in instcombineselect seems more limited than handling the general (icmp ne (A & C1), 0) | (icmp ne (A & C2), 0) pattern.
 

-Chris

> 
> Added:
>    llvm/trunk/test/Transforms/InstCombine/bit-checks.ll
> Modified:
>    llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
>    llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> 
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp?rev=108422&r1=108421&r2=108422&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Thu Jul 15 10:00:23 2010
> @@ -472,6 +472,25 @@
>       Value *NewOr = Builder->CreateOr(Val, Val2);
>       return Builder->CreateICmp(LHSCC, NewOr, LHSCst);
>     }
> +    
> +    // (icmp ne (A & C1), 0) & (icmp ne (A & C2), 0) -->
> +    // (icmp eq (A & (C1|C2)), (C1|C2))
> +    if (LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) {
> +      Instruction *I1 = dyn_cast<Instruction>(Val);
> +      Instruction *I2 = dyn_cast<Instruction>(Val2);
> +      if (I1 && I1->getOpcode() == Instruction::And &&
> +          I2 && I2->getOpcode() == Instruction::And &&
> +          I1->getOperand(0) == I1->getOperand(0)) {
> +        ConstantInt *CI1 = dyn_cast<ConstantInt>(I1->getOperand(1));
> +        ConstantInt *CI2 = dyn_cast<ConstantInt>(I2->getOperand(1));
> +        if (CI1 && !CI1->isZero() && CI2 && !CI2->isZero() &&
> +            CI1->getValue().operator&(CI2->getValue()) == 0) {
> +          Constant *ConstOr = ConstantExpr::getOr(CI1, CI2);
> +          Value *NewAnd = Builder->CreateAnd(I1->getOperand(0), ConstOr);
> +          return Builder->CreateICmp(ICmpInst::ICMP_EQ, NewAnd, ConstOr);
> +        }
> +      }
> +    }
>   }
> 
>   // From here on, we only handle:
> 
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp?rev=108422&r1=108421&r2=108422&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp Thu Jul 15 10:00:23 2010
> @@ -699,6 +699,34 @@
>     SI.setOperand(2, TrueVal);
>     return &SI;
>   }
> +  
> +  // select (A == 0 | B == 0), T, F--> select (A != 0 & B != 0), F, T
> +  // Note: This is a canonicalization rather than an optimization, and is used
> +  // to expose opportunities to other instcombine transforms.
> +  Instruction* CondInst = dyn_cast<Instruction>(CondVal);
> +  if (CondInst && CondInst->hasOneUse() && 
> +      CondInst->getOpcode() == Instruction::Or) {
> +    ICmpInst *LHSCmp = dyn_cast<ICmpInst>(CondInst->getOperand(0));
> +    ICmpInst *RHSCmp = dyn_cast<ICmpInst>(CondInst->getOperand(1));
> +    if (LHSCmp && LHSCmp->hasOneUse() &&
> +                  LHSCmp->getPredicate() == ICmpInst::ICMP_EQ &&
> +        RHSCmp && RHSCmp->hasOneUse() &&
> +                  RHSCmp->getPredicate() == ICmpInst::ICMP_EQ) {
> +      ConstantInt* C1 = dyn_cast<ConstantInt>(LHSCmp->getOperand(1));
> +      ConstantInt* C2 = dyn_cast<ConstantInt>(RHSCmp->getOperand(1));
> +      if (C1 && C1->isZero() && C2 && C2->isZero()) {
> +        LHSCmp->setPredicate(ICmpInst::ICMP_NE);
> +        RHSCmp->setPredicate(ICmpInst::ICMP_NE);
> +        Value *And =
> +          InsertNewInstBefore(BinaryOperator::CreateAnd(LHSCmp, RHSCmp,
> +                                             "and."+CondVal->getName()), SI);
> +        SI.setOperand(0, And);
> +        SI.setOperand(1, FalseVal);
> +        SI.setOperand(2, TrueVal);
> +        return &SI;
> +      }
> +    }
> +  }
> 
>   return 0;
> }
> 
> Added: llvm/trunk/test/Transforms/InstCombine/bit-checks.ll
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/bit-checks.ll?rev=108422&view=auto
> ==============================================================================
> --- llvm/trunk/test/Transforms/InstCombine/bit-checks.ll (added)
> +++ llvm/trunk/test/Transforms/InstCombine/bit-checks.ll Thu Jul 15 10:00:23 2010
> @@ -0,0 +1,15 @@
> +; This test makes sure that these instructions are properly eliminated.
> +;
> +; RUN: opt < %s -instcombine -S | \
> +; RUN:    not grep {tobool}
> +; END.
> +define i32 @main(i32 %argc, i8** %argv) nounwind ssp {
> +entry:
> +  %and = and i32 %argc, 1                         ; <i32> [#uses=1]
> +  %tobool = icmp ne i32 %and, 0                   ; <i1> [#uses=1]
> +  %and2 = and i32 %argc, 2                        ; <i32> [#uses=1]
> +  %tobool3 = icmp ne i32 %and2, 0                 ; <i1> [#uses=1]
> +  %or.cond = and i1 %tobool, %tobool3             ; <i1> [#uses=1]
> +  %retval.0 = select i1 %or.cond, i32 2, i32 1    ; <i32> [#uses=1]
> +  ret i32 %retval.0
> +}
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits