static bool canSplitCallSite(CallSite CS, TargetTransformInfo &TTI) { // FIXME: As of now we handle only CallInst. InvokeInst could be handled // without too much effort. Instruction *Instr = CS.getInstruction(); if (!isa<CallInst>(Instr)) return false; BasicBlock *CallSiteBB = Instr->getParent(); // Allow splitting a call-site only when the CodeSize cost of the // instructions before the call is less then DuplicationThreshold. The // instructions before the call will be duplicated in the split blocks and // corresponding uses will be updated. unsigned Cost = 0; for (auto &InstBeforeCall : llvm::make_range(CallSiteBB->begin(), Instr->getIterator())) { Cost += TTI.getInstructionCost(&InstBeforeCall, TargetTransformInfo::TCK_CodeSize); if (Cost >= DuplicationThreshold) return false; } // Need 2 predecessors and cannot split an edge from an IndirectBrInst. SmallVector<BasicBlock *, 2> Preds(predecessors(CallSiteBB)); if (Preds.size() != 2 || isa<IndirectBrInst>(Preds[0]->getTerminator()) || isa<IndirectBrInst>(Preds[1]->getTerminator())) return false; return CallSiteBB->canSplitPredecessors(); }
/// \brief If this loop has multiple backedges, try to pull one of them out into /// a nested loop. /// /// This is important for code that looks like /// this: /// /// Loop: /// ... /// br cond, Loop, Next /// ... /// br cond2, Loop, Out /// /// To identify this common case, we look at the PHI nodes in the header of the /// loop. PHI nodes with unchanging values on one backedge correspond to values /// that change in the "outer" loop, but not in the "inner" loop. /// /// If we are able to separate out a loop, return the new outer loop that was /// created. /// static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, Pass *PP, AssumptionCache *AC) { // Don't try to separate loops without a preheader. if (!Preheader) return nullptr; // The header is not a landing pad; preheader insertion should ensure this. BasicBlock *Header = L->getHeader(); assert(!Header->isLandingPad() && "Can't insert backedge to landing pad"); if (!Header->canSplitPredecessors()) return nullptr; PHINode *PN = findPHIToPartitionLoops(L, DT, AC); if (!PN) return nullptr; // No known way to partition. // Pull out all predecessors that have varying values in the loop. This // handles the case when a PHI node has multiple instances of itself as // arguments. SmallVector<BasicBlock*, 8> OuterLoopPreds; for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { if (PN->getIncomingValue(i) != PN || !L->contains(PN->getIncomingBlock(i))) { // We can't split indirectbr edges. if (isa<IndirectBrInst>(PN->getIncomingBlock(i)->getTerminator())) return nullptr; OuterLoopPreds.push_back(PN->getIncomingBlock(i)); } } DEBUG(dbgs() << "LoopSimplify: Splitting out a new outer loop\n"); // If ScalarEvolution is around and knows anything about values in // this loop, tell it to forget them, because we're about to // substantially change it. if (SE) SE->forgetLoop(L); bool PreserveLCSSA = PP->mustPreserveAnalysisID(LCSSAID); BasicBlock *NewBB = SplitBlockPredecessors(Header, OuterLoopPreds, ".outer", DT, LI, PreserveLCSSA); // Make sure that NewBB is put someplace intelligent, which doesn't mess up // code layout too horribly. placeSplitBlockCarefully(NewBB, OuterLoopPreds, L); // Create the new outer loop. Loop *NewOuter = new Loop(); // Change the parent loop to use the outer loop as its child now. if (Loop *Parent = L->getParentLoop()) Parent->replaceChildLoopWith(L, NewOuter); else LI->changeTopLevelLoop(L, NewOuter); // L is now a subloop of our outer loop. NewOuter->addChildLoop(L); for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E; ++I) NewOuter->addBlockEntry(*I); // Now reset the header in L, which had been moved by // SplitBlockPredecessors for the outer loop. L->moveToHeader(Header); // Determine which blocks should stay in L and which should be moved out to // the Outer loop now. std::set<BasicBlock*> BlocksInL; for (pred_iterator PI=pred_begin(Header), E = pred_end(Header); PI!=E; ++PI) { BasicBlock *P = *PI; if (DT->dominates(Header, P)) addBlockAndPredsToSet(P, Header, BlocksInL); } // Scan all of the loop children of L, moving them to OuterLoop if they are // not part of the inner loop. const std::vector<Loop*> &SubLoops = L->getSubLoops(); for (size_t I = 0; I != SubLoops.size(); ) if (BlocksInL.count(SubLoops[I]->getHeader())) ++I; // Loop remains in L else NewOuter->addChildLoop(L->removeChildLoop(SubLoops.begin() + I)); // Now that we know which blocks are in L and which need to be moved to // OuterLoop, move any blocks that need it. for (unsigned i = 0; i != L->getBlocks().size(); ++i) { BasicBlock *BB = L->getBlocks()[i]; if (!BlocksInL.count(BB)) { // Move this block to the parent, updating the exit blocks sets L->removeBlockFromLoop(BB); if ((*LI)[BB] == L) LI->changeLoopFor(BB, NewOuter); --i; } } return NewOuter; }