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 && CI2) {
+ 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:
SI.setOperand(2, TrueVal);
return &SI;
}
+
+ // select (or (A == 0) (B == 0)) T, F--> select (and (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->getOpcode() == Instruction::Or) {
+ ICmpInst *LHSCmp = dyn_cast<ICmpInst>(CondInst->getOperand(0));
+ ICmpInst *RHSCmp = dyn_cast<ICmpInst>(CondInst->getOperand(1));
+ if (LHSCmp && LHSCmp->getPredicate() == ICmpInst::ICMP_EQ &&
+ RHSCmp && 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;
}