Transforms/Utils/SimplifyIndVar.cpp

1094   Instruction *cloneIVUser(NarrowIVDefUse DU, const SCEVAddRecExpr *WideAR);
1095   Instruction *cloneArithmeticIVUser(NarrowIVDefUse DU,
1097   Instruction *cloneBitwiseIVUser(NarrowIVDefUse DU);
1103   WidenedRecTy getWideRecurrence(NarrowIVDefUse DU);
1105   WidenedRecTy getExtendedOperandRecurrence(NarrowIVDefUse DU);
1110   Instruction *widenIVUse(NarrowIVDefUse DU, SCEVExpander &Rewriter);
1112   bool widenLoopCompare(NarrowIVDefUse DU);
1113   bool widenWithVariantUse(NarrowIVDefUse DU);
1201 Instruction *WidenIV::cloneIVUser(WidenIV::NarrowIVDefUse DU,
1203   unsigned Opcode = DU.NarrowUse->getOpcode();
1211     return cloneArithmeticIVUser(DU, WideAR);
1219     return cloneBitwiseIVUser(DU);
1223 Instruction *WidenIV::cloneBitwiseIVUser(WidenIV::NarrowIVDefUse DU) {
1224   Instruction *NarrowUse = DU.NarrowUse;
1225   Instruction *NarrowDef = DU.NarrowDef;
1226   Instruction *WideDef = DU.WideDef;
1253 Instruction *WidenIV::cloneArithmeticIVUser(WidenIV::NarrowIVDefUse DU,
1255   Instruction *NarrowUse = DU.NarrowUse;
1256   Instruction *NarrowDef = DU.NarrowDef;
1257   Instruction *WideDef = DU.WideDef;
1353 WidenIV::getExtendedOperandRecurrence(WidenIV::NarrowIVDefUse DU) {
1355   const unsigned OpCode = DU.NarrowUse->getOpcode();
1364       DU.NarrowUse->getOperand(0) == DU.NarrowDef ? 1 : 0;
1365   assert(DU.NarrowUse->getOperand(1-ExtendOperIdx) == DU.NarrowDef && "bad DU");
1369     cast<OverflowingBinaryOperator>(DU.NarrowUse);
1370   ExtendKind ExtKind = getExtendKind(DU.NarrowDef);
1373       SE->getSCEV(DU.NarrowUse->getOperand(ExtendOperIdx)), WideType);
1376       SE->getSCEV(DU.NarrowUse->getOperand(ExtendOperIdx)), WideType);
1385   const SCEV *lhs = SE->getSCEV(DU.WideDef);
1406 WidenIV::WidenedRecTy WidenIV::getWideRecurrence(WidenIV::NarrowIVDefUse DU) {
1407   if (!SE->isSCEVable(DU.NarrowUse->getType()))
1410   const SCEV *NarrowExpr = SE->getSCEV(DU.NarrowUse);
1420   if (DU.NeverNegative) {
1428   } else if (getExtendKind(DU.NarrowDef) == SignExtended) {
1443 static void truncateIVUse(WidenIV::NarrowIVDefUse DU, DominatorTree *DT,
1445   auto *InsertPt = getInsertPointForUses(DU.NarrowUse, DU.NarrowDef, DT, LI);
1448   LLVM_DEBUG(dbgs() << "INDVARS: Truncate IV " << *DU.WideDef << " for user "
1449                     << *DU.NarrowUse << "\n");
1451   Value *Trunc = Builder.CreateTrunc(DU.WideDef, DU.NarrowDef->getType());
1452   DU.NarrowUse->replaceUsesOfWith(DU.NarrowDef, Trunc);
1458 bool WidenIV::widenLoopCompare(WidenIV::NarrowIVDefUse DU) {
1459   ICmpInst *Cmp = dyn_cast<ICmpInst>(DU.NarrowUse);
1477   bool IsSigned = getExtendKind(DU.NarrowDef) == SignExtended;
1478   if (!(DU.NeverNegative || IsSigned == Cmp->isSigned()))
1481   Value *Op = Cmp->getOperand(Cmp->getOperand(0) == DU.NarrowDef ? 1 : 0);
1487   auto *InsertPt = getInsertPointForUses(DU.NarrowUse, DU.NarrowDef, DT, LI);
1491   DU.NarrowUse->replaceUsesOfWith(DU.NarrowDef, DU.WideDef);
1496     DU.NarrowUse->replaceUsesOfWith(Op, ExtOp);
1521 bool WidenIV::widenWithVariantUse(WidenIV::NarrowIVDefUse DU) {
1522   Instruction *NarrowUse = DU.NarrowUse;
1523   Instruction *NarrowDef = DU.NarrowDef;
1524   Instruction *WideDef = DU.WideDef;
1533   // The operand that is not defined by NarrowDef of DU. Let's call it the
1537          "bad DU");
1695 Instruction *WidenIV::widenIVUse(WidenIV::NarrowIVDefUse DU, SCEVExpander &Rewriter) {
1696   assert(ExtendKindMap.count(DU.NarrowDef) &&
1700   if (PHINode *UsePhi = dyn_cast<PHINode>(DU.NarrowUse)) {
1706         truncateIVUse(DU, DT, LI);
1715           PHINode::Create(DU.WideDef->getType(), 1, UsePhi->getName() + ".wide",
1717         WidePhi->addIncoming(DU.WideDef, UsePhi->getIncomingBlock(0));
1719         Value *Trunc = Builder.CreateTrunc(WidePhi, DU.NarrowDef->getType());
1732     return DU.NeverNegative || getExtendKind(DU.NarrowDef) == SignExtended;
1735     return DU.NeverNegative || getExtendKind(DU.NarrowDef) == ZeroExtended;
1739   if ((isa<SExtInst>(DU.NarrowUse) && canWidenBySExt()) ||
1740       (isa<ZExtInst>(DU.NarrowUse) && canWidenByZExt())) {
1741     Value *NewDef = DU.WideDef;
1742     if (DU.NarrowUse->getType() != WideType) {
1743       unsigned CastWidth = SE->getTypeSizeInBits(DU.NarrowUse->getType());
1747         IRBuilder<> Builder(DU.NarrowUse);
1748         NewDef = Builder.CreateTrunc(DU.WideDef, DU.NarrowUse->getType());
1755                           << " not wide enough to subsume " << *DU.NarrowUse
1757         DU.NarrowUse->replaceUsesOfWith(DU.NarrowDef, DU.WideDef);
1758         NewDef = DU.NarrowUse;
1761     if (NewDef != DU.NarrowUse) {
1762       LLVM_DEBUG(dbgs() << "INDVARS: eliminating " << *DU.NarrowUse
1763                         << " replaced by " << *DU.WideDef << "\n");
1765       DU.NarrowUse->replaceAllUsesWith(NewDef);
1766       DeadInsts.emplace_back(DU.NarrowUse);
1779   WidenedRecTy WideAddRec = getExtendedOperandRecurrence(DU);
1781     WideAddRec = getWideRecurrence(DU);
1787     if (widenLoopCompare(DU))
1795     if (widenWithVariantUse(DU))
1801     truncateIVUse(DU, DT, LI);
1806   assert(DU.NarrowUse != DU.NarrowUse->getParent()->getTerminator() &&
1813       Rewriter.hoistIVInc(WideInc, DU.NarrowUse))
1816     WideUse = cloneIVUser(DU, WideAddRec.first);
1834   // DU.NarrowUse with WideUse. Reattach DbgValue then.
1835   replaceAllDbgUsesWith(*DU.NarrowUse, *WideUse, *WideUse, *DT);
1837   ExtendKindMap[DU.NarrowUse] = WideAddRec.second;
1958     WidenIV::NarrowIVDefUse DU = NarrowIVUsers.pop_back_val();
1962     Instruction *WideUse = widenIVUse(DU, Rewriter);
1966       pushNarrowIVUsers(DU.NarrowUse, WideUse);
1969     if (DU.NarrowDef->use_empty())
1970       DeadInsts.emplace_back(DU.NarrowDef);