Lines Matching refs:BinaryOperator
1570 Instruction *InstCombinerImpl::foldLogicOfIsFPClass(BinaryOperator &BO,
1637 BinaryOperator &I) {
1638 assert(I.getOpcode() == BinaryOperator::Xor && "Only for xor!");
1654 static Instruction *reassociateFCmps(BinaryOperator &BO,
1689 return BinaryOperator::Create(Opcode, NewFCmp, BO11);
1695 static Instruction *matchDeMorgansLaws(BinaryOperator &I,
1713 return BinaryOperator::CreateNot(AndOr);
1725 return BinaryOperator::Create(Opcode, A, IC.Builder.CreateNot(FlippedBO));
1748 static Instruction *foldLogicCastConstant(BinaryOperator &Logic, CastInst *Cast,
1783 Instruction *InstCombinerImpl::foldCastedBitwiseLogic(BinaryOperator &I) {
1880 static Instruction *foldAndToXor(BinaryOperator &I,
1892 return BinaryOperator::CreateXor(A, B);
1901 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
1906 static Instruction *foldOrToXor(BinaryOperator &I,
1919 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
1927 return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
1935 return BinaryOperator::CreateXor(A, B);
1949 Instruction *InstCombinerImpl::narrowMaskedBinOp(BinaryOperator &And) {
1975 Instruction::BinaryOps Opc = cast<BinaryOperator>(Op0)->getOpcode();
1990 static Instruction *foldComplexAndOrPatterns(BinaryOperator &I,
2033 ? BinaryOperator::CreateAnd(Xor, Builder.CreateNot(A))
2034 : BinaryOperator::CreateNot(Builder.CreateAnd(Xor, A));
2043 ? BinaryOperator::CreateAnd(Xor, Builder.CreateNot(B))
2044 : BinaryOperator::CreateNot(Builder.CreateAnd(Xor, B));
2051 return BinaryOperator::CreateNot(Builder.CreateBinOp(
2058 return BinaryOperator::CreateNot(Builder.CreateBinOp(
2072 Value *Or = cast<BinaryOperator>(X)->getOperand(0);
2073 return BinaryOperator::CreateNot(Builder.CreateAnd(Or, Y));
2105 ? BinaryOperator::CreateNot(Builder.CreateOr(Xor, A))
2106 : BinaryOperator::CreateOr(Xor, X);
2113 return BinaryOperator::Create(
2121 return BinaryOperator::Create(
2133 static Instruction *reassociateForUses(BinaryOperator &BO,
2144 return BinaryOperator::Create(Opcode, YZ, X);
2149 return BinaryOperator::Create(Opcode, XZ, Y);
2166 static Instruction *canonicalizeLogicFirst(BinaryOperator &I,
2197 return BinaryOperator::CreateWithCopiedFlags(Instruction::Add, NewBinOp,
2204 Instruction *InstCombinerImpl::foldBinOpOfDisplacedShifts(BinaryOperator &I) {
2241 return BinaryOperator::Create(ShiftOp, NewC, ShAmt);
2254 foldBitwiseLogicWithIntrinsics(BinaryOperator &I,
2319 auto *I = dyn_cast<BinaryOperator>(V);
2370 Instruction *InstCombinerImpl::visitAnd(BinaryOperator &I) {
2434 return BinaryOperator::CreateAnd(Builder.CreateNot(X), Y);
2443 return BinaryOperator::CreateXor(And, NewC);
2457 return BinaryOperator::CreateOr(And, ConstantInt::get(Ty, Together));
2469 return BinaryOperator::CreateLShr(Sext, ShAmtC);
2477 return BinaryOperator::CreateLShr(X, ConstantInt::get(Ty, *ShiftC));
2488 return BinaryOperator::CreateXor(NewAnd, Op1);
2494 auto isNarrowableBinOpcode = [](BinaryOperator *B) {
2506 BinaryOperator *BO;
2557 BinaryOperator::BinaryOps BinOp = cast<BinaryOperator>(Op0)->getOpcode();
2562 return BinaryOperator::Create(BinOp, X, NewRHS);
2568 return BinaryOperator::Create(BinOp, NewLHS, Y);
2581 cast<BinaryOperator>(Op0)->getOpcode() == Instruction::Shl;
2659 return BinaryOperator::CreateAnd(SExt, Op1);
2688 return BinaryOperator::CreateAnd(Op0, B);
2691 return BinaryOperator::CreateAnd(Op1, B);
2700 return BinaryOperator::CreateAnd(Op0, NotC);
2710 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
2719 return BinaryOperator::CreateAnd(A, B);
2727 return BinaryOperator::CreateAnd(A, B);
2735 return BinaryOperator::CreateAnd(Builder.CreateNot(A), B);
2743 return BinaryOperator::CreateAnd(Builder.CreateNot(A), B);
2852 return BinaryOperator::CreateAnd(V, Op1);
2856 return BinaryOperator::CreateAnd(Op0, V);
2882 assert(Or.getOpcode() == BinaryOperator::Or && "Expecting or instruction");
2896 if (isa<BinaryOperator>(Or0) && isa<BinaryOperator>(Or1)) {
2906 if (Or0->getOpcode() == BinaryOperator::LShr) {
2911 assert(Or0->getOpcode() == BinaryOperator::Shl &&
2912 Or1->getOpcode() == BinaryOperator::LShr &&
3530 static Value *foldOrOfInversions(BinaryOperator &I,
3552 Instruction *InstCombinerImpl::visitOr(BinaryOperator &I) {
3639 return BinaryOperator::CreateXor(Or, ConstantInt::get(Ty, *CV));
3647 return BinaryOperator::CreateMul(X, IncrementY);
3662 return BinaryOperator::CreateOr(Builder.CreateAnd(X, *C0), B);
3665 return BinaryOperator::CreateOr(Builder.CreateAnd(X, *C1), A);
3669 return BinaryOperator::CreateXor(Builder.CreateAnd(X, *C0), B);
3672 return BinaryOperator::CreateXor(Builder.CreateAnd(X, *C1), A);
3681 return BinaryOperator::CreateAnd(A, C01);
3688 return BinaryOperator::CreateAnd(B, C01);
3698 return BinaryOperator::CreateAnd(Or, C01);
3746 return BinaryOperator::CreateOr(Op0, C);
3753 return BinaryOperator::CreateOr(Op1, C);
3769 return BinaryOperator::CreateOr(Op0, B);
3771 return BinaryOperator::CreateOr(Op0, A);
3776 return BinaryOperator::CreateOr(A, B);
3783 return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
3792 return BinaryOperator::CreateNot(Builder.CreateAnd(And, B));
3796 return BinaryOperator::CreateNot(Builder.CreateAnd(And, A));
3804 return BinaryOperator::CreateOr(Nand, C);
3856 return BinaryOperator::CreateOr(Inner, CI);
3895 return BinaryOperator::CreateXor(A, B);
3932 return BinaryOperator::CreateAnd(NotNullA, NotNullB);
3961 return BinaryOperator::CreateOr(Ov, NewCmp);
3976 return BinaryOperator::CreateLShr(Constant::getAllOnesValue(Ty), Sub);
3999 return BinaryOperator::CreateOr(
4011 return BinaryOperator::CreateOr(
4056 return BinaryOperator::CreateAnd(X, ConstantInt::get(Ty, *C1 | *C2));
4065 return BinaryOperator::CreateOr(V, Op1);
4069 return BinaryOperator::CreateOr(Op0, V);
4080 static Instruction *foldXorToXor(BinaryOperator &I,
4095 return BinaryOperator::CreateXor(A, B);
4103 return BinaryOperator::CreateXor(A, B);
4111 return BinaryOperator::CreateXor(A, B);
4126 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
4132 BinaryOperator &I) {
4268 static Instruction *visitMaskedMerge(BinaryOperator &I,
4283 return BinaryOperator::CreateXor(NewA, X);
4295 return BinaryOperator::CreateOr(LHS, RHS);
4301 static Instruction *foldNotXor(BinaryOperator &I,
4319 return BinaryOperator::CreateOr(X, NotY);
4327 return BinaryOperator::CreateOr(Y, NotX);
4335 static Instruction *canonicalizeAbs(BinaryOperator &Xor,
4358 auto *Add = cast<BinaryOperator>(Op0);
4402 bool IsBinaryOp = isa<BinaryOperator>(I);
4442 bool IsBinaryOp = isa<BinaryOperator>(I);
4477 Instruction *InstCombinerImpl::foldNot(BinaryOperator &I) {
4495 return BinaryOperator::CreateOr(X, NotY);
4506 return BinaryOperator::CreateAnd(X, NotY);
4514 BinaryOperator *NotVal;
4521 return BinaryOperator::CreateAnd(DecX, NotY);
4526 return BinaryOperator::CreateAShr(X, Y);
4532 return BinaryOperator::CreateAShr(X, Y);
4551 return BinaryOperator::CreateLShr(ConstantExpr::getNot(C), Y);
4556 return BinaryOperator::CreateAShr(ConstantExpr::getNot(C), Y);
4560 return BinaryOperator::CreateSub(ConstantExpr::getNot(C), X);
4566 return BinaryOperator::CreateAdd(Builder.CreateNot(X), Y);
4570 return BinaryOperator::CreateWithCopiedFlags(Instruction::Sub, X, Y,
4663 Instruction *InstCombinerImpl::visitXor(BinaryOperator &I) {
4703 return BinaryOperator::CreateXor(XorAC, Y);
4706 return BinaryOperator::CreateXor(XorBC, X);
4716 return BinaryOperator::CreateDisjointOr(Op0, Op1);
4718 return BinaryOperator::CreateOr(Op0, Op1);
4735 return BinaryOperator::CreateXor(
4743 return BinaryOperator::CreateXor(And, ConstantExpr::getNot(C1));
4748 return BinaryOperator::CreateXor(Or, ConstantExpr::getNot(C1));
4774 return BinaryOperator::CreateSub(ConstantInt::get(Ty, *C + *RHSC), X);
4778 return BinaryOperator::CreateAdd(X, ConstantInt::get(Ty, *C + *RHSC));
4783 return BinaryOperator::CreateXor(X, ConstantInt::get(Ty, *C ^ *RHSC));
4807 return BinaryOperator::CreateShl(NotX, ConstantInt::get(Ty, *C));
4813 return BinaryOperator::CreateLShr(NotX, ConstantInt::get(Ty, *C));
4856 return BinaryOperator::CreateXor(Opnd0, ConstantInt::get(Ty, FoldConst));
4866 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
4870 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
4875 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
4883 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
4889 return BinaryOperator::CreateXor(
4895 return BinaryOperator::CreateXor(
4901 return BinaryOperator::CreateOr(A, B);
4905 return BinaryOperator::CreateOr(A, B);
4911 return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
4915 return BinaryOperator::CreateOr(A, B);
4919 return BinaryOperator::CreateNot(Builder.CreateAnd(Op1, B));
4923 return BinaryOperator::CreateNot(Builder.CreateAnd(Op0, B));
4936 return BinaryOperator::CreateAnd(Builder.CreateXor(B, C), NotA);
4976 return BinaryOperator::CreateXor(Builder.CreateXor(X, Y), C1);