Lines Matching refs:DT
72 static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
79 if (DT)
80 return DT->dominates(I, P);
98 const DominatorTree *DT, unsigned MaxRecurse) {
110 if (Value *L = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse))
111 if (Value *R = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) {
120 if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT,
134 if (Value *L = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse))
135 if (Value *R = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse)) {
144 if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT,
161 const DominatorTree *DT, unsigned MaxRecurse) {
185 if (Value *V = SimplifyBinOp(Opcode, B, DD, TD, DT, MaxRecurse)) {
194 if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, TD, DT, MaxRecurse)) {
208 if (Value *V = SimplifyBinOp(Opcode, A, CC, TD, DT, MaxRecurse)) {
217 if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, TD, DT, MaxRecurse)) {
231 const DominatorTree *DT,
250 if (Value *V = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) {
255 if (Value *W = SimplifyBinOp(Opcode, A, V, TD, DT, MaxRecurse)) {
269 if (Value *V = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse)) {
274 if (Value *W = SimplifyBinOp(Opcode, V, C, TD, DT, MaxRecurse)) {
292 if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) {
297 if (Value *W = SimplifyBinOp(Opcode, V, B, TD, DT, MaxRecurse)) {
311 if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) {
316 if (Value *W = SimplifyBinOp(Opcode, B, V, TD, DT, MaxRecurse)) {
332 const DominatorTree *DT,
350 TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, TD, DT, MaxRecurse);
351 FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, TD, DT, MaxRecurse);
353 TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), TD, DT, MaxRecurse);
354 FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), TD, DT, MaxRecurse);
406 const DominatorTree *DT,
422 if (Value *TCmp = SimplifyCmpInst(Pred, SI->getTrueValue(), RHS, TD, DT,
425 if (Value *FCmp = SimplifyCmpInst(Pred, SI->getFalseValue(), RHS, TD, DT,
436 if (Value *V = SimplifyAndInst(Cond, TCmp, TD, DT, MaxRecurse))
441 if (Value *V = SimplifyOrInst(Cond, FCmp, TD, DT, MaxRecurse))
448 TD, DT, MaxRecurse))
461 const TargetData *TD, const DominatorTree *DT,
471 if (!ValueDominatesPHI(RHS, PI, DT))
477 if (!ValueDominatesPHI(LHS, PI, DT))
488 SimplifyBinOp(Opcode, Incoming, RHS, TD, DT, MaxRecurse) :
489 SimplifyBinOp(Opcode, LHS, Incoming, TD, DT, MaxRecurse);
505 const TargetData *TD, const DominatorTree *DT,
520 if (!ValueDominatesPHI(RHS, PI, DT))
529 Value *V = SimplifyCmpInst(Pred, Incoming, RHS, TD, DT, MaxRecurse);
543 const TargetData *TD, const DominatorTree *DT,
579 if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1))
583 if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, TD, DT,
589 TD, DT, MaxRecurse))
605 const TargetData *TD, const DominatorTree *DT) {
606 return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit);
612 const TargetData *TD, const DominatorTree *DT,
646 if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, TD, DT, MaxRecurse-1))
648 if (Value *W = SimplifyBinOp(Instruction::Add, X, V, TD, DT,
655 if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1))
657 if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, TD, DT,
670 if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, TD, DT, MaxRecurse-1))
672 if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, TD, DT,
679 if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1))
681 if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, TD, DT,
694 if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, DT, MaxRecurse-1))
696 if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, DT,
705 TD, DT, MaxRecurse))
710 if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1))
726 const TargetData *TD, const DominatorTree *DT) {
727 return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit);
733 const DominatorTree *DT, unsigned MaxRecurse) {
768 if (Value *V = SimplifyAndInst(Op0, Op1, TD, DT, MaxRecurse-1))
772 if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, TD, DT,
778 TD, DT, MaxRecurse))
784 if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, TD, DT,
791 if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, TD, DT,
799 const DominatorTree *DT) {
800 return ::SimplifyMulInst(Op0, Op1, TD, DT, RecursionLimit);
806 const TargetData *TD, const DominatorTree *DT,
864 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse))
870 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse))
879 const DominatorTree *DT, unsigned MaxRecurse) {
880 if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, TD, DT, MaxRecurse))
887 const DominatorTree *DT) {
888 return ::SimplifySDivInst(Op0, Op1, TD, DT, RecursionLimit);
894 const DominatorTree *DT, unsigned MaxRecurse) {
895 if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, TD, DT, MaxRecurse))
902 const DominatorTree *DT) {
903 return ::SimplifyUDivInst(Op0, Op1, TD, DT, RecursionLimit);
920 const DominatorTree *DT) {
921 return ::SimplifyFDivInst(Op0, Op1, TD, DT, RecursionLimit);
927 const TargetData *TD, const DominatorTree *DT,
967 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse))
973 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse))
982 const DominatorTree *DT, unsigned MaxRecurse) {
983 if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, DT, MaxRecurse))
990 const DominatorTree *DT) {
991 return ::SimplifySRemInst(Op0, Op1, TD, DT, RecursionLimit);
997 const DominatorTree *DT, unsigned MaxRecurse) {
998 if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, DT, MaxRecurse))
1005 const DominatorTree *DT) {
1006 return ::SimplifyURemInst(Op0, Op1, TD, DT, RecursionLimit);
1023 const DominatorTree *DT) {
1024 return ::SimplifyFRemInst(Op0, Op1, TD, DT, RecursionLimit);
1030 const TargetData *TD, const DominatorTree *DT,
1060 if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse))
1066 if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse))
1075 const TargetData *TD, const DominatorTree *DT,
1077 if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, TD, DT, MaxRecurse))
1093 const TargetData *TD, const DominatorTree *DT) {
1094 return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit);
1100 const TargetData *TD, const DominatorTree *DT,
1102 if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, TD, DT, MaxRecurse))
1119 const TargetData *TD, const DominatorTree *DT) {
1120 return ::SimplifyLShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit);
1126 const TargetData *TD, const DominatorTree *DT,
1128 if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, TD, DT, MaxRecurse))
1149 const TargetData *TD, const DominatorTree *DT) {
1150 return ::SimplifyAShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit);
1156 const DominatorTree *DT, unsigned MaxRecurse) {
1201 if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, TD, DT,
1207 TD, DT, MaxRecurse))
1212 TD, DT, MaxRecurse))
1217 TD, DT, MaxRecurse))
1223 if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, TD, DT,
1230 if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, TD, DT,
1238 const DominatorTree *DT) {
1239 return ::SimplifyAndInst(Op0, Op1, TD, DT, RecursionLimit);
1245 const DominatorTree *DT, unsigned MaxRecurse) {
1300 if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, TD, DT,
1306 TD, DT, MaxRecurse))
1311 TD, DT, MaxRecurse))
1317 if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, TD, DT,
1324 if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, TD, DT,
1332 const DominatorTree *DT) {
1333 return ::SimplifyOrInst(Op0, Op1, TD, DT, RecursionLimit);
1339 const DominatorTree *DT, unsigned MaxRecurse) {
1369 if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, TD, DT,
1375 TD, DT, MaxRecurse))
1391 const DominatorTree *DT) {
1392 return ::SimplifyXorInst(Op0, Op1, TD, DT, RecursionLimit);
1422 const TargetData *TD, const DominatorTree *DT,
1625 TD, DT, MaxRecurse-1))
1631 TD, DT, MaxRecurse-1))
1643 SrcOp, RI->getOperand(0), TD, DT,
1659 SrcOp, Trunc, TD, DT, MaxRecurse-1))
1704 TD, DT, MaxRecurse-1))
1718 if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, DT,
1754 TD, DT, MaxRecurse-1))
1763 TD, DT, MaxRecurse-1))
1797 TD, DT, MaxRecurse-1))
1804 C == LHS ? D : C, TD, DT, MaxRecurse-1))
1813 if (Value *V = SimplifyICmpInst(Pred, Y, Z, TD, DT, MaxRecurse-1))
1887 RBO->getOperand(0), TD, DT, MaxRecurse-1))
1898 RBO->getOperand(0), TD, DT, MaxRecurse-1))
1952 if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1))
1966 if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1))
2022 if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1))
2036 if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1))
2096 if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse))
2102 if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse))
2109 const TargetData *TD, const DominatorTree *DT) {
2110 return ::SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit);
2116 const TargetData *TD, const DominatorTree *DT,
2191 if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse))
2197 if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse))
2204 const TargetData *TD, const DominatorTree *DT) {
2205 return ::SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit);
2304 static Value *SimplifyPHINode(PHINode *PN, const DominatorTree *DT) {
2332 return ValueDominatesPHI(CommonValue, PN, DT) ? CommonValue : 0;
2343 const TargetData *TD, const DominatorTree *DT,
2348 TD, DT, MaxRecurse);
2351 TD, DT, MaxRecurse);
2352 case Instruction::Mul: return SimplifyMulInst (LHS, RHS, TD, DT, MaxRecurse);
2353 case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, DT, MaxRecurse);
2354 case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, DT, MaxRecurse);
2355 case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, DT, MaxRecurse);
2356 case Instruction::SRem: return SimplifySRemInst(LHS, RHS, TD, DT, MaxRecurse);
2357 case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, DT, MaxRecurse);
2358 case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, DT, MaxRecurse);
2361 TD, DT, MaxRecurse);
2363 return SimplifyLShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse);
2365 return SimplifyAShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse);
2366 case Instruction::And: return SimplifyAndInst(LHS, RHS, TD, DT, MaxRecurse);
2367 case Instruction::Or: return SimplifyOrInst (LHS, RHS, TD, DT, MaxRecurse);
2368 case Instruction::Xor: return SimplifyXorInst(LHS, RHS, TD, DT, MaxRecurse);
2378 if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, TD, DT,
2385 if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, TD, DT,
2392 if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, TD, DT, MaxRecurse))
2400 const TargetData *TD, const DominatorTree *DT) {
2401 return ::SimplifyBinOp(Opcode, LHS, RHS, TD, DT, RecursionLimit);
2407 const TargetData *TD, const DominatorTree *DT,
2410 return SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse);
2411 return SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse);
2415 const TargetData *TD, const DominatorTree *DT) {
2416 return ::SimplifyCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit);
2422 const DominatorTree *DT) {
2433 TD, DT);
2439 TD, DT);
2442 Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, DT);
2445 Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, DT);
2448 Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, DT);
2451 Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, DT);
2454 Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, DT);
2457 Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, DT);
2460 Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, DT);
2466 TD, DT);
2471 TD, DT);
2476 TD, DT);
2479 Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, DT);
2482 Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, DT);
2485 Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, DT);
2489 I->getOperand(0), I->getOperand(1), TD, DT);
2493 I->getOperand(0), I->getOperand(1), TD, DT);
2497 I->getOperand(2), TD, DT);
2501 Result = SimplifyGEPInst(Ops, TD, DT);
2508 IV->getIndices(), TD, DT);
2512 Result = SimplifyPHINode(cast<PHINode>(I), DT);
2530 const DominatorTree *DT) {
2554 SimplifiedVal = SimplifyInstruction(User, TD, DT);
2559 ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, DT);
