Lines Matching refs:Builder
28 /// remainder, which will have the sign of the dividend. Builder's insert point
30 /// instruction. This will generate a urem in the process, and Builder's insert
34 IRBuilder<> &Builder) {
39 Shift = Builder.getInt64(63);
42 Shift = Builder.getInt32(31);
57 Value *DividendSign = Builder.CreateAShr(Dividend, Shift);
58 Value *DivisorSign = Builder.CreateAShr(Divisor, Shift);
59 Value *DvdXor = Builder.CreateXor(Dividend, DividendSign);
60 Value *DvsXor = Builder.CreateXor(Divisor, DivisorSign);
61 Value *UDividend = Builder.CreateSub(DvdXor, DividendSign);
62 Value *UDivisor = Builder.CreateSub(DvsXor, DivisorSign);
63 Value *URem = Builder.CreateURem(UDividend, UDivisor);
64 Value *Xored = Builder.CreateXor(URem, DividendSign);
65 Value *SRem = Builder.CreateSub(Xored, DividendSign);
68 Builder.SetInsertPoint(URemInst);
75 /// remainder. Builder's insert point should be pointing where the caller wants
77 /// the process, and Builder's insert point will be pointing at the udiv (if
80 IRBuilder<> &Builder) {
88 Value *Quotient = Builder.CreateUDiv(Dividend, Divisor);
89 Value *Product = Builder.CreateMul(Divisor, Quotient);
90 Value *Remainder = Builder.CreateSub(Dividend, Product);
93 Builder.SetInsertPoint(UDiv);
99 /// towards 0. Builder's insert point should be pointing where the caller wants
101 /// the process, and Builder's insert point will be pointing at the udiv (if
104 IRBuilder<> &Builder) {
111 Shift = Builder.getInt64(63);
114 Shift = Builder.getInt32(31);
130 Value *Tmp = Builder.CreateAShr(Dividend, Shift);
131 Value *Tmp1 = Builder.CreateAShr(Divisor, Shift);
132 Value *Tmp2 = Builder.CreateXor(Tmp, Dividend);
133 Value *U_Dvnd = Builder.CreateSub(Tmp2, Tmp);
134 Value *Tmp3 = Builder.CreateXor(Tmp1, Divisor);
135 Value *U_Dvsr = Builder.CreateSub(Tmp3, Tmp1);
136 Value *Q_Sgn = Builder.CreateXor(Tmp1, Tmp);
137 Value *Q_Mag = Builder.CreateUDiv(U_Dvnd, U_Dvsr);
138 Value *Tmp4 = Builder.CreateXor(Q_Mag, Q_Sgn);
139 Value *Q = Builder.CreateSub(Tmp4, Q_Sgn);
142 Builder.SetInsertPoint(UDiv);
148 /// Returns the quotient, rounded towards 0. Builder's insert point should
151 IRBuilder<> &Builder) {
166 Zero = Builder.getInt64(0);
167 One = Builder.getInt64(1);
169 MSB = Builder.getInt64(63);
172 Zero = Builder.getInt32(0);
173 One = Builder.getInt32(1);
175 MSB = Builder.getInt32(31);
178 ConstantInt *True = Builder.getTrue();
180 BasicBlock *IBB = Builder.GetInsertBlock();
217 BasicBlock *SpecialCases = Builder.GetInsertBlock();
219 BasicBlock *End = SpecialCases->splitBasicBlock(Builder.GetInsertPoint(),
221 BasicBlock *LoopExit = BasicBlock::Create(Builder.getContext(),
223 BasicBlock *DoWhile = BasicBlock::Create(Builder.getContext(),
225 BasicBlock *Preheader = BasicBlock::Create(Builder.getContext(),
227 BasicBlock *BB1 = BasicBlock::Create(Builder.getContext(),
250 Builder.SetInsertPoint(SpecialCases);
251 Value *Ret0_1 = Builder.CreateICmpEQ(Divisor, Zero);
252 Value *Ret0_2 = Builder.CreateICmpEQ(Dividend, Zero);
253 Value *Ret0_3 = Builder.CreateOr(Ret0_1, Ret0_2);
254 Value *Tmp0 = Builder.CreateCall(CTLZ, {Divisor, True});
255 Value *Tmp1 = Builder.CreateCall(CTLZ, {Dividend, True});
256 Value *SR = Builder.CreateSub(Tmp0, Tmp1);
257 Value *Ret0_4 = Builder.CreateICmpUGT(SR, MSB);
258 Value *Ret0 = Builder.CreateOr(Ret0_3, Ret0_4);
259 Value *RetDividend = Builder.CreateICmpEQ(SR, MSB);
260 Value *RetVal = Builder.CreateSelect(Ret0, Zero, Dividend);
261 Value *EarlyRet = Builder.CreateOr(Ret0, RetDividend);
262 Builder.CreateCondBr(EarlyRet, End, BB1);
270 Builder.SetInsertPoint(BB1);
271 Value *SR_1 = Builder.CreateAdd(SR, One);
272 Value *Tmp2 = Builder.CreateSub(MSB, SR);
273 Value *Q = Builder.CreateShl(Dividend, Tmp2);
274 Value *SkipLoop = Builder.CreateICmpEQ(SR_1, Zero);
275 Builder.CreateCondBr(SkipLoop, LoopExit, Preheader);
281 Builder.SetInsertPoint(Preheader);
282 Value *Tmp3 = Builder.CreateLShr(Dividend, SR_1);
283 Value *Tmp4 = Builder.CreateAdd(Divisor, NegOne);
284 Builder.CreateBr(DoWhile);
304 Builder.SetInsertPoint(DoWhile);
305 PHINode *Carry_1 = Builder.CreatePHI(DivTy, 2);
306 PHINode *SR_3 = Builder.CreatePHI(DivTy, 2);
307 PHINode *R_1 = Builder.CreatePHI(DivTy, 2);
308 PHINode *Q_2 = Builder.CreatePHI(DivTy, 2);
309 Value *Tmp5 = Builder.CreateShl(R_1, One);
310 Value *Tmp6 = Builder.CreateLShr(Q_2, MSB);
311 Value *Tmp7 = Builder.CreateOr(Tmp5, Tmp6);
312 Value *Tmp8 = Builder.CreateShl(Q_2, One);
313 Value *Q_1 = Builder.CreateOr(Carry_1, Tmp8);
314 Value *Tmp9 = Builder.CreateSub(Tmp4, Tmp7);
315 Value *Tmp10 = Builder.CreateAShr(Tmp9, MSB);
316 Value *Carry = Builder.CreateAnd(Tmp10, One);
317 Value *Tmp11 = Builder.CreateAnd(Tmp10, Divisor);
318 Value *R = Builder.CreateSub(Tmp7, Tmp11);
319 Value *SR_2 = Builder.CreateAdd(SR_3, NegOne);
320 Value *Tmp12 = Builder.CreateICmpEQ(SR_2, Zero);
321 Builder.CreateCondBr(Tmp12, LoopExit, DoWhile);
329 Builder.SetInsertPoint(LoopExit);
330 PHINode *Carry_2 = Builder.CreatePHI(DivTy, 2);
331 PHINode *Q_3 = Builder.CreatePHI(DivTy, 2);
332 Value *Tmp13 = Builder.CreateShl(Q_3, One);
333 Value *Q_4 = Builder.CreateOr(Carry_2, Tmp13);
334 Builder.CreateBr(End);
339 Builder.SetInsertPoint(End, End->begin());
340 PHINode *Q_5 = Builder.CreatePHI(DivTy, 2);
380 IRBuilder<> Builder(Rem);
390 Rem->getOperand(1), Builder);
393 bool IsInsertPoint = Rem->getIterator() == Builder.GetInsertPoint();
400 // Builder insertion point was unchanged
404 BinaryOperator *BO = dyn_cast<BinaryOperator>(Builder.GetInsertPoint());
410 Builder);
417 if (BinaryOperator *UDiv = dyn_cast<BinaryOperator>(Builder.GetInsertPoint())) {
438 IRBuilder<> Builder(Div);
449 Div->getOperand(1), Builder);
452 bool IsInsertPoint = Div->getIterator() == Builder.GetInsertPoint();
459 // Builder insertion point was unchanged
463 BinaryOperator *BO = dyn_cast<BinaryOperator>(Builder.GetInsertPoint());
470 Builder);
503 IRBuilder<> Builder(Rem);
509 Type *Int32Ty = Builder.getInt32Ty();
512 ExtDividend = Builder.CreateSExt(Rem->getOperand(0), Int32Ty);
513 ExtDivisor = Builder.CreateSExt(Rem->getOperand(1), Int32Ty);
514 ExtRem = Builder.CreateSRem(ExtDividend, ExtDivisor);
516 ExtDividend = Builder.CreateZExt(Rem->getOperand(0), Int32Ty);
517 ExtDivisor = Builder.CreateZExt(Rem->getOperand(1), Int32Ty);
518 ExtRem = Builder.CreateURem(ExtDividend, ExtDivisor);
520 Trunc = Builder.CreateTrunc(ExtRem, RemTy);
551 IRBuilder<> Builder(Rem);
557 Type *Int64Ty = Builder.getInt64Ty();
560 ExtDividend = Builder.CreateSExt(Rem->getOperand(0), Int64Ty);
561 ExtDivisor = Builder.CreateSExt(Rem->getOperand(1), Int64Ty);
562 ExtRem = Builder.CreateSRem(ExtDividend, ExtDivisor);
564 ExtDividend = Builder.CreateZExt(Rem->getOperand(0), Int64Ty);
565 ExtDivisor = Builder.CreateZExt(Rem->getOperand(1), Int64Ty);
566 ExtRem = Builder.CreateURem(ExtDividend, ExtDivisor);
568 Trunc = Builder.CreateTrunc(ExtRem, RemTy);
600 IRBuilder<> Builder(Div);
606 Type *Int32Ty = Builder.getInt32Ty();
609 ExtDividend = Builder.CreateSExt(Div->getOperand(0), Int32Ty);
610 ExtDivisor = Builder.CreateSExt(Div->getOperand(1), Int32Ty);
611 ExtDiv = Builder.CreateSDiv(ExtDividend, ExtDivisor);
613 ExtDividend = Builder.CreateZExt(Div->getOperand(0), Int32Ty);
614 ExtDivisor = Builder.CreateZExt(Div->getOperand(1), Int32Ty);
615 ExtDiv = Builder.CreateUDiv(ExtDividend, ExtDivisor);
617 Trunc = Builder.CreateTrunc(ExtDiv, DivTy);
649 IRBuilder<> Builder(Div);
655 Type *Int64Ty = Builder.getInt64Ty();
658 ExtDividend = Builder.CreateSExt(Div->getOperand(0), Int64Ty);
659 ExtDivisor = Builder.CreateSExt(Div->getOperand(1), Int64Ty);
660 ExtDiv = Builder.CreateSDiv(ExtDividend, ExtDivisor);
662 ExtDividend = Builder.CreateZExt(Div->getOperand(0), Int64Ty);
663 ExtDivisor = Builder.CreateZExt(Div->getOperand(1), Int64Ty);
664 ExtDiv = Builder.CreateUDiv(ExtDividend, ExtDivisor);
666 Trunc = Builder.CreateTrunc(ExtDiv, DivTy);