|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
lib/Transforms/InstCombine/InstCombineAddSub.cpp 887 return BinaryOperator::CreateAdd(Builder.CreateNot(Y), X);
933 return new ZExtInst(Builder.CreateNot(X), Ty);
940 Value *NotX = Builder.CreateNot(X);
1045 return IsSigned ? Builder.CreateSRem(X, NewDivisor, "srem")
1046 : Builder.CreateURem(X, NewDivisor, "urem");
1197 Builder.Insert(NewAShr);
1220 if (Instruction *X = foldNoWrapAdd(I, Builder))
1250 Value *NewShl = Builder.CreateShl(XorLHS, ShAmt, "sext");
1285 return BinaryOperator::CreateNeg(Builder.CreateAdd(A, B));
1295 return BinaryOperator::CreateSub(A, Builder.CreateZExt(B, Ty));
1301 if (Value *V = checkForNegativeOperand(I, Builder))
1341 Value *NewAdd = Builder.CreateAdd(X, CRHS, LHS->getName());
1403 if (Instruction *V = canonicalizeLowbitMask(I, Builder))
1500 Value *XY = Builder.CreateFMulFMF(X, Y, &I);
1509 Value *XY = Builder.CreateFDivFMF(X, Y, &I);
1547 Value *NewAdd = Builder.CreateNSWAdd(LHSIntVal, CI, "addconv");
1565 Value *NewAdd = Builder.CreateNSWAdd(LHSIntVal, RHSIntVal, "addconv");
1577 if (Instruction *F = factorizeFAddFSub(I, Builder))
1579 if (Value *V = FAddCombine(Builder).simplify(&I))
1662 Result = Builder.CreateSub(Result, Offset);
1667 Result = Builder.CreateNeg(Result, "diff.neg");
1669 return Builder.CreateIntCast(Result, Ty, true);
1717 return BinaryOperator::CreateAdd(Builder.CreateNot(Op1), X);
1721 return BinaryOperator::CreateAdd(Builder.CreateNot(X), Op0);
1726 Builder.CreateAdd(Op0, ConstantInt::get(I.getType(), 1)), X);
1793 Builder.Insert(NewShift);
1805 Builder.Insert(NewShift);
1856 return BinaryOperator::CreateNeg(Builder.CreateXor(A, B));
1873 return BinaryOperator::CreateNeg(Builder.CreateAnd(A, B));
1881 Y, Builder.CreateNot(Op1, Op1->getName() + ".not"));
1891 Builder.CreateSub(Z, Y, Op1->getName()));
1896 Builder.CreateNot(Y, Y->getName() + ".not"));
1919 Value *Zext = Builder.CreateZExt(Y, I.getType());
1929 return BinaryOperator::CreateAdd(Op0, Builder.CreateMul(A, B));
1935 Value *NewMul = Builder.CreateMul(A, ConstantExpr::getNeg(C));
1964 Value *Not = Builder.CreateNot(MinMax);
2001 Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
2003 Value *Neg = Builder.CreateNeg(A, "", I.hasNoUnsignedWrap(),
2084 if (Instruction *R = hoistFNegAboveFMulFDiv(I, Builder))
2108 if (Instruction *R = hoistFNegAboveFMulFDiv(I, Builder))
2122 Value *NewSub = Builder.CreateFSubFMF(Y, X, &I);
2146 return BinaryOperator::CreateFAddFMF(Op0, Builder.CreateFPTrunc(Y, Ty), &I);
2150 return BinaryOperator::CreateFAddFMF(Op0, Builder.CreateFPExt(Y, Ty), &I);
2156 Value *FMul = Builder.CreateFMulFMF(X, Y, &I);
2163 Value *FDiv = Builder.CreateFDivFMF(X, Y, &I);
2192 if (Instruction *F = factorizeFAddFSub(I, Builder))
2199 if (Value *V = FAddCombine(Builder).simplify(&I))
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp 150 Value *NewAnd = Builder.CreateAnd(X, AndRHS);
177 return Builder.CreateICmp(Pred, V, ConstantInt::get(Ty, Hi));
183 Builder.CreateSub(V, ConstantInt::get(Ty, Lo), V->getName() + ".off");
185 return Builder.CreateICmp(Pred, VMinusLo, HiMinusLo);
800 return Builder.CreateICmp(NewPred, Input, RangeEnd);
888 Value *Mask = Builder.CreateOr(B, D);
889 Value *Masked = Builder.CreateAnd(A, Mask);
891 return Builder.CreateICmp(NewPred, Masked, Mask);
1166 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
1171 if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, true, Builder))
1182 if (Value *V = foldAndOrOfEqualityCmpsWithConstants(LHS, RHS, true, Builder))
1185 if (Value *V = foldSignedTruncationCheck(LHS, RHS, CxtI, Builder))
1188 if (Value *V = foldIsPowerOf2(LHS, RHS, true /* JoinedByAnd */, Builder))
1192 foldUnsignedUnderflowCheck(LHS, RHS, /*IsAnd=*/true, Q, Builder))
1195 foldUnsignedUnderflowCheck(RHS, LHS, /*IsAnd=*/true, Q, Builder))
1211 Value *NewOr = Builder.CreateOr(LHS0, RHS0);
1212 return Builder.CreateICmp(PredL, NewOr, LHSC);
1244 Value *NewAnd = Builder.CreateAnd(V, Low | AndC->getValue());
1247 return Builder.CreateICmp(PredL, NewAnd, NewVal);
1300 return Builder.CreateICmpULT(LHS0, LHSC);
1308 return Builder.CreateICmpSLT(LHS0, LHSC);
1326 return Builder.CreateICmp(PredL, LHS0, RHSC);
1344 return Builder.CreateICmp(PredL, LHS0, RHSC);
1389 return getFCmpValue(NewPred, LHS0, LHS1, Builder);
1403 return Builder.CreateFCmp(PredL, LHS0, RHS0);
1551 if (Instruction *Ret = foldLogicCastConstant(I, Cast0, Builder))
1569 Value *NewOp = Builder.CreateBinOp(LogicOpc, Cast0Src, Cast1Src,
1715 Value *NewBO = Opc == Instruction::Sub ? Builder.CreateBinOp(Opc, NewC, X)
1716 : Builder.CreateBinOp(Opc, X, NewC);
1717 return new ZExtInst(Builder.CreateAnd(NewBO, X), Ty);
1740 if (Instruction *Xor = foldAndToXor(I, Builder))
1747 if (Value *V = SimplifyBSwap(I, Builder))
1758 Value *IsZero = Builder.CreateICmpEQ(X, ConstantInt::get(I.getType(), 0));
1766 Value *And = Builder.CreateAnd(X, Op1);
1780 Value *And = Builder.CreateAnd(X, ConstantInt::get(I.getType(),
1795 Value *NewRHS = Builder.CreateAnd(Y, Op1, Y->getName() + ".masked");
1801 Value *NewLHS = Builder.CreateAnd(X, Op1, X->getName() + ".masked");
1835 BinOp = Builder.CreateBinOp(Op0I->getOpcode(), X, TruncC1);
1837 BinOp = Builder.CreateBinOp(Op0I->getOpcode(), TruncC1, X);
1839 auto *And = Builder.CreateAnd(BinOp, TruncC2);
1859 Value *NewCast = Builder.CreateTrunc(X, I.getType(), "and.shrunk");
1873 if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
1880 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(B));
1883 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(B));
1889 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(C));
1895 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(C));
1927 return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
1930 return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
1935 return replaceInstUsesWith(I, Builder.CreateAnd(Res, Y));
1938 return replaceInstUsesWith(I, Builder.CreateAnd(Res, X));
1947 if (Instruction *FoldedFCmps = reassociateFCmps(I, Builder))
1971 Value *NewICmpInst = Builder.CreateICmpSGT(X, Y);
2125 return Builder.CreateTrunc(A, CmpInst::makeCmpResultType(Ty));
2132 return Builder.CreateZExtOrTrunc(A, CmpInst::makeCmpResultType(Ty));
2159 return Builder.CreateXor(Cond, AConst);
2177 Value *BitcastC = Builder.CreateBitCast(C, A->getType());
2178 Value *BitcastD = Builder.CreateBitCast(D, A->getType());
2179 Value *Select = Builder.CreateSelect(Cond, BitcastC, BitcastD);
2180 return Builder.CreateBitCast(Select, OrigType);
2248 Value *NewAnd = Builder.CreateAnd(LAddOpnd, MaskC);
2249 Value *NewAdd = Builder.CreateAdd(NewAnd, MaxAddC);
2250 return Builder.CreateICmp(LHS->getPredicate(), NewAdd, LHSC);
2266 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
2272 if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, false, Builder))
2297 return Builder.CreateICmp(
2299 Builder.CreateAdd(B, ConstantInt::getSigned(B->getType(), -1)), A);
2310 if (Value *V = foldAndOrOfEqualityCmpsWithConstants(LHS, RHS, false, Builder))
2313 if (Value *V = foldIsPowerOf2(LHS, RHS, false /* JoinedByAnd */, Builder))
2317 foldUnsignedUnderflowCheck(LHS, RHS, /*IsAnd=*/false, Q, Builder))
2320 foldUnsignedUnderflowCheck(RHS, LHS, /*IsAnd=*/false, Q, Builder))
2330 Value *NewOr = Builder.CreateOr(LHS0, RHS0);
2331 return Builder.CreateICmp(PredL, NewOr, LHSC);
2341 return Builder.CreateICmpULE(LHS0, LHSC);
2465 if (Instruction *Xor = foldOrToXor(I, Builder))
2472 if (Value *V = SimplifyBSwap(I, Builder))
2490 Value *Or = Builder.CreateOr(X, Y);
2512 Builder.getInt(C1->getValue()|C2->getValue()));
2520 Builder.getInt(C1->getValue()|C2->getValue()));
2529 V2 = Builder.CreateOr(V1, ConstantExpr::getOr(C3, C4), "bitfield");
2531 Builder.getInt(C1->getValue()|C2->getValue()));
2540 return BinaryOperator::CreateOr(Builder.CreateAnd(X, C1), B);
2543 return BinaryOperator::CreateOr(Builder.CreateAnd(X, C2), A);
2547 return BinaryOperator::CreateXor(Builder.CreateAnd(X, C1), B);
2550 return BinaryOperator::CreateXor(Builder.CreateAnd(X, C2), A);
2590 return BinaryOperator::CreateOr(Op1, Builder.CreateAnd(A, C));
2592 if (Instruction *DeMorgan = matchDeMorgansLaws(I, Builder))
2614 Value *Not = Builder.CreateNot(B, B->getName() + ".not");
2618 Value *Not = Builder.CreateNot(A, A->getName() + ".not");
2632 Value *Not = Builder.CreateNot(NotOp, NotOp->getName() + ".not");
2652 return replaceInstUsesWith(I, Builder.CreateOr(Res, Y));
2655 return replaceInstUsesWith(I, Builder.CreateOr(Res, X));
2660 return replaceInstUsesWith(I, Builder.CreateOr(Res, Y));
2663 return replaceInstUsesWith(I, Builder.CreateOr(Res, X));
2672 if (Instruction *FoldedFCmps = reassociateFCmps(I, Builder))
2694 Value *Inner = Builder.CreateOr(A, Op1);
2707 Value *orTrue = Builder.CreateOr(A, C);
2708 Value *orFalse = Builder.CreateOr(B, D);
2722 Value *NewICmpInst = Builder.CreateICmpSGT(X, Y);
2812 return getNewICmpValue(Code, IsSigned, Op0, Op1, Builder);
2832 return Builder.CreateICmpSLT(Builder.CreateXor(LHS0, RHS0), Zero);
2832 return Builder.CreateICmpSLT(Builder.CreateXor(LHS0, RHS0), Zero);
2841 return Builder.CreateICmpSGT(Builder.CreateXor(LHS0, RHS0), MinusOne);
2841 return Builder.CreateICmpSGT(Builder.CreateXor(LHS0, RHS0), MinusOne);
2876 BuilderTy::InsertPointGuard Guard(Builder);
2878 Builder.SetInsertPoint(Y->getParent(), ++(Y->getIterator()));
2879 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
2885 return Builder.CreateAnd(LHS, RHS);
2977 if (Instruction *NewXor = foldXorToXor(I, Builder))
2989 if (Value *V = SimplifyBSwap(I, Builder))
3011 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
3017 Value *NotY = Builder.CreateNot(Y, Y->getName() + ".not");
3021 if (Instruction *Xor = visitMaskedMerge(I, Builder))
3036 Value *NotX = Builder.CreateNot(NotVal->getOperand(0), "notlhs");
3037 Value *NotY = Builder.CreateNot(NotVal->getOperand(1), "notrhs");
3047 return BinaryOperator::CreateAdd(Builder.CreateNot(X), Y);
3080 Value *And = Builder.CreateAnd(X, ConstantExpr::getNot(C2));
3085 Value *Or = Builder.CreateOr(X, ConstantExpr::getNot(C2));
3142 Value *Opnd0 = Builder.CreateLShr(E1->getOperand(0), C2);
3160 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op0));
3164 return BinaryOperator::CreateAnd(X, Builder.CreateNot(Op1));
3169 return BinaryOperator::CreateAnd(Op0, Builder.CreateNot(X));
3177 return BinaryOperator::CreateAnd(Op1, Builder.CreateNot(X));
3184 Builder.CreateAnd(Builder.CreateNot(A), C), B);
3184 Builder.CreateAnd(Builder.CreateNot(A), C), B);
3190 Builder.CreateAnd(Builder.CreateNot(B), C), A);
3190 Builder.CreateAnd(Builder.CreateNot(B), C), A);
3205 return BinaryOperator::CreateNot(Builder.CreateAnd(A, B));
3231 Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
3234 Value *Neg = Builder.CreateNeg(A, "", Add->hasNoUnsignedWrap(),
3258 Value *NotY = Builder.CreateNot(RHS);
3260 Builder.CreateICmp(getInverseMinMaxPred(SPF), X, NotY), X, NotY);
3266 Value *NotX = Builder.CreateNot(LHS);
3268 Builder.CreateICmp(getInverseMinMaxPred(SPF), NotX, Y), NotX, Y);
3275 Value *NotLHS = Builder.CreateNot(LHS);
3276 Value *NotRHS = Builder.CreateNot(RHS);
3278 Builder.CreateICmp(getInverseMinMaxPred(SPF), NotLHS, NotRHS),
3284 if (Instruction *NewXor = sinkNotIntoXor(I, Builder))
lib/Transforms/InstCombine/InstCombineCalls.cpp 184 Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
185 Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
186 LoadInst *L = Builder.CreateLoad(IntType, Src);
200 StoreInst *S = Builder.CreateStore(L, Dest);
268 Dest = Builder.CreateBitCast(Dest, NewDstPtrTy);
272 StoreInst *S = Builder.CreateStore(ConstantInt::get(ITy, Fill), Dest,
1057 return Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
1065 Value *LI = Builder.CreateAlignedLoad(II.getType(), LoadPtr, Alignment,
1067 return Builder.CreateSelect(II.getArgOperand(2), LI, II.getArgOperand(3));
1167 Result = IC.Builder.CreateLaunderInvariantGroup(StrippedInvariantGroupsArg);
1169 Result = IC.Builder.CreateStripInvariantGroup(StrippedInvariantGroupsArg);
1175 Result = IC.Builder.CreateAddrSpaceCast(Result, II.getType());
1177 Result = IC.Builder.CreateBitCast(Result, II.getType());
1238 II.setOperand(1, IC.Builder.getTrue());
1319 Value *PtrCast = IC.Builder.CreateBitCast(Ptr, VecPtrTy, "castvec");
1327 IC.Builder.CreateMaskedLoad(PtrCast, 1, BoolMask, ZeroVec);
1362 Value *PtrCast = IC.Builder.CreateBitCast(Ptr, VecPtrTy, "castvec");
1368 IC.Builder.CreateMaskedStore(Vec, PtrCast, 1, BoolMask);
1898 Value *V = Builder.CreateLShr(X, CV);
2033 *II, Builder.CreateBinaryIntrinsic(
2066 *II, Builder.CreateBinaryIntrinsic(Intrinsic::sadd_with_overflow,
2114 *II, Builder.CreateBinaryIntrinsic(
2147 *II, Builder.CreateBinaryIntrinsic(
2185 Value *NewCall = Builder.CreateBinaryIntrinsic(NewIID, X, Y, II);
2216 Instruction *NewCall = Builder.CreateBinaryIntrinsic(
2228 BuilderTy::FastMathFlagGuard Guard(Builder);
2229 Builder.setFastMathFlags(II->getFastMathFlags());
2230 Value *Mul = Builder.CreateFMul(II->getArgOperand(0),
2232 Value *Add = Builder.CreateFAdd(Mul, II->getArgOperand(2));
2287 CallInst *Call0 = Builder.CreateCall(II->getCalledFunction(), {LHS});
2288 CallInst *Call1 = Builder.CreateCall(II->getCalledFunction(), {RHS});
2303 Value *NarrowII = Builder.CreateUnaryIntrinsic(IID, ExtSrc, II);
2324 Value *NewSin = Builder.CreateUnaryIntrinsic(Intrinsic::sin, X, II);
2336 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
2344 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
2355 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
2363 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
2370 Type *VTy = VectorType::get(Builder.getFloatTy(),
2372 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
2374 Value *Load = Builder.CreateLoad(VTy, Ptr);
2382 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
2391 Type *VTy = VectorType::get(Builder.getFloatTy(),
2393 Value *TOp = Builder.CreateFPTrunc(II->getArgOperand(0), VTy);
2395 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
2405 Value *Ptr = Builder.CreateBitCast(II->getArgOperand(1), OpPtrTy);
2480 VectorHalfAsShorts = Builder.CreateShuffleVector(
2487 Builder.CreateBitCast(VectorHalfAsShorts, VectorHalfType);
2488 auto VectorFloats = Builder.CreateFPExt(VectorHalfs, RetType);
2542 if (Value *V = simplifyX86movmsk(*II, Builder))
2644 V = Builder.CreateFAdd(Arg0, Arg1);
2648 V = Builder.CreateFSub(Arg0, Arg1);
2652 V = Builder.CreateFMul(Arg0, Arg1);
2656 V = Builder.CreateFDiv(Arg0, Arg1);
2680 Value *LHS = Builder.CreateExtractElement(Arg0, (uint64_t)0);
2681 Value *RHS = Builder.CreateExtractElement(Arg1, (uint64_t)0);
2688 V = Builder.CreateFAdd(LHS, RHS);
2692 V = Builder.CreateFSub(LHS, RHS);
2696 V = Builder.CreateFMul(LHS, RHS);
2700 V = Builder.CreateFDiv(LHS, RHS);
2710 auto *MaskTy = VectorType::get(Builder.getInt1Ty(),
2712 Mask = Builder.CreateBitCast(Mask, MaskTy);
2713 Mask = Builder.CreateExtractElement(Mask, (uint64_t)0);
2715 Value *Passthru = Builder.CreateExtractElement(II->getArgOperand(2),
2717 V = Builder.CreateSelect(Mask, V, Passthru);
2721 V = Builder.CreateInsertElement(Arg0, V, (uint64_t)0);
2758 if (Value *V = simplifyX86immShift(*II, Builder))
2789 if (Value *V = simplifyX86immShift(*II, Builder))
2833 if (Value *V = simplifyX86varShift(*II, Builder))
2843 if (Value *V = simplifyX86pack(*II, Builder, true))
2853 if (Value *V = simplifyX86pack(*II, Builder, false))
2899 if (Value *V = simplifyX86insertps(*II, Builder))
2922 if (Value *V = simplifyX86extrq(*II, Op0, CILength, CIIndex, Builder))
2954 if (Value *V = simplifyX86extrq(*II, Op0, CILength, CIIndex, Builder))
2986 if (Value *V = simplifyX86insertq(*II, Op0, Op1, Len, Idx, Builder))
3019 if (Value *V = simplifyX86insertq(*II, Op0, Op1, Len, Idx, Builder))
3081 Value *CastOp0 = Builder.CreateBitCast(Op0, Mask->getType());
3082 Value *CastOp1 = Builder.CreateBitCast(Op1, Mask->getType());
3083 Value *Sel = Builder.CreateSelect(BoolVec, CastOp1, CastOp0);
3094 if (Value *V = simplifyX86pshufb(*II, Builder))
3104 if (Value *V = simplifyX86vpermilvar(*II, Builder))
3122 if (Value *V = simplifyX86vpermv(*II, Builder))
3153 if (Value *V = simplifyX86addcarry(*II, Builder))
3180 Value *Op0 = Builder.CreateBitCast(II->getArgOperand(0),
3182 Value *Op1 = Builder.CreateBitCast(II->getArgOperand(1),
3203 Builder.CreateExtractElement(Idx < 16 ? Op0ToUse : Op1ToUse,
3204 Builder.getInt32(Idx&15));
3208 Result = Builder.CreateInsertElement(Result, ExtractedElts[Idx],
3209 Builder.getInt32(i));
3219 if (Value *V = simplifyNeonVld1(*II, MemAlign, Builder))
3252 if (Value *V = simplifyNeonTbl1(*II, Builder))
3417 Value *FCmp = Builder.CreateFCmpUNO(Src0, Src0);
3424 Value *FCmp = Builder.CreateFCmpOEQ(
3445 CallInst *NewCall = Builder.CreateCall(II->getCalledFunction(),
3558 Value *Shl = Builder.CreateShl(Src, IntSize - Offset - Width);
3559 Value *RightShift = Signed ? Builder.CreateAShr(Shl, IntSize - Width)
3560 : Builder.CreateLShr(Shl, IntSize - Width);
3565 Value *RightShift = Signed ? Builder.CreateAShr(Src, Offset)
3566 : Builder.CreateLShr(Src, Offset);
3609 NewCall = Builder.CreateMinNum(Src1, Src2);
3611 NewCall = Builder.CreateMinNum(Src0, Src2);
3613 NewCall = Builder.CreateMaxNum(Src0, Src1);
3654 ConstantFP::get(Builder.getContext(), Result));
3694 CallInst *NewCall = Builder.CreateCall(NewF, Args);
3772 IntegerType *CmpTy = Builder.getIntNTy(NewWidth);
3774 SrcLHS = Builder.CreateSExt(SrcLHS, CmpTy);
3775 SrcRHS = Builder.CreateSExt(SrcRHS, CmpTy);
3777 SrcLHS = Builder.CreateZExt(SrcLHS, CmpTy);
3778 SrcRHS = Builder.CreateZExt(SrcRHS, CmpTy);
3790 CallInst *NewCall = Builder.CreateCall(NewF, Args);
3937 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic, A, II->getName());
3938 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic, B, II->getName());
3943 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
3944 Builder.CreateNot(A), II->getName());
3945 Builder.CreateCall(AssumeIntrinsicTy, AssumeIntrinsic,
3946 Builder.CreateNot(B), II->getName());
4058 II->setArgOperand(0, Builder.CreateAnd(CurrCond, NextCond));
4573 NewArg = Builder.CreateBitOrPointerCast(*AI, ParamTy);
4604 NewArg = Builder.CreateCast(opcode, *AI, PTy);
4629 NewCall = Builder.CreateInvoke(Callee, II->getNormalDest(),
4632 NewCall = Builder.CreateCallBr(Callee, CBI->getDefaultDest(),
4635 NewCall = Builder.CreateCall(Callee, Args, OpBundles);
4744 NestVal = Builder.CreateBitCast(NestVal, NestTy, "nest");
lib/Transforms/InstCombine/InstCombineCasts.cpp 87 BuilderTy AllocaBuilder(Builder);
483 VecInput = IC.Builder.CreateBitCast(VecInput, VecType, "bc");
490 return ExtractElementInst::Create(VecInput, IC.Builder.getInt32(Elt));
567 Value *NarrowShAmt = Builder.CreateTrunc(ShAmt, DestTy);
568 Value *X = Builder.CreateTrunc(ShVal, DestTy);
602 Value *TruncX = Builder.CreateTrunc(BinOp1, DestTy);
608 Value *TruncX = Builder.CreateTrunc(BinOp0, DestTy);
614 Value *NarrowOp1 = Builder.CreateTrunc(BinOp1, DestTy);
619 Value *NarrowOp0 = Builder.CreateTrunc(BinOp0, DestTy);
731 Value *And = Builder.CreateAnd(Src, ConstantInt::get(SrcTy, 1));
742 Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
749 Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
775 Value *Shift = Builder.CreateLShr(A, Cst->getZExtValue());
805 Value *Shift = Builder.CreateAShr(A, std::min(ShiftAmt, ASize - 1));
815 if (Instruction *I = shrinkSplatShuffle(CI, Builder))
818 if (Instruction *I = shrinkInsertElt(CI, Builder))
831 Value *NewTrunc = Builder.CreateTrunc(A, DestTy, A->getName() + ".tr");
863 In = Builder.CreateLShr(In, Sh, In->getName() + ".lobit");
865 In = Builder.CreateIntCast(In, CI.getType(), false /*ZExt*/);
869 In = Builder.CreateXor(In, One, In->getName() + ".not");
906 In = Builder.CreateLShr(In, ConstantInt::get(In->getType(), ShAmt),
912 In = Builder.CreateXor(In, One);
918 Value *IntCast = Builder.CreateIntCast(In, CI.getType(), false);
941 Value *Result = Builder.CreateXor(LHS, RHS);
945 Result = Builder.CreateAnd(Result,
949 Result = Builder.CreateLShr(
953 Result = Builder.CreateXor(Result, ConstantInt::get(ITy, 1));
1157 Value *And = Builder.CreateAnd(A, AndConst, CSrc->getName() + ".mask");
1167 Value *Trunc = Builder.CreateTrunc(A, CI.getType());
1189 Value *LCast = Builder.CreateZExt(LHS, CI.getType(), LHS->getName());
1190 Value *RCast = Builder.CreateZExt(RHS, CI.getType(), RHS->getName());
1217 return BinaryOperator::CreateXor(Builder.CreateAnd(X, ZC), ZC);
1238 Value *In = Builder.CreateAShr(Op0, Sh, Op0->getName() + ".lobit");
1240 In = Builder.CreateIntCast(In, CI.getType(), true /*SExt*/);
1243 In = Builder.CreateNot(In, In->getName() + ".not");
1273 In = Builder.CreateLShr(In,
1278 In = Builder.CreateAdd(In,
1287 In = Builder.CreateShl(In,
1291 In = Builder.CreateAShr(In, ConstantInt::get(In->getType(),
1398 return BinaryOperator::CreateAShr(Builder.CreateShl(Res, ShAmt, "sext"),
1410 return BinaryOperator::CreateAShr(Builder.CreateShl(X, ShAmt), ShAmt);
1439 A = Builder.CreateShl(A, ShAmtV, CI.getName());
1566 Value *LHS = Builder.CreateFPTrunc(BO->getOperand(0), Ty);
1567 Value *RHS = Builder.CreateFPTrunc(BO->getOperand(1), Ty);
1580 Value *LHS = Builder.CreateFPTrunc(BO->getOperand(0), Ty);
1581 Value *RHS = Builder.CreateFPTrunc(BO->getOperand(1), Ty);
1593 Value *LHS = Builder.CreateFPTrunc(BO->getOperand(0), Ty);
1594 Value *RHS = Builder.CreateFPTrunc(BO->getOperand(1), Ty);
1607 LHS = Builder.CreateFPTrunc(BO->getOperand(0), LHSMinType);
1608 RHS = Builder.CreateFPTrunc(BO->getOperand(1), LHSMinType);
1610 LHS = Builder.CreateFPTrunc(BO->getOperand(0), RHSMinType);
1611 RHS = Builder.CreateFPTrunc(BO->getOperand(1), RHSMinType);
1614 Value *ExactResult = Builder.CreateFRemFMF(LHS, RHS, BO);
1625 Value *InnerTrunc = Builder.CreateFPTrunc(X, Ty);
1660 Value *InnerTrunc = Builder.CreateFPTrunc(Src, Ty);
1673 if (Instruction *I = shrinkInsertElt(FPT, Builder))
1768 Value *P = Builder.CreateZExtOrTrunc(CI.getOperand(0), Ty);
1818 Value *P = Builder.CreatePtrToInt(CI.getOperand(0), PtrTy);
1844 InVal = IC.Builder.CreateBitCast(InVal, SrcTy);
2024 Result = IC.Builder.CreateInsertElement(Result, Elements[i],
2025 IC.Builder.getInt32(i));
2050 auto *NewBC = IC.Builder.CreateBitCast(ExtElt->getVectorOperand(),
2223 Builder.SetInsertPoint(OldPN);
2224 PHINode *NewPN = Builder.CreatePHI(DestTy, OldPN->getNumOperands());
2237 Builder.SetInsertPoint(LI->getNextNode());
2238 NewV = Builder.CreateBitCast(LI, DestTy);
2265 Builder.SetInsertPoint(SI);
2267 cast<BitCastInst>(Builder.CreateBitCast(NewPN, SrcTy));
2340 SmallVector<Value *, 8> Idxs(NumZeros + 1, Builder.getInt32(0));
2363 Value *Elem = Builder.CreateBitCast(Src, DestVTy->getElementType());
2396 Builder.CreateExtractElement(Src,
2427 Value *LHS = Builder.CreateBitCast(ShufOp0, DestTy);
2428 Value *RHS = Builder.CreateBitCast(ShufOp1, DestTy);
2447 Value *ScalarX = Builder.CreateBitCast(ShufOp0, DestTy);
2460 if (Instruction *I = foldBitCastBitwiseLogic(CI, Builder))
2463 if (Instruction *I = foldBitCastSelect(CI, Builder))
2487 Value *NewBitCast = Builder.CreateBitCast(Src, MidTy);
lib/Transforms/InstCombine/InstCombineCompares.cpp 317 Idx = Builder.CreateTrunc(Idx, IntPtrTy);
325 return replaceInstUsesWith(ICI, Builder.getFalse());
334 Value *C1 = Builder.CreateICmpEQ(Idx, FirstTrueIdx);
336 Value *C2 = Builder.CreateICmpEQ(Idx, SecondTrueIdx);
345 return replaceInstUsesWith(ICI, Builder.getTrue());
354 Value *C1 = Builder.CreateICmpNE(Idx, FirstFalseIdx);
356 Value *C2 = Builder.CreateICmpNE(Idx, SecondFalseIdx);
368 Idx = Builder.CreateAdd(Idx, Offs);
382 Idx = Builder.CreateAdd(Idx, Offs);
405 Value *V = Builder.CreateIntCast(Idx, Ty, false);
406 V = Builder.CreateLShr(ConstantInt::get(Ty, MagicBitvector), V);
407 V = Builder.CreateAnd(ConstantInt::get(Ty, 1), V);
490 VariableIdx = IC.Builder.CreateTrunc(VariableIdx, IntPtrTy);
510 VariableIdx = IC.Builder.CreateIntCast(VariableIdx, IntPtrTy,
513 return IC.Builder.CreateAdd(VariableIdx, OffsetVal, "offset");
901 Base = Builder.CreateVectorSplat(NumElts, Base);
946 ROffset = Builder.CreateTrunc(ROffset, LHSIndexTy);
948 LOffset = Builder.CreateTrunc(LOffset, RHSIndexTy);
951 Value *Cmp = Builder.CreateICmp(ICmpInst::getSignedPredicate(Cond),
1318 InstCombiner::BuilderTy &Builder = IC.Builder;
1354 Value *Mask = Builder.CreateAdd(Y, Constant::getAllOnesValue(Y->getType()));
1355 Value *Masked = Builder.CreateAnd(X, Mask);
1504 return replaceInstUsesWith(Cmp, Builder.getFalse());
1506 return replaceInstUsesWith(Cmp, Builder.getTrue());
1519 return new ICmpInst(ICmpInst::ICMP_EQ, X, Builder.getInt(*EqC));
1521 return new ICmpInst(ICmpInst::ICMP_NE, X, Builder.getInt(*NeC));
1703 IsShl ? Builder.CreateLShr(And->getOperand(1), Shift->getOperand(1))
1704 : Builder.CreateShl(And->getOperand(1), Shift->getOperand(1));
1707 Value *NewAnd = Builder.CreateAnd(Shift->getOperand(0), NewShift);
1775 Value *NewAnd = Builder.CreateAnd(W, ZextC2, And->getName());
1809 NewOr = Builder.CreateOr(Builder.CreateShl(One, B, LShr->getName(),
1809 NewOr = Builder.CreateOr(Builder.CreateShl(One, B, LShr->getName(),
1814 Value *NewAnd = Builder.CreateAnd(A, NewOr, And->getName());
1868 Value *Trunc = Builder.CreateTrunc(X, NTy);
1903 Value *A = Builder.CreateAnd(OrOp0, ~C);
1916 Builder.CreateICmp(Pred, P, ConstantInt::getNullValue(P->getType()));
1918 Builder.CreateICmp(Pred, Q, ConstantInt::getNullValue(Q->getType()));
1930 Value *Cmp12 = Builder.CreateICmp(Pred, X1, X2);
1931 Value *Cmp34 = Builder.CreateICmp(Pred, X3, X4);
2104 Value *And = Builder.CreateAnd(X, Mask, Shl->getName() + ".mask");
2116 Value *And = Builder.CreateAnd(X, Mask, Shl->getName() + ".mask");
2126 Value *And = Builder.CreateAnd(X, (~C).lshr(ShiftAmt->getZExtValue()));
2135 Builder.CreateAnd(X, (~(C - 1)).lshr(ShiftAmt->getZExtValue()));
2156 return new ICmpInst(Pred, Builder.CreateTrunc(X, TruncTy), NewC);
2249 Value *And = Builder.CreateAnd(X, Mask, Shr->getName() + ".mask");
2280 Value *And = Builder.CreateAnd(SRem->getOperand(0), MaskC);
2445 return replaceInstUsesWith(Cmp, Builder.getFalse());
2458 return replaceInstUsesWith(Cmp, Builder.getTrue());
2473 return replaceInstUsesWith(Cmp, Builder.getTrue());
2475 return replaceInstUsesWith(Cmp, Builder.getFalse());
2480 return replaceInstUsesWith(Cmp, Builder.getFalse());
2482 return replaceInstUsesWith(Cmp, Builder.getTrue());
2545 return new ICmpInst(ICmpInst::ICMP_EQ, Builder.CreateOr(Y, C - 1), X);
2550 return new ICmpInst(ICmpInst::ICMP_NE, Builder.CreateOr(Y, C), X);
2609 return new ICmpInst(ICmpInst::ICMP_EQ, Builder.CreateAnd(X, -C),
2616 return new ICmpInst(ICmpInst::ICMP_NE, Builder.CreateAnd(X, ~C),
2709 Value *Cond = Builder.getFalse();
2711 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_SLT,
2711 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_SLT,
2714 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_EQ,
2714 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_EQ,
2717 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_SGT,
2717 Cond = Builder.CreateOr(Cond, Builder.CreateICmp(ICmpInst::ICMP_SGT,
2923 Value *NewRem = Builder.CreateURem(BOp0, BOp1, BO->getName());
2945 Value *Neg = Builder.CreateNeg(BOp1);
2984 Value *And = Builder.CreateAnd(BOp0, NotBOC);
3057 Cmp.setOperand(0, Builder.CreateAnd(II->getArgOperand(0), Mask1));
3083 Value *Or = Builder.CreateOr(II->getArgOperand(0), II->getArgOperand(1));
3084 return replaceInstUsesWith(Cmp, Builder.CreateICmp(
3146 Builder.CreateAnd(II->getArgOperand(0), Mask),
3155 Builder.CreateAnd(II->getArgOperand(0), Mask),
3231 Op1 = Builder.CreateICmp(I.getPredicate(), LHSI->getOperand(1), RHSC,
3234 Op2 = Builder.CreateICmp(I.getPredicate(), LHSI->getOperand(2), RHSC,
3639 BuilderTy::InsertPointGuard Guard(Builder);
3644 Builder.SetInsertPoint(Mul);
3648 CallInst *Call = Builder.CreateCall(F, {X, Y}, "umul");
3654 replaceInstUsesWith(*Mul, Builder.CreateExtractValue(Call, 0, "umul.val"));
3656 Value *Res = Builder.CreateExtractValue(Call, 1, "umul.ov");
3658 Res = Builder.CreateNot(Res, "umul.not.ov");
3684 return new ICmpInst(Pred, Builder.CreateNot(Op1), X);
3688 return new ICmpInst(Pred, X, Builder.CreateNot(Op0));
3830 ConstantInt *C3 = Builder.getInt(AP1 - AP2);
3831 Value *NewAdd = Builder.CreateNSWAdd(A, C3);
3834 ConstantInt *C3 = Builder.getInt(AP2 - AP1);
3835 Value *NewAdd = Builder.CreateNSWAdd(C, C3);
3969 Value *And1 = Builder.CreateAnd(BO0->getOperand(0), Mask);
3970 Value *And2 = Builder.CreateAnd(BO1->getOperand(0), Mask);
4022 if (Value *V = foldICmpWithLowBitMaskedVal(I, Builder))
4025 if (Value *V = foldICmpWithTruncSignExtendedVal(I, Builder))
4028 if (Value *V = foldShiftIntoShiftInAnotherHandOfAndInICmp(I, SQ, Builder))
4139 Constant *NC = Builder.getInt(C1->getValue() ^ C2->getValue());
4140 Value *Xor = Builder.CreateXor(C, NC);
4186 Op1 = Builder.CreateXor(X, Y);
4187 Op1 = Builder.CreateAnd(Op1, Z);
4204 return new ICmpInst(Pred, A, Builder.CreateTrunc(B, A->getType()));
4218 Value *Xor = Builder.CreateXor(A, B, I.getName() + ".unshifted");
4220 return new ICmpInst(NewPred, Xor, Builder.getInt(CmpVal));
4230 Value *Xor = Builder.CreateXor(A, B, I.getName() + ".unshifted");
4232 Value *And = Builder.CreateAnd(Xor, Builder.getInt(AndVal),
4232 Value *And = Builder.CreateAnd(Xor, Builder.getInt(AndVal),
4257 Value *Mask = Builder.CreateAnd(A, Builder.getInt(MaskV));
4257 Value *Mask = Builder.CreateAnd(A, Builder.getInt(MaskV));
4258 return new ICmpInst(Pred, Mask, Builder.getInt(CmpV));
4289 CallInst *CtPop = Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, A);
4421 NewOp1 = Builder.CreateBitCast(NewOp1, Op0Src->getType());
4431 return foldICmpWithZextOrSext(ICmp, Builder);
4480 Builder.SetInsertPoint(&OrigI);
4484 Overflow = Builder.getFalse();
4493 Result = Builder.CreateBinOp(BinaryOp, LHS, RHS);
4495 Overflow = Builder.getTrue();
4498 Result = Builder.CreateBinOp(BinaryOp, LHS, RHS);
4500 Overflow = Builder.getFalse();
4675 InstCombiner::BuilderTy &Builder = IC.Builder;
5415 if (Instruction *Res = canonicalizeICmpBool(I, Builder))
5506 if (Instruction *Res = foldICmpBitCast(I, Builder))
5523 return new ICmpInst(I.getInversePredicate(), Builder.CreateAnd(A, B),
5593 if (Instruction *Res = foldICmpWithHighBitMask(I, Builder))
5597 if (Instruction *Res = foldVectorCmp(I, Builder))
5632 return replaceInstUsesWith(I, Builder.getFalse());
5635 return replaceInstUsesWith(I, Builder.getTrue());
5701 return replaceInstUsesWith(I, Builder.getTrue());
5703 return replaceInstUsesWith(I, Builder.getFalse());
5721 return replaceInstUsesWith(I, Builder.getTrue());
5722 return replaceInstUsesWith(I, Builder.getFalse());
5733 return replaceInstUsesWith(I, Builder.getTrue());
5734 return replaceInstUsesWith(I, Builder.getFalse());
5746 return replaceInstUsesWith(I, Builder.getTrue());
5747 return replaceInstUsesWith(I, Builder.getFalse());
5757 return replaceInstUsesWith(I, Builder.getTrue());
5758 return replaceInstUsesWith(I, Builder.getFalse());
5780 return replaceInstUsesWith(I, Builder.getTrue());
5782 return replaceInstUsesWith(I, Builder.getFalse());
5787 return replaceInstUsesWith(I, Builder.getFalse());
5799 return replaceInstUsesWith(I, Builder.getFalse());
5812 return replaceInstUsesWith(I, Builder.getTrue());
5824 return replaceInstUsesWith(I, Builder.getTrue());
6109 if (Instruction *Res = foldVectorCmp(I, Builder))
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 190 Value *V = IC.Builder.getInt32(1);
199 AllocaInst *New = IC.Builder.CreateAlloca(NewTy, nullptr, AI.getName());
232 Value *V = IC.Builder.CreateIntCast(AI.getArraySize(), IntPtrTy, false);
463 NewPtr = IC.Builder.CreateBitCast(Ptr, NewTy->getPointerTo(AS));
465 LoadInst *NewLoad = IC.Builder.CreateAlignedLoad(
484 StoreInst *NewStore = IC.Builder.CreateAlignedStore(
485 V, IC.Builder.CreateBitCast(Ptr, V->getType()->getPointerTo(AS)),
605 IC.Builder.SetInsertPoint(SI);
656 return IC.replaceInstUsesWith(LI, IC.Builder.CreateInsertValue(
681 auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices),
684 auto *L = IC.Builder.CreateAlignedLoad(ST->getElementType(i), Ptr,
690 V = IC.Builder.CreateInsertValue(V, L, i);
705 return IC.replaceInstUsesWith(LI, IC.Builder.CreateInsertValue(
733 auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices),
735 auto *L = IC.Builder.CreateAlignedLoad(
740 V = IC.Builder.CreateInsertValue(V, L, i);
988 LI, Builder.CreateBitOrPointerCast(AvailableVal, LI.getType(),
1029 Builder.CreateLoad(LI.getType(), SI->getOperand(1),
1032 Builder.CreateLoad(LI.getType(), SI->getOperand(2),
1185 V = IC.Builder.CreateExtractValue(V, 0);
1214 auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices),
1216 auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
1218 llvm::Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
1231 V = IC.Builder.CreateExtractValue(V, 0);
1264 auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices),
1266 auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
1268 Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
1336 IC.Builder.SetInsertPoint(LI);
1342 IC.Builder.SetInsertPoint(USI);
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp 63 A = IC.Builder.CreateSub(A, B);
64 return IC.Builder.CreateShl(One, A);
245 Sub = Builder.CreateSub(X, Y, "suba");
247 Sub = Builder.CreateSub(Builder.CreateNeg(C1), Y, "subc");
247 Sub = Builder.CreateSub(Builder.CreateNeg(C1), Y, "subc");
260 if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))
269 Value *Mul = Builder.CreateMul(C1, Op1);
273 return BinaryOperator::CreateAdd(Builder.CreateMul(X, Op1), Mul);
296 return BinaryOperator::CreateNeg(Builder.CreateMul(X, Y));
324 Value *Rem = Builder.CreateBinOp(RemOpc, X, DivOp1);
372 return BinaryOperator::CreateAnd(Builder.CreateAShr(X, *C), Op1);
374 return BinaryOperator::CreateAnd(Builder.CreateAShr(X, *C), Op0);
408 if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))
464 Value *XC = Builder.CreateFMulFMF(X, C, &I);
470 Value *XC = Builder.CreateFMulFMF(X, C, &I);
479 Value *NewFMul = Builder.CreateFMulFMF(X, Z, &I);
489 Value *XY = Builder.CreateFMulFMF(X, Y, &I);
490 Value *Sqrt = Builder.CreateUnaryIntrinsic(Intrinsic::sqrt, XY, &I);
502 Value *XX = Builder.CreateFMulFMF(X, X, &I);
508 Value *XX = Builder.CreateFMulFMF(X, X, &I);
518 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
519 Value *Exp = Builder.CreateUnaryIntrinsic(Intrinsic::exp, XY, &I);
528 Value *XY = Builder.CreateFAddFMF(X, Y, &I);
529 Value *Exp2 = Builder.CreateUnaryIntrinsic(Intrinsic::exp2, XY, &I);
542 Value *XX = Builder.CreateFMulFMF(Op1, Op1, &I);
547 Value *XX = Builder.CreateFMulFMF(Op0, Op0, &I);
568 Value *LogXTimesY = Builder.CreateFMulFMF(Log2, Y, &I);
770 Value *Inc = Builder.CreateAdd(Op1, Op0);
771 Value *Cmp = Builder.CreateICmpULT(Inc, ConstantInt::get(Ty, 3));
776 return new ZExtInst(Builder.CreateICmpEQ(Op1, Op0), Ty);
872 N = IC.Builder.CreateAdd(N, Log2Base);
874 N = IC.Builder.CreateZExt(N, Op1->getType());
987 Value *Cmp = Builder.CreateICmpUGE(Op0, Op1);
992 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
996 if (Instruction *NarrowDiv = narrowUDivURem(I, Builder))
1070 return new ZExtInst(Builder.CreateICmpEQ(Op0, Op1), I.getType());
1093 Value *NarrowOp = Builder.CreateSDiv(Op0Src, NarrowDivisor);
1113 Builder.CreateSDiv(X, Y, I.getName(), I.isExact()));
1233 Value *YZ = Builder.CreateFMulFMF(Y, Op1, &I);
1239 Value *YZ = Builder.CreateFMulFMF(Y, Op0, &I);
1294 Value *V = Builder.CreateBinaryIntrinsic(
1356 if (Instruction *NarrowRem = narrowUDivURem(I, Builder))
1366 Value *Add = Builder.CreateAdd(Op1, N1);
1372 return CastInst::CreateZExtOrBitCast(Builder.CreateICmpNE(Op1, Op0), Ty);
1376 Value *Cmp = Builder.CreateICmpULT(Op0, Op1);
1377 Value *Sub = Builder.CreateSub(Op0, Op1);
1387 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
1420 return BinaryOperator::CreateNSWNeg(Builder.CreateSRem(X, Y));
lib/Transforms/InstCombine/InstCombinePHI.cpp 1084 Builder.SetInsertPoint(Pred->getTerminator());
1087 Res = Builder.CreateLShr(Res, ConstantInt::get(InVal->getType(),
1089 Res = Builder.CreateTrunc(Res, Ty, "extract.t");
lib/Transforms/InstCombine/InstCombineSelect.cpp 330 Builder.CreateSelect(Cond, TI->getOperand(0), FI->getOperand(0),
340 Value *NewSel = Builder.CreateSelect(Cond, X, Y, SI.getName() + ".v", &SI);
394 Value *NewSI = Builder.CreateSelect(Cond, OtherOpT, OtherOpF,
447 Value *NewSel = Builder.CreateSelect(SI.getCondition(), OOp, C);
478 Value *NewSel = Builder.CreateSelect(SI.getCondition(), C, OOp);
1388 if (Instruction *NewSel = canonicalizeMinMaxWithConstant(SI, *ICI, Builder))
1391 if (Instruction *NewAbs = canonicalizeAbsNabs(SI, *ICI, Builder))
1394 if (Instruction *NewAbs = canonicalizeClampLike(SI, *ICI, Builder))
1398 tryToReuseConstantFromSelectInComparison(SI, *ICI, Builder))
1403 if (Value *V = foldSelectICmpAnd(SI, ICI, Builder))
1455 V = Builder.CreateAnd(X, ~(*Y));
1459 V = Builder.CreateAnd(X, ~(*Y));
1463 V = Builder.CreateOr(X, *Y);
1467 V = Builder.CreateOr(X, *Y);
1475 foldSelectICmpAndAnd(SI.getType(), ICI, TrueVal, FalseVal, Builder))
1478 if (Instruction *V = foldSelectCtlzToCttz(ICI, TrueVal, FalseVal, Builder))
1481 if (Value *V = foldSelectICmpAndOr(ICI, TrueVal, FalseVal, Builder))
1484 if (Value *V = foldSelectICmpLshrAshr(ICI, TrueVal, FalseVal, Builder))
1487 if (Value *V = foldSelectCttzCtlz(ICI, TrueVal, FalseVal, Builder))
1490 if (Value *V = canonicalizeSaturatedSubtract(ICI, TrueVal, FalseVal, Builder))
1493 if (Value *V = canonicalizeSaturatedAdd(ICI, TrueVal, FalseVal, Builder))
1608 Builder.CreateSelect(SI->getCondition(), SI->getFalseValue(),
1647 NotA = Builder.CreateNot(A);
1649 NotB = Builder.CreateNot(B);
1651 NotC = Builder.CreateNot(C);
1653 Value *NewInner = createMinMax(Builder, getInverseMinMaxFlavor(SPF1), NotA,
1655 Value *NewOuter = Builder.CreateNot(
1656 createMinMax(Builder, getInverseMinMaxFlavor(SPF2), NewInner, NotC));
1772 Value *NewSel = Builder.CreateSelect(Cond, X, TruncCVal, "narrow", &Sel);
2073 Value *AT = Builder.CreateSExt(A, NewTy);
2074 Value *BT = Builder.CreateSExt(B, NewTy);
2075 Value *Sat = Builder.CreateCall(F, {AT, BT});
2219 if (Instruction *I = canonicalizeScalarSelectOfVecs(SI, Builder))
2247 Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
2256 Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
2293 Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
2299 Value *NotCond = Builder.CreateNot(CondVal, "not." + CondVal->getName());
2314 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
2315 Builder.setFastMathFlags(FCI->getFastMathFlags());
2316 Value *NewCond = Builder.CreateFCmp(InvPred, TrueVal, FalseVal,
2332 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
2333 Builder.setFastMathFlags(FCI->getFastMathFlags());
2334 Value *NewCond = Builder.CreateFCmp(InvPred, FalseVal, TrueVal,
2357 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, FalseVal, FSub);
2365 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, TrueVal, FSub);
2378 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, FalseVal, FNeg);
2390 Value *Fabs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, TrueVal, FNeg);
2399 if (Instruction *Add = foldAddSubSelect(SI, Builder))
2451 Cmp = Builder.CreateICmp(MinMaxPred, LHS, RHS);
2453 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
2456 Builder.setFastMathFlags(FMF);
2457 Cmp = Builder.CreateFCmp(MinMaxPred, LHS, RHS);
2460 Value *NewSI = Builder.CreateSelect(Cmp, LHS, RHS, SI.getName(), &SI);
2464 Value *NewCast = Builder.CreateCast(CastOp, NewSI, SelType);
2478 Value *B = Builder.CreateNot(Y);
2479 Value *NewMinMax = createMinMax(Builder, getInverseMinMaxFlavor(SPF),
2500 if (Instruction *I = moveAddAfterMinMax(SPF, LHS, RHS, Builder))
2503 if (Instruction *I = factorizeMinMaxTree(SPF, LHS, RHS, Builder))
2516 SI, Builder.CreateBinaryIntrinsic(Intrinsic::maxnum, X, Y, &SI));
2520 SI, Builder.CreateBinaryIntrinsic(Intrinsic::minnum, X, Y, &SI));
2544 Value *And = Builder.CreateAnd(CondVal, TrueSI->getCondition());
2562 Value *Or = Builder.CreateOr(CondVal, FalseSI->getCondition());
2659 if (Instruction *BitCastSel = foldSelectCmpBitcasts(SI, Builder))
lib/Transforms/InstCombine/InstCombineShifts.cpp 134 Builder.Insert(NewShift);
293 Value *NewExt = Builder.CreateZExt(Y, I.getType(), Op1->getName());
323 I.getOpcode(), Builder.CreateBinOp(I.getOpcode(), Op0, C), A);
332 Value *Rem = Builder.CreateAnd(A, ConstantInt::get(I.getType(), *B - 1),
536 V = IC.Builder.CreateShl(C, NumBits);
538 V = IC.Builder.CreateLShr(C, NumBits);
565 IC.Builder);
647 Value *NSh = Builder.CreateBinOp(I.getOpcode(), TrOp, ShAmt, I.getName());
669 Value *And = Builder.CreateAnd(NSh,
695 Builder.CreateShl(Op0BO->getOperand(0), Op1, Op0BO->getName());
697 Value *X = Builder.CreateBinOp(Op0BO->getOpcode(), YS, V1,
715 Builder.CreateShl(Op0BO->getOperand(0), Op1, Op0BO->getName());
717 Value *XM = Builder.CreateAnd(V1, ConstantExpr::getShl(CC, Op1),
730 Builder.CreateShl(Op0BO->getOperand(1), Op1, Op0BO->getName());
732 Value *X = Builder.CreateBinOp(Op0BO->getOpcode(), V1, YS,
749 Builder.CreateShl(Op0BO->getOperand(1), Op1, Op0BO->getName());
751 Value *XM = Builder.CreateAnd(V1, ConstantExpr::getShl(CC, Op1),
771 Builder.CreateBinOp(I.getOpcode(), Op0BO->getOperand(0), Op1);
787 Value *NewShift = Builder.CreateShl(Op0BO->getOperand(1), Op1);
815 Builder.CreateBinOp(I.getOpcode(), FalseVal, Op1);
816 Value *NewOp = Builder.CreateBinOp(TBO->getOpcode(), NewShift,
834 Builder.CreateBinOp(I.getOpcode(), TrueVal, Op1);
835 Value *NewOp = Builder.CreateBinOp(FBO->getOpcode(), NewShift,
858 if (Instruction *V = dropRedundantMaskingOfLeftShiftInput(&I, Q, Builder))
876 return new ZExtInst(Builder.CreateShl(X, ShAmt), Ty);
935 Value *Mask = Builder.CreateShl(AllOnes, Op1);
994 Value *Cmp = Builder.CreateICmpEQ(II->getArgOperand(0), RHS);
1011 Value *NewLShr = Builder.CreateLShr(X, ShiftDiff, "", I.isExact());
1025 Value *NewShl = Builder.CreateShl(X, ShiftDiff);
1040 Value *NewLShr = Builder.CreateLShr(X, ShAmt);
1055 Value *NewLShr = Builder.CreateLShr(X, SrcTyBitWidth - 1);
1064 Value *AShr = Builder.CreateAShr(X, NewShAmt);
1089 Value *Mask = Builder.CreateLShr(AllOnes, Op1);
1161 Builder.Insert(NewAShr);
1227 Value *NewSh = Builder.CreateAShr(X, ConstantInt::get(SrcTy, ShAmt));
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 1049 IRBuilderBase::InsertPointGuard Guard(Builder);
1050 Builder.SetInsertPoint(II);
1052 CallInst *NewCall = Builder.CreateCall(NewIntrin, Args);
1057 return Builder.CreateInsertElement(UndefValue::get(II->getType()), NewCall,
1071 Builder.CreateShuffleVector(NewCall, UndefValue::get(NewTy), EltMask);
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 366 if (Instruction *I = foldBitcastExtElt(EI, Builder, DL.isBigEndian()))
380 Value *E0 = Builder.CreateExtractElement(X, Index);
381 Value *E1 = Builder.CreateExtractElement(Y, Index);
390 Value *E0 = Builder.CreateExtractElement(X, Index);
391 Value *E1 = Builder.CreateExtractElement(Y, Index);
434 Value *EE = Builder.CreateExtractElement(CI->getOperand(0), Index);
1045 Value *NewInsElt = Builder.CreateInsertElement(VecSrc, ScalarSrc, IdxOp);
1109 if (Instruction *NewInsElt = hoistInsEltConst(IE, Builder))
1924 if (Instruction *I = canonicalizeInsertSplat(SVI, Builder))
1927 if (Instruction *I = foldSelectShuffle(SVI, Builder, DL))
1930 if (Instruction *I = narrowVectorSelect(SVI, Builder))
2032 V = Builder.CreateShuffleVector(V, UndefValue::get(V->getType()),
2044 : Builder.CreateBitCast(V, CastSrcTy, SVI.getName() + ".bc");
2047 auto *Ext = Builder.CreateExtractElement(
lib/Transforms/InstCombine/InstructionCombining.cpp 147 return llvm::EmitGEPOffset(&Builder, DL, GEP);
567 V = Builder.CreateBinOp(TopLevelOpcode, B, D, RHS->getName());
569 SimplifiedInst = Builder.CreateBinOp(InnerOpcode, A, V);
587 V = Builder.CreateBinOp(TopLevelOpcode, A, C, LHS->getName());
589 SimplifiedInst = Builder.CreateBinOp(InnerOpcode, V, B);
696 C = Builder.CreateBinOp(InnerOpcode, L, R);
705 C = Builder.CreateBinOp(TopLevelOpcode, B, C);
714 C = Builder.CreateBinOp(TopLevelOpcode, A, C);
733 A = Builder.CreateBinOp(InnerOpcode, L, R);
742 A = Builder.CreateBinOp(TopLevelOpcode, A, C);
751 A = Builder.CreateBinOp(TopLevelOpcode, A, B);
772 BuilderTy::FastMathFlagGuard Guard(Builder);
775 Builder.setFastMathFlags(FMF);
781 SI = Builder.CreateSelect(A, V2, V1);
783 SI = Builder.CreateSelect(A, V2, Builder.CreateBinOp(Opcode, C, E));
783 SI = Builder.CreateSelect(A, V2, Builder.CreateBinOp(Opcode, C, E));
785 SI = Builder.CreateSelect(A, Builder.CreateBinOp(Opcode, B, D), V1);
785 SI = Builder.CreateSelect(A, Builder.CreateBinOp(Opcode, B, D), V1);
902 Value *NewTV = foldOperationIntoSelectOperand(Op, TV, Builder);
903 Value *NewFV = foldOperationIntoSelectOperand(Op, FV, Builder);
993 Builder.SetInsertPoint(NonConstBB->getTerminator());
1025 Builder.SetInsertPoint(ThisBB->getTerminator());
1026 InV = Builder.CreateSelect(PN->getIncomingValue(i), TrueVInPred,
1038 InV = Builder.CreateICmp(CI->getPredicate(), PN->getIncomingValue(i),
1041 InV = Builder.CreateFCmp(CI->getPredicate(), PN->getIncomingValue(i),
1048 Builder);
1059 InV = Builder.CreateCast(CI->getOpcode(), PN->getIncomingValue(i),
1426 Value *NewBO0 = Builder.CreateBinOp(Opcode, L0, R0);
1429 Value *NewBO1 = Builder.CreateBinOp(Opcode, L1, R1);
1442 Value *XY = Builder.CreateBinOp(Opcode, X, Y);
1608 Value *NarrowBO = Builder.CreateBinOp(BO.getOpcode(), X, Y, "narrow");
1679 *I = Builder.CreateIntCast(*I, NewIndexType, true);
1773 IRBuilderBase::InsertPointGuard Guard(Builder);
1774 Builder.SetInsertPoint(PN);
1775 NewPN = Builder.CreatePHI(Op1->getOperand(DI)->getType(),
1838 Builder.SetInsertPoint(cast<Instruction>(PtrOp));
1840 Builder.CreateGEP(GEPEltType, SO0, GO1, Src->getName()));
1942 Value *PtrToInt = Builder.CreatePtrToInt(PtrOp, Index->getType());
1943 Value *NewSub = Builder.CreateSub(PtrToInt, Index->getOperand(1));
1995 return new AddrSpaceCastInst(Builder.Insert(Res), GEPType);
2023 ? Builder.CreateInBoundsGEP(StrippedPtrEltTy, StrippedPtr,
2025 : Builder.CreateGEP(StrippedPtrEltTy, StrippedPtr, Idx,
2042 ? Builder.CreateInBoundsGEP(StrippedPtrEltTy, StrippedPtr, Idx,
2044 : Builder.CreateGEP(StrippedPtrEltTy, StrippedPtr, Idx,
2078 ? Builder.CreateInBoundsGEP(StrippedPtrEltTy, StrippedPtr,
2080 : Builder.CreateGEP(StrippedPtrEltTy, StrippedPtr, NewIdx,
2122 ? Builder.CreateInBoundsGEP(StrippedPtrEltTy, StrippedPtr,
2124 : Builder.CreateGEP(StrippedPtrEltTy, StrippedPtr, Off,
2173 ? Builder.CreateInBoundsGEP(SrcEltType, SrcOp, {Ops[1], Ops[2]})
2174 : Builder.CreateGEP(SrcEltType, SrcOp, {Ops[1], Ops[2]});
2221 ? Builder.CreateInBoundsGEP(SrcEltType, SrcOp, NewIndices)
2222 : Builder.CreateGEP(SrcEltType, SrcOp, NewIndices);
2630 Builder.SetInsertPoint(&SI);
2631 Value *NewCond = Builder.CreateTrunc(Cond, Ty, "trunc");
2688 Value *NewEV = Builder.CreateExtractValue(IV->getAggregateOperand(),
2739 Indices.push_back(Builder.getInt32(0));
2742 Indices.push_back(Builder.getInt32(*I));
2746 Builder.SetInsertPoint(L);
2747 Value *GEP = Builder.CreateInBoundsGEP(L->getType(),
2749 Instruction *NL = Builder.CreateLoad(EV.getType(), GEP);
3301 Builder.SetInsertPoint(I);
3302 Builder.SetCurrentDebugLocation(I->getDebugLoc());