Lines Matching refs:Builder
56 InstCombiner::BuilderTy &Builder) {
60 return Builder.CreateICmp(NewPred, LHS, RHS);
66 InstCombiner::BuilderTy &Builder) {
74 return Builder.CreateFCmp(Pred, LHS, RHS);
83 InstCombiner::BuilderTy &Builder) {
109 Value *BinOp = Builder.CreateBinOp(I.getOpcode(), NewLHS, NewRHS);
112 return Builder.CreateCall(F, BinOp);
149 Value *NewAnd = Builder.CreateAnd(X, AndRHS);
176 return Builder.CreateICmp(Pred, V, ConstantInt::get(Ty, Hi));
182 Builder.CreateSub(V, ConstantInt::get(Ty, Lo), V->getName() + ".off");
184 return Builder.CreateICmp(Pred, VMinusLo, HiMinusLo);
444 llvm::InstCombiner::BuilderTy &Builder) {
512 Value *NewAnd = Builder.CreateAnd(A, NewMask);
513 return Builder.CreateICmp(NewCC, NewAnd, NewMaskedValue);
575 llvm::InstCombiner::BuilderTy &Builder) {
590 PredL, PredR, Builder)) {
596 PredR, PredL, Builder)) {
606 llvm::InstCombiner::BuilderTy &Builder) {
623 Builder))
650 Value *NewOr = Builder.CreateOr(B, D);
651 Value *NewAnd = Builder.CreateAnd(A, NewOr);
656 return Builder.CreateICmp(NewCC, NewAnd, Zero);
661 Value *NewOr = Builder.CreateOr(B, D);
662 Value *NewAnd = Builder.CreateAnd(A, NewOr);
663 return Builder.CreateICmp(NewCC, NewAnd, NewOr);
668 Value *NewAnd1 = Builder.CreateAnd(B, D);
669 Value *NewAnd2 = Builder.CreateAnd(A, NewAnd1);
670 return Builder.CreateICmp(NewCC, NewAnd2, A);
738 Value *NewOr1 = Builder.CreateOr(B, D);
740 Value *NewAnd = Builder.CreateAnd(A, NewOr1);
741 return Builder.CreateICmp(NewCC, NewAnd, NewOr2);
799 return Builder.CreateICmp(NewPred, Input, RangeEnd);
805 InstCombiner::BuilderTy &Builder) {
836 Value *Or = Builder.CreateOr(X, ConstantInt::get(X->getType(), Xor));
837 return Builder.CreateICmp(Pred, Or, ConstantInt::get(X->getType(), *C2));
849 Value *Add = Builder.CreateAdd(X, ConstantInt::get(X->getType(), -(*C1)));
851 return Builder.CreateICmp(NewPred, Add, ConstantInt::get(X->getType(), 1));
889 Value *Mask = Builder.CreateOr(B, D);
890 Value *Masked = Builder.CreateAnd(A, Mask);
892 return Builder.CreateICmp(NewPred, Masked, Mask);
931 InstCombiner::BuilderTy &Builder) {
1019 return Builder.CreateICmpULT(X, ConstantInt::get(X->getType(), HighestBit),
1025 InstCombiner::BuilderTy &Builder) {
1040 return Builder.CreateICmpEQ(CtPop, ConstantInt::get(CtPop->getType(), 1));
1048 return Builder.CreateICmpNE(CtPop, ConstantInt::get(CtPop->getType(), 1));
1058 InstCombiner::BuilderTy &Builder) {
1092 return Builder.CreateICmpULT(Builder.CreateNeg(B), A);
1095 return Builder.CreateICmpULT(Builder.CreateNeg(B), A);
1098 return Builder.CreateICmpUGE(Builder.CreateNeg(B), A);
1101 return Builder.CreateICmpUGE(Builder.CreateNeg(B), A);
1118 return Builder.CreateICmpUGT(Base, Offset);
1125 return Builder.CreateICmpULE(Base, Offset);
1130 return Builder.CreateICmpULT(Base, Offset);
1135 return Builder.CreateICmpUGE(Base, Offset);
1145 InstCombiner::BuilderTy &Builder,
1181 SubstituteCmp = Builder.CreateICmp(Pred1, Y, C);
1183 return Builder.CreateBinOp(Logic.getOpcode(), Cmp0, SubstituteCmp);
1208 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
1213 if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, true, Builder))
1216 if (Value *V = foldAndOrOfICmpsWithConstEq(LHS, RHS, And, Builder, Q))
1218 if (Value *V = foldAndOrOfICmpsWithConstEq(RHS, LHS, And, Builder, Q))
1229 if (Value *V = foldAndOrOfEqualityCmpsWithConstants(LHS, RHS, true, Builder))
1232 if (Value *V = foldSignedTruncationCheck(LHS, RHS, And, Builder))
1235 if (Value *V = foldIsPowerOf2(LHS, RHS, true /* JoinedByAnd */, Builder))
1239 foldUnsignedUnderflowCheck(LHS, RHS, /*IsAnd=*/true, Q, Builder))
1242 foldUnsignedUnderflowCheck(RHS, LHS, /*IsAnd=*/true, Q, Builder))
1258 Value *NewOr = Builder.CreateOr(LHS0, RHS0);
1259 return Builder.CreateICmp(PredL, NewOr, LHSC);
1291 Value *NewAnd = Builder.CreateAnd(V, Low | AndC->getValue());
1294 return Builder.CreateICmp(PredL, NewAnd, NewVal);
1347 return Builder.CreateICmpULT(LHS0, LHSC);
1355 return Builder.CreateICmpSLT(LHS0, LHSC);
1373 return Builder.CreateICmp(PredL, LHS0, RHSC);
1391 return Builder.CreateICmp(PredL, LHS0, RHSC);
1436 return getFCmpValue(NewPred, LHS0, LHS1, Builder);
1450 return Builder.CreateFCmp(PredL, LHS0, RHS0);
1461 InstCombiner::BuilderTy &Builder) {
1493 Value *NewFCmp = Builder.CreateFCmp(Pred, X, Y);
1506 InstCombiner::BuilderTy &Builder) {
1519 Value *AndOr = Builder.CreateBinOp(Opcode, A, B, I.getName() + ".demorgan");
1544 InstCombiner::BuilderTy &Builder) {
1563 Value *NewOp = Builder.CreateBinOp(LogicOpc, X, TruncC);
1573 Value *NewOp = Builder.CreateBinOp(LogicOpc, X, TruncC);
1598 if (Instruction *Ret = foldLogicCastConstant(I, Cast0, Builder))
1616 Value *NewOp = Builder.CreateBinOp(LogicOpc, Cast0Src, Cast1Src,
1649 InstCombiner::BuilderTy &Builder) {
1669 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
1675 InstCombiner::BuilderTy &Builder) {
1687 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
1762 Value *NewBO = Opc == Instruction::Sub ? Builder.CreateBinOp(Opc, NewC, X)
1763 : Builder.CreateBinOp(Opc, X, NewC);
1764 return new ZExtInst(Builder.CreateAnd(NewBO, X), Ty);
1787 if (Instruction *Xor = foldAndToXor(I, Builder))
1794 if (Value *V = SimplifyBSwap(I, Builder))
1805 Value *IsZero = Builder.CreateICmpEQ(X, ConstantInt::get(I.getType(), 0));
1813 Value *And = Builder.CreateAnd(X, Op1);
1827 Value *And = Builder.CreateAnd(X, ConstantInt::get(I.getType(),
1842 Value *NewRHS = Builder.CreateAnd(Y, Op1, Y->getName() + ".masked");
1848 Value *NewLHS = Builder.CreateAnd(X, Op1, X->getName() + ".masked");
1858 Value *Sext = Builder.CreateSExt(X, I.getType());
1892 BinOp = Builder.CreateBinOp(Op0I->getOpcode(), X, TruncC1);
1894 BinOp = Builder.CreateBinOp(Op0I->getOpcode(), TruncC1, X);
1896 auto *And = Builder.CreateAnd(BinOp, TruncC2);
1916 Value *NewCast = Builder.CreateTrunc(X, I.getType(), "and.shrunk");
1930 if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
1937 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(B));
1940 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(B));
1946 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(C));
1952 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
1984 return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
1987 return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
1992 return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
1995 return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
2004 if (Instruction *FoldedFCmps = reassociateFCmps(I, Builder))
2028 Value *NewICmpInst = Builder.CreateICmpSGT(X, Y);
2148 InstCombiner::BuilderTy &Builder) {
2174 Value *NewLower = Builder.CreateZExt(Lo, Ty);
2175 Value *NewUpper = Builder.CreateZExt(Hi, Ty);
2176 NewUpper = Builder.CreateShl(NewUpper, HalfWidth);
2177 Value *BinOp = Builder.CreateOr(NewLower, NewUpper);
2179 return Builder.CreateCall(F, BinOp);
2235 return Builder.CreateTrunc(A, CmpInst::makeCmpResultType(Ty));
2242 return Builder.CreateZExtOrTrunc(A, CmpInst::makeCmpResultType(Ty));
2269 return Builder.CreateXor(Cond, AConst);
2287 Value *BitcastC = Builder.CreateBitCast(C, A->getType());
2288 Value *BitcastD = Builder.CreateBitCast(D, A->getType());
2289 Value *Select = Builder.CreateSelect(Cond, BitcastC, BitcastD);
2290 return Builder.CreateBitCast(Select, OrigType);
2358 Value *NewAnd = Builder.CreateAnd(LAddOpnd, MaskC);
2359 Value *NewAdd = Builder.CreateAdd(NewAnd, MaxAddC);
2360 return Builder.CreateICmp(LHS->getPredicate(), NewAdd, LHSC);
2376 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
2382 if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, false, Builder))
2407 return Builder.CreateICmp(
2409 Builder.CreateAdd(B, ConstantInt::getSigned(B->getType(), -1)), A);
2412 if (Value *V = foldAndOrOfICmpsWithConstEq(LHS, RHS, Or, Builder, Q))
2414 if (Value *V = foldAndOrOfICmpsWithConstEq(RHS, LHS, Or, Builder, Q))
2425 if (Value *V = foldAndOrOfEqualityCmpsWithConstants(LHS, RHS, false, Builder))
2428 if (Value *V = foldIsPowerOf2(LHS, RHS, false /* JoinedByAnd */, Builder))
2432 foldUnsignedUnderflowCheck(LHS, RHS, /*IsAnd=*/false, Q, Builder))
2435 foldUnsignedUnderflowCheck(RHS, LHS, /*IsAnd=*/false, Q, Builder))
2445 Value *NewOr = Builder.CreateOr(LHS0, RHS0);
2446 return Builder.CreateICmp(PredL, NewOr, LHSC);
2456 return Builder.CreateICmpULE(LHS0, LHSC);
2580 if (Instruction *Xor = foldOrToXor(I, Builder))
2587 if (Value *V = SimplifyBSwap(I, Builder))
2599 if (Instruction *Concat = matchOrConcat(I, Builder))
2608 Value *Or = Builder.CreateOr(X, Y);
2630 Builder.getInt(C1->getValue()|C2->getValue()));
2638 Builder.getInt(C1->getValue()|C2->getValue()));
2647 V2 = Builder.CreateOr(V1, ConstantExpr::getOr(C3, C4), "bitfield");
2649 Builder.getInt(C1->getValue()|C2->getValue()));
2658 return BinaryOperator::CreateOr(Builder.CreateAnd(X, C1), B);
2661 return BinaryOperator::CreateOr(Builder.CreateAnd(X, C2), A);
2665 return BinaryOperator::CreateXor(Builder.CreateAnd(X, C1), B);
2668 return BinaryOperator::CreateXor(Builder.CreateAnd(X, C2), A);
2708 return BinaryOperator::CreateOr(Op1, Builder.CreateAnd(A, C));
2710 if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
2732 Value *Not = Builder.CreateNot(B, B->getName() + ".not");
2736 Value *Not = Builder.CreateNot(A, A->getName() + ".not");
2750 Value *Not = Builder.CreateNot(NotOp, NotOp->getName() + ".not");
2770 return replaceInstUsesWith(I, Builder.CreateOr(Res, Y));
2773 return replaceInstUsesWith(I, Builder.CreateOr(Res, X));
2778 return replaceInstUsesWith(I, Builder.CreateOr(Res, Y));
2781 return replaceInstUsesWith(I, Builder.CreateOr(Res, X));
2790 if (Instruction *FoldedFCmps = reassociateFCmps(I, Builder))
2812 Value *Inner = Builder.CreateOr(A, Op1);
2825 Value *orTrue = Builder.CreateOr(A, C);
2826 Value *orFalse = Builder.CreateOr(B, D);
2840 Value *NewICmpInst = Builder.CreateICmpSGT(X, Y);
2870 Value *NotNullA = Builder.CreateIsNotNull(A);
2871 Value *NotNullB = Builder.CreateIsNotNull(B);
2882 InstCombiner::BuilderTy &Builder) {
2927 return BinaryOperator::CreateNot(Builder.CreateXor(A, B));
2947 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
2967 return Builder.CreateICmpSLT(Builder.CreateXor(LHS0, RHS0), Zero);
2976 return Builder.CreateICmpSGT(Builder.CreateXor(LHS0, RHS0), MinusOne);
3011 BuilderTy::InsertPointGuard Guard(Builder);
3013 Builder.SetInsertPoint(Y->getParent(), ++(Y->getIterator()));
3014 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
3021 return Builder.CreateAnd(LHS, RHS);
3044 InstCombiner::BuilderTy &Builder) {
3057 Value *NewA = Builder.CreateAnd(D, NotM);
3067 Value *LHS = Builder.CreateAnd(X, C);
3068 Value *NotC = Builder.CreateNot(C);
3069 Value *RHS = Builder.CreateAnd(B, NotC);
3083 InstCombiner::BuilderTy &Builder) {
3098 Value *NotX = Builder.CreateNot(X, X->getName() + ".not");
3116 if (Instruction *NewXor = foldXorToXor(I, Builder))
3128 if (Value *V = SimplifyBSwap(I, Builder))
3150 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
3156 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
3160 if (Instruction *Xor = visitMaskedMerge(I, Builder))
3175 Value *NotX = Builder.CreateNot(NotVal->getOperand(0), "notlhs");
3176 Value *NotY = Builder.CreateNot(NotVal->getOperand(1), "notrhs");
3186 return BinaryOperator::CreateAdd(Builder.CreateNot(X), Y);
3229 Value *And = Builder.CreateAnd(X, ConstantExpr::getNot(C2));
3234 Value *Or = Builder.CreateOr(X, ConstantExpr::getNot(C2));
3288 Value *Opnd0 = Builder.CreateLShr(E1->getOperand(0), C2);
3306 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
3310 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
3315 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
3323 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
3330 Builder.CreateAnd(Builder.CreateNot(A), C), B);
3336 Builder.CreateAnd(Builder.CreateNot(B), C), A);
3351 return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
3377 Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
3380 Value *Neg = Builder.CreateNeg(A, "", Add->hasNoUnsignedWrap(),
3404 Value *NotY = Builder.CreateNot(RHS);
3406 Builder.CreateICmp(getInverseMinMaxPred(SPF), X, NotY), X, NotY);
3412 Value *NotX = Builder.CreateNot(LHS);
3414 Builder.CreateICmp(getInverseMinMaxPred(SPF), NotX, Y), NotX, Y);
3421 Value *NotLHS = Builder.CreateNot(LHS);
3422 Value *NotRHS = Builder.CreateNot(RHS);
3424 Builder.CreateICmp(getInverseMinMaxPred(SPF), NotLHS, NotRHS),
3447 if (Instruction *NewXor = sinkNotIntoXor(I, Builder))