contrib/llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp

   1 //===-- UnrollLoopRuntime.cpp - Runtime Loop unrolling utilities ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements some loop unrolling utilities for loops with run-time
  11 // trip counts.  See LoopUnroll.cpp for unrolling loops with compile-time
  12 // trip counts.
  13 //
  14 // The functions in this file are used to generate extra code when the
  15 // run-time trip count modulo the unroll factor is not 0.  When this is the
  16 // case, we need to generate code to execute these 'left over' iterations.
  17 //
  18 // The current strategy generates an if-then-else sequence prior to the
  19 // unrolled loop to execute the 'left over' iterations before or after the
  20 // unrolled loop.
  21 //
  22 //===----------------------------------------------------------------------===//
  23
  24 #include "llvm/Transforms/Utils/UnrollLoop.h"
  25 #include "llvm/ADT/Statistic.h"
  26 #include "llvm/Analysis/AliasAnalysis.h"
  27 #include "llvm/Analysis/LoopIterator.h"
  28 #include "llvm/Analysis/LoopPass.h"
  29 #include "llvm/Analysis/ScalarEvolution.h"
  30 #include "llvm/Analysis/ScalarEvolutionExpander.h"
  31 #include "llvm/IR/BasicBlock.h"
  32 #include "llvm/IR/Dominators.h"
  33 #include "llvm/IR/Metadata.h"
  34 #include "llvm/IR/Module.h"
  35 #include "llvm/Support/Debug.h"
  36 #include "llvm/Support/raw_ostream.h"
  37 #include "llvm/Transforms/Scalar.h"
  38 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
  39 #include "llvm/Transforms/Utils/Cloning.h"
  40 #include <algorithm>
  41
  42 using namespace llvm;
  43
  44 #define DEBUG_TYPE "loop-unroll"
  45
  46 STATISTIC(NumRuntimeUnrolled,
  47           "Number of loops unrolled with run-time trip counts");
  48
  49 /// Connect the unrolling prolog code to the original loop.
  50 /// The unrolling prolog code contains code to execute the
  51 /// 'extra' iterations if the run-time trip count modulo the
  52 /// unroll count is non-zero.
  53 ///
  54 /// This function performs the following:
  55 /// - Create PHI nodes at prolog end block to combine values
  56 ///   that exit the prolog code and jump around the prolog.
  57 /// - Add a PHI operand to a PHI node at the loop exit block
  58 ///   for values that exit the prolog and go around the loop.
  59 /// - Branch around the original loop if the trip count is less
  60 ///   than the unroll factor.
  61 ///
  62 static void ConnectProlog(Loop *L, Value *BECount, unsigned Count,
  63                           BasicBlock *PrologExit, BasicBlock *PreHeader,
  64                           BasicBlock *NewPreHeader, ValueToValueMapTy &VMap,
  65                           DominatorTree *DT, LoopInfo *LI, bool PreserveLCSSA) {
  66   BasicBlock *Latch = L->getLoopLatch();
  67   assert(Latch && "Loop must have a latch");
  68   BasicBlock *PrologLatch = cast<BasicBlock>(VMap[Latch]);
  69
  70   // Create a PHI node for each outgoing value from the original loop
  71   // (which means it is an outgoing value from the prolog code too).
  72   // The new PHI node is inserted in the prolog end basic block.
  73   // The new PHI node value is added as an operand of a PHI node in either
  74   // the loop header or the loop exit block.
  75   for (BasicBlock *Succ : successors(Latch)) {
  76     for (Instruction &BBI : *Succ) {
  77       PHINode *PN = dyn_cast<PHINode>(&BBI);
  78       // Exit when we passed all PHI nodes.
  79       if (!PN)
  80         break;
  81       // Add a new PHI node to the prolog end block and add the
  82       // appropriate incoming values.
  83       PHINode *NewPN = PHINode::Create(PN->getType(), 2, PN->getName() + ".unr",
  84                                        PrologExit->getFirstNonPHI());
  85       // Adding a value to the new PHI node from the original loop preheader.
  86       // This is the value that skips all the prolog code.
  87       if (L->contains(PN)) {
  88         NewPN->addIncoming(PN->getIncomingValueForBlock(NewPreHeader),
  89                            PreHeader);
  90       } else {
  91         NewPN->addIncoming(UndefValue::get(PN->getType()), PreHeader);
  92       }
  93
  94       Value *V = PN->getIncomingValueForBlock(Latch);
  95       if (Instruction *I = dyn_cast<Instruction>(V)) {
  96         if (L->contains(I)) {
  97           V = VMap.lookup(I);
  98         }
  99       }
 100       // Adding a value to the new PHI node from the last prolog block
 101       // that was created.
 102       NewPN->addIncoming(V, PrologLatch);
 103
 104       // Update the existing PHI node operand with the value from the
 105       // new PHI node.  How this is done depends on if the existing
 106       // PHI node is in the original loop block, or the exit block.
 107       if (L->contains(PN)) {
 108         PN->setIncomingValue(PN->getBasicBlockIndex(NewPreHeader), NewPN);
 109       } else {
 110         PN->addIncoming(NewPN, PrologExit);
 111       }
 112     }
 113   }
 114
 115   // Make sure that created prolog loop is in simplified form
 116   SmallVector<BasicBlock *, 4> PrologExitPreds;
 117   Loop *PrologLoop = LI->getLoopFor(PrologLatch);
 118   if (PrologLoop) {
 119     for (BasicBlock *PredBB : predecessors(PrologExit))
 120       if (PrologLoop->contains(PredBB))
 121         PrologExitPreds.push_back(PredBB);
 122
 123     SplitBlockPredecessors(PrologExit, PrologExitPreds, ".unr-lcssa", DT, LI,
 124                            PreserveLCSSA);
 125   }
 126
 127   // Create a branch around the original loop, which is taken if there are no
 128   // iterations remaining to be executed after running the prologue.
 129   Instruction *InsertPt = PrologExit->getTerminator();
 130   IRBuilder<> B(InsertPt);
 131
 132   assert(Count != 0 && "nonsensical Count!");
 133
 134   // If BECount <u (Count - 1) then (BECount + 1) % Count == (BECount + 1)
 135   // This means %xtraiter is (BECount + 1) and all of the iterations of this
 136   // loop were executed by the prologue.  Note that if BECount <u (Count - 1)
 137   // then (BECount + 1) cannot unsigned-overflow.
 138   Value *BrLoopExit =
 139       B.CreateICmpULT(BECount, ConstantInt::get(BECount->getType(), Count - 1));
 140   BasicBlock *Exit = L->getUniqueExitBlock();
 141   assert(Exit && "Loop must have a single exit block only");
 142   // Split the exit to maintain loop canonicalization guarantees
 143   SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
 144   SplitBlockPredecessors(Exit, Preds, ".unr-lcssa", DT, LI,
 145                          PreserveLCSSA);
 146   // Add the branch to the exit block (around the unrolled loop)
 147   B.CreateCondBr(BrLoopExit, Exit, NewPreHeader);
 148   InsertPt->eraseFromParent();
 149 }
 150
 151 /// Connect the unrolling epilog code to the original loop.
 152 /// The unrolling epilog code contains code to execute the
 153 /// 'extra' iterations if the run-time trip count modulo the
 154 /// unroll count is non-zero.
 155 ///
 156 /// This function performs the following:
 157 /// - Update PHI nodes at the unrolling loop exit and epilog loop exit
 158 /// - Create PHI nodes at the unrolling loop exit to combine
 159 ///   values that exit the unrolling loop code and jump around it.
 160 /// - Update PHI operands in the epilog loop by the new PHI nodes
 161 /// - Branch around the epilog loop if extra iters (ModVal) is zero.
 162 ///
 163 static void ConnectEpilog(Loop *L, Value *ModVal, BasicBlock *NewExit,
 164                           BasicBlock *Exit, BasicBlock *PreHeader,
 165                           BasicBlock *EpilogPreHeader, BasicBlock *NewPreHeader,
 166                           ValueToValueMapTy &VMap, DominatorTree *DT,
 167                           LoopInfo *LI, bool PreserveLCSSA)  {
 168   BasicBlock *Latch = L->getLoopLatch();
 169   assert(Latch && "Loop must have a latch");
 170   BasicBlock *EpilogLatch = cast<BasicBlock>(VMap[Latch]);
 171
 172   // Loop structure should be the following:
 173   //
 174   // PreHeader
 175   // NewPreHeader
 176   //   Header
 177   //   ...
 178   //   Latch
 179   // NewExit (PN)
 180   // EpilogPreHeader
 181   //   EpilogHeader
 182   //   ...
 183   //   EpilogLatch
 184   // Exit (EpilogPN)
 185
 186   // Update PHI nodes at NewExit and Exit.
 187   for (Instruction &BBI : *NewExit) {
 188     PHINode *PN = dyn_cast<PHINode>(&BBI);
 189     // Exit when we passed all PHI nodes.
 190     if (!PN)
 191       break;
 192     // PN should be used in another PHI located in Exit block as
 193     // Exit was split by SplitBlockPredecessors into Exit and NewExit
 194     // Basicaly it should look like:
 195     // NewExit:
 196     //   PN = PHI [I, Latch]
 197     // ...
 198     // Exit:
 199     //   EpilogPN = PHI [PN, EpilogPreHeader]
 200     //
 201     // There is EpilogPreHeader incoming block instead of NewExit as
 202     // NewExit was spilt 1 more time to get EpilogPreHeader.
 203     assert(PN->hasOneUse() && "The phi should have 1 use");
 204     PHINode *EpilogPN = cast<PHINode> (PN->use_begin()->getUser());
 205     assert(EpilogPN->getParent() == Exit && "EpilogPN should be in Exit block");
 206
 207     // Add incoming PreHeader from branch around the Loop
 208     PN->addIncoming(UndefValue::get(PN->getType()), PreHeader);
 209
 210     Value *V = PN->getIncomingValueForBlock(Latch);
 211     Instruction *I = dyn_cast<Instruction>(V);
 212     if (I && L->contains(I))
 213       // If value comes from an instruction in the loop add VMap value.
 214       V = VMap.lookup(I);
 215     // For the instruction out of the loop, constant or undefined value
 216     // insert value itself.
 217     EpilogPN->addIncoming(V, EpilogLatch);
 218
 219     assert(EpilogPN->getBasicBlockIndex(EpilogPreHeader) >= 0 &&
 220           "EpilogPN should have EpilogPreHeader incoming block");
 221     // Change EpilogPreHeader incoming block to NewExit.
 222     EpilogPN->setIncomingBlock(EpilogPN->getBasicBlockIndex(EpilogPreHeader),
 223                                NewExit);
 224     // Now PHIs should look like:
 225     // NewExit:
 226     //   PN = PHI [I, Latch], [undef, PreHeader]
 227     // ...
 228     // Exit:
 229     //   EpilogPN = PHI [PN, NewExit], [VMap[I], EpilogLatch]
 230   }
 231
 232   // Create PHI nodes at NewExit (from the unrolling loop Latch and PreHeader).
 233   // Update corresponding PHI nodes in epilog loop.
 234   for (BasicBlock *Succ : successors(Latch)) {
 235     // Skip this as we already updated phis in exit blocks.
 236     if (!L->contains(Succ))
 237       continue;
 238     for (Instruction &BBI : *Succ) {
 239       PHINode *PN = dyn_cast<PHINode>(&BBI);
 240       // Exit when we passed all PHI nodes.
 241       if (!PN)
 242         break;
 243       // Add new PHI nodes to the loop exit block and update epilog
 244       // PHIs with the new PHI values.
 245       PHINode *NewPN = PHINode::Create(PN->getType(), 2, PN->getName() + ".unr",
 246                                        NewExit->getFirstNonPHI());
 247       // Adding a value to the new PHI node from the unrolling loop preheader.
 248       NewPN->addIncoming(PN->getIncomingValueForBlock(NewPreHeader), PreHeader);
 249       // Adding a value to the new PHI node from the unrolling loop latch.
 250       NewPN->addIncoming(PN->getIncomingValueForBlock(Latch), Latch);
 251
 252       // Update the existing PHI node operand with the value from the new PHI
 253       // node.  Corresponding instruction in epilog loop should be PHI.
 254       PHINode *VPN = cast<PHINode>(VMap[&BBI]);
 255       VPN->setIncomingValue(VPN->getBasicBlockIndex(EpilogPreHeader), NewPN);
 256     }
 257   }
 258
 259   Instruction *InsertPt = NewExit->getTerminator();
 260   IRBuilder<> B(InsertPt);
 261   Value *BrLoopExit = B.CreateIsNotNull(ModVal, "lcmp.mod");
 262   assert(Exit && "Loop must have a single exit block only");
 263   // Split the exit to maintain loop canonicalization guarantees
 264   SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
 265   SplitBlockPredecessors(Exit, Preds, ".epilog-lcssa", DT, LI,
 266                          PreserveLCSSA);
 267   // Add the branch to the exit block (around the unrolling loop)
 268   B.CreateCondBr(BrLoopExit, EpilogPreHeader, Exit);
 269   InsertPt->eraseFromParent();
 270 }
 271
 272 /// Create a clone of the blocks in a loop and connect them together.
 273 /// If CreateRemainderLoop is false, loop structure will not be cloned,
 274 /// otherwise a new loop will be created including all cloned blocks, and the
 275 /// iterator of it switches to count NewIter down to 0.
 276 /// The cloned blocks should be inserted between InsertTop and InsertBot.
 277 /// If loop structure is cloned InsertTop should be new preheader, InsertBot
 278 /// new loop exit.
 279 ///
 280 static void CloneLoopBlocks(Loop *L, Value *NewIter,
 281                             const bool CreateRemainderLoop,
 282                             const bool UseEpilogRemainder,
 283                             BasicBlock *InsertTop, BasicBlock *InsertBot,
 284                             BasicBlock *Preheader,
 285                             std::vector<BasicBlock *> &NewBlocks,
 286                             LoopBlocksDFS &LoopBlocks, ValueToValueMapTy &VMap,
 287                             LoopInfo *LI) {
 288   StringRef suffix = UseEpilogRemainder ? "epil" : "prol";
 289   BasicBlock *Header = L->getHeader();
 290   BasicBlock *Latch = L->getLoopLatch();
 291   Function *F = Header->getParent();
 292   LoopBlocksDFS::RPOIterator BlockBegin = LoopBlocks.beginRPO();
 293   LoopBlocksDFS::RPOIterator BlockEnd = LoopBlocks.endRPO();
 294   Loop *NewLoop = nullptr;
 295   Loop *ParentLoop = L->getParentLoop();
 296   if (CreateRemainderLoop) {
 297     NewLoop = new Loop();
 298     if (ParentLoop)
 299       ParentLoop->addChildLoop(NewLoop);
 300     else
 301       LI->addTopLevelLoop(NewLoop);
 302   }
 303
 304   NewLoopsMap NewLoops;
 305   NewLoops[L] = NewLoop;
 306   // For each block in the original loop, create a new copy,
 307   // and update the value map with the newly created values.
 308   for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
 309     BasicBlock *NewBB = CloneBasicBlock(*BB, VMap, "." + suffix, F);
 310     NewBlocks.push_back(NewBB);
 311
 312     if (NewLoop) {
 313       addClonedBlockToLoopInfo(*BB, NewBB, LI, NewLoops);
 314     } else if (ParentLoop)
 315       ParentLoop->addBasicBlockToLoop(NewBB, *LI);
 316
 317     VMap[*BB] = NewBB;
 318     if (Header == *BB) {
 319       // For the first block, add a CFG connection to this newly
 320       // created block.
 321       InsertTop->getTerminator()->setSuccessor(0, NewBB);
 322     }
 323
 324     if (Latch == *BB) {
 325       // For the last block, if CreateRemainderLoop is false, create a direct
 326       // jump to InsertBot. If not, create a loop back to cloned head.
 327       VMap.erase((*BB)->getTerminator());
 328       BasicBlock *FirstLoopBB = cast<BasicBlock>(VMap[Header]);
 329       BranchInst *LatchBR = cast<BranchInst>(NewBB->getTerminator());
 330       IRBuilder<> Builder(LatchBR);
 331       if (!CreateRemainderLoop) {
 332         Builder.CreateBr(InsertBot);
 333       } else {
 334         PHINode *NewIdx = PHINode::Create(NewIter->getType(), 2,
 335                                           suffix + ".iter",
 336                                           FirstLoopBB->getFirstNonPHI());
 337         Value *IdxSub =
 338             Builder.CreateSub(NewIdx, ConstantInt::get(NewIdx->getType(), 1),
 339                               NewIdx->getName() + ".sub");
 340         Value *IdxCmp =
 341             Builder.CreateIsNotNull(IdxSub, NewIdx->getName() + ".cmp");
 342         Builder.CreateCondBr(IdxCmp, FirstLoopBB, InsertBot);
 343         NewIdx->addIncoming(NewIter, InsertTop);
 344         NewIdx->addIncoming(IdxSub, NewBB);
 345       }
 346       LatchBR->eraseFromParent();
 347     }
 348   }
 349
 350   // Change the incoming values to the ones defined in the preheader or
 351   // cloned loop.
 352   for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
 353     PHINode *NewPHI = cast<PHINode>(VMap[&*I]);
 354     if (!CreateRemainderLoop) {
 355       if (UseEpilogRemainder) {
 356         unsigned idx = NewPHI->getBasicBlockIndex(Preheader);
 357         NewPHI->setIncomingBlock(idx, InsertTop);
 358         NewPHI->removeIncomingValue(Latch, false);
 359       } else {
 360         VMap[&*I] = NewPHI->getIncomingValueForBlock(Preheader);
 361         cast<BasicBlock>(VMap[Header])->getInstList().erase(NewPHI);
 362       }
 363     } else {
 364       unsigned idx = NewPHI->getBasicBlockIndex(Preheader);
 365       NewPHI->setIncomingBlock(idx, InsertTop);
 366       BasicBlock *NewLatch = cast<BasicBlock>(VMap[Latch]);
 367       idx = NewPHI->getBasicBlockIndex(Latch);
 368       Value *InVal = NewPHI->getIncomingValue(idx);
 369       NewPHI->setIncomingBlock(idx, NewLatch);
 370       if (Value *V = VMap.lookup(InVal))
 371         NewPHI->setIncomingValue(idx, V);
 372     }
 373   }
 374   if (NewLoop) {
 375     // Add unroll disable metadata to disable future unrolling for this loop.
 376     SmallVector<Metadata *, 4> MDs;
 377     // Reserve first location for self reference to the LoopID metadata node.
 378     MDs.push_back(nullptr);
 379     MDNode *LoopID = NewLoop->getLoopID();
 380     if (LoopID) {
 381       // First remove any existing loop unrolling metadata.
 382       for (unsigned i = 1, ie = LoopID->getNumOperands(); i < ie; ++i) {
 383         bool IsUnrollMetadata = false;
 384         MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
 385         if (MD) {
 386           const MDString *S = dyn_cast<MDString>(MD->getOperand(0));
 387           IsUnrollMetadata = S && S->getString().startswith("llvm.loop.unroll.");
 388         }
 389         if (!IsUnrollMetadata)
 390           MDs.push_back(LoopID->getOperand(i));
 391       }
 392     }
 393
 394     LLVMContext &Context = NewLoop->getHeader()->getContext();
 395     SmallVector<Metadata *, 1> DisableOperands;
 396     DisableOperands.push_back(MDString::get(Context, "llvm.loop.unroll.disable"));
 397     MDNode *DisableNode = MDNode::get(Context, DisableOperands);
 398     MDs.push_back(DisableNode);
 399
 400     MDNode *NewLoopID = MDNode::get(Context, MDs);
 401     // Set operand 0 to refer to the loop id itself.
 402     NewLoopID->replaceOperandWith(0, NewLoopID);
 403     NewLoop->setLoopID(NewLoopID);
 404   }
 405 }
 406
 407 /// Insert code in the prolog/epilog code when unrolling a loop with a
 408 /// run-time trip-count.
 409 ///
 410 /// This method assumes that the loop unroll factor is total number
 411 /// of loop bodies in the loop after unrolling. (Some folks refer
 412 /// to the unroll factor as the number of *extra* copies added).
 413 /// We assume also that the loop unroll factor is a power-of-two. So, after
 414 /// unrolling the loop, the number of loop bodies executed is 2,
 415 /// 4, 8, etc.  Note - LLVM converts the if-then-sequence to a switch
 416 /// instruction in SimplifyCFG.cpp.  Then, the backend decides how code for
 417 /// the switch instruction is generated.
 418 ///
 419 /// ***Prolog case***
 420 ///        extraiters = tripcount % loopfactor
 421 ///        if (extraiters == 0) jump Loop:
 422 ///        else jump Prol:
 423 /// Prol:  LoopBody;
 424 ///        extraiters -= 1                 // Omitted if unroll factor is 2.
 425 ///        if (extraiters != 0) jump Prol: // Omitted if unroll factor is 2.
 426 ///        if (tripcount < loopfactor) jump End:
 427 /// Loop:
 428 /// ...
 429 /// End:
 430 ///
 431 /// ***Epilog case***
 432 ///        extraiters = tripcount % loopfactor
 433 ///        if (tripcount < loopfactor) jump LoopExit:
 434 ///        unroll_iters = tripcount - extraiters
 435 /// Loop:  LoopBody; (executes unroll_iter times);
 436 ///        unroll_iter -= 1
 437 ///        if (unroll_iter != 0) jump Loop:
 438 /// LoopExit:
 439 ///        if (extraiters == 0) jump EpilExit:
 440 /// Epil:  LoopBody; (executes extraiters times)
 441 ///        extraiters -= 1                 // Omitted if unroll factor is 2.
 442 ///        if (extraiters != 0) jump Epil: // Omitted if unroll factor is 2.
 443 /// EpilExit:
 444
 445 bool llvm::UnrollRuntimeLoopRemainder(Loop *L, unsigned Count,
 446                                       bool AllowExpensiveTripCount,
 447                                       bool UseEpilogRemainder,
 448                                       LoopInfo *LI, ScalarEvolution *SE,
 449                                       DominatorTree *DT, bool PreserveLCSSA) {
 450   // for now, only unroll loops that contain a single exit
 451   if (!L->getExitingBlock())
 452     return false;
 453
 454   // Make sure the loop is in canonical form, and there is a single
 455   // exit block only.
 456   if (!L->isLoopSimplifyForm())
 457     return false;
 458   BasicBlock *Exit = L->getUniqueExitBlock(); // successor out of loop
 459   if (!Exit)
 460     return false;
 461
 462   // Use Scalar Evolution to compute the trip count. This allows more loops to
 463   // be unrolled than relying on induction var simplification.
 464   if (!SE)
 465     return false;
 466
 467   // Only unroll loops with a computable trip count, and the trip count needs
 468   // to be an int value (allowing a pointer type is a TODO item).
 469   const SCEV *BECountSC = SE->getBackedgeTakenCount(L);
 470   if (isa<SCEVCouldNotCompute>(BECountSC) ||
 471       !BECountSC->getType()->isIntegerTy())
 472     return false;
 473
 474   unsigned BEWidth = cast<IntegerType>(BECountSC->getType())->getBitWidth();
 475
 476   // Add 1 since the backedge count doesn't include the first loop iteration.
 477   const SCEV *TripCountSC =
 478       SE->getAddExpr(BECountSC, SE->getConstant(BECountSC->getType(), 1));
 479   if (isa<SCEVCouldNotCompute>(TripCountSC))
 480     return false;
 481
 482   BasicBlock *Header = L->getHeader();
 483   BasicBlock *PreHeader = L->getLoopPreheader();
 484   BranchInst *PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
 485   const DataLayout &DL = Header->getModule()->getDataLayout();
 486   SCEVExpander Expander(*SE, DL, "loop-unroll");
 487   if (!AllowExpensiveTripCount &&
 488       Expander.isHighCostExpansion(TripCountSC, L, PreHeaderBR))
 489     return false;
 490
 491   // This constraint lets us deal with an overflowing trip count easily; see the
 492   // comment on ModVal below.
 493   if (Log2_32(Count) > BEWidth)
 494     return false;
 495
 496   BasicBlock *Latch = L->getLoopLatch();
 497
 498   // Loop structure is the following:
 499   //
 500   // PreHeader
 501   //   Header
 502   //   ...
 503   //   Latch
 504   // Exit
 505
 506   BasicBlock *NewPreHeader;
 507   BasicBlock *NewExit = nullptr;
 508   BasicBlock *PrologExit = nullptr;
 509   BasicBlock *EpilogPreHeader = nullptr;
 510   BasicBlock *PrologPreHeader = nullptr;
 511
 512   if (UseEpilogRemainder) {
 513     // If epilog remainder
 514     // Split PreHeader to insert a branch around loop for unrolling.
 515     NewPreHeader = SplitBlock(PreHeader, PreHeader->getTerminator(), DT, LI);
 516     NewPreHeader->setName(PreHeader->getName() + ".new");
 517     // Split Exit to create phi nodes from branch above.
 518     SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
 519     NewExit = SplitBlockPredecessors(Exit, Preds, ".unr-lcssa",
 520                                      DT, LI, PreserveLCSSA);
 521     // Split NewExit to insert epilog remainder loop.
 522     EpilogPreHeader = SplitBlock(NewExit, NewExit->getTerminator(), DT, LI);
 523     EpilogPreHeader->setName(Header->getName() + ".epil.preheader");
 524   } else {
 525     // If prolog remainder
 526     // Split the original preheader twice to insert prolog remainder loop
 527     PrologPreHeader = SplitEdge(PreHeader, Header, DT, LI);
 528     PrologPreHeader->setName(Header->getName() + ".prol.preheader");
 529     PrologExit = SplitBlock(PrologPreHeader, PrologPreHeader->getTerminator(),
 530                             DT, LI);
 531     PrologExit->setName(Header->getName() + ".prol.loopexit");
 532     // Split PrologExit to get NewPreHeader.
 533     NewPreHeader = SplitBlock(PrologExit, PrologExit->getTerminator(), DT, LI);
 534     NewPreHeader->setName(PreHeader->getName() + ".new");
 535   }
 536   // Loop structure should be the following:
 537   //  Epilog             Prolog
 538   //
 539   // PreHeader         PreHeader
 540   // *NewPreHeader     *PrologPreHeader
 541   //   Header          *PrologExit
 542   //   ...             *NewPreHeader
 543   //   Latch             Header
 544   // *NewExit            ...
 545   // *EpilogPreHeader    Latch
 546   // Exit              Exit
 547
 548   // Calculate conditions for branch around loop for unrolling
 549   // in epilog case and around prolog remainder loop in prolog case.
 550   // Compute the number of extra iterations required, which is:
 551   //  extra iterations = run-time trip count % loop unroll factor
 552   PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
 553   Value *TripCount = Expander.expandCodeFor(TripCountSC, TripCountSC->getType(),
 554                                             PreHeaderBR);
 555   Value *BECount = Expander.expandCodeFor(BECountSC, BECountSC->getType(),
 556                                           PreHeaderBR);
 557   IRBuilder<> B(PreHeaderBR);
 558   Value *ModVal;
 559   // Calculate ModVal = (BECount + 1) % Count.
 560   // Note that TripCount is BECount + 1.
 561   if (isPowerOf2_32(Count)) {
 562     // When Count is power of 2 we don't BECount for epilog case, however we'll
 563     // need it for a branch around unrolling loop for prolog case.
 564     ModVal = B.CreateAnd(TripCount, Count - 1, "xtraiter");
 565     //  1. There are no iterations to be run in the prolog/epilog loop.
 566     // OR
 567     //  2. The addition computing TripCount overflowed.
 568     //
 569     // If (2) is true, we know that TripCount really is (1 << BEWidth) and so
 570     // the number of iterations that remain to be run in the original loop is a
 571     // multiple Count == (1 << Log2(Count)) because Log2(Count) <= BEWidth (we
 572     // explicitly check this above).
 573   } else {
 574     // As (BECount + 1) can potentially unsigned overflow we count
 575     // (BECount % Count) + 1 which is overflow safe as BECount % Count < Count.
 576     Value *ModValTmp = B.CreateURem(BECount,
 577                                     ConstantInt::get(BECount->getType(),
 578                                                      Count));
 579     Value *ModValAdd = B.CreateAdd(ModValTmp,
 580                                    ConstantInt::get(ModValTmp->getType(), 1));
 581     // At that point (BECount % Count) + 1 could be equal to Count.
 582     // To handle this case we need to take mod by Count one more time.
 583     ModVal = B.CreateURem(ModValAdd,
 584                           ConstantInt::get(BECount->getType(), Count),
 585                           "xtraiter");
 586   }
 587   Value *BranchVal =
 588       UseEpilogRemainder ? B.CreateICmpULT(BECount,
 589                                            ConstantInt::get(BECount->getType(),
 590                                                             Count - 1)) :
 591                            B.CreateIsNotNull(ModVal, "lcmp.mod");
 592   BasicBlock *RemainderLoop = UseEpilogRemainder ? NewExit : PrologPreHeader;
 593   BasicBlock *UnrollingLoop = UseEpilogRemainder ? NewPreHeader : PrologExit;
 594   // Branch to either remainder (extra iterations) loop or unrolling loop.
 595   B.CreateCondBr(BranchVal, RemainderLoop, UnrollingLoop);
 596   PreHeaderBR->eraseFromParent();
 597   Function *F = Header->getParent();
 598   // Get an ordered list of blocks in the loop to help with the ordering of the
 599   // cloned blocks in the prolog/epilog code
 600   LoopBlocksDFS LoopBlocks(L);
 601   LoopBlocks.perform(LI);
 602
 603   //
 604   // For each extra loop iteration, create a copy of the loop's basic blocks
 605   // and generate a condition that branches to the copy depending on the
 606   // number of 'left over' iterations.
 607   //
 608   std::vector<BasicBlock *> NewBlocks;
 609   ValueToValueMapTy VMap;
 610
 611   // For unroll factor 2 remainder loop will have 1 iterations.
 612   // Do not create 1 iteration loop.
 613   bool CreateRemainderLoop = (Count != 2);
 614
 615   // Clone all the basic blocks in the loop. If Count is 2, we don't clone
 616   // the loop, otherwise we create a cloned loop to execute the extra
 617   // iterations. This function adds the appropriate CFG connections.
 618   BasicBlock *InsertBot = UseEpilogRemainder ? Exit : PrologExit;
 619   BasicBlock *InsertTop = UseEpilogRemainder ? EpilogPreHeader : PrologPreHeader;
 620   CloneLoopBlocks(L, ModVal, CreateRemainderLoop, UseEpilogRemainder, InsertTop,
 621                   InsertBot, NewPreHeader, NewBlocks, LoopBlocks, VMap, LI);
 622
 623   // Insert the cloned blocks into the function.
 624   F->getBasicBlockList().splice(InsertBot->getIterator(),
 625                                 F->getBasicBlockList(),
 626                                 NewBlocks[0]->getIterator(),
 627                                 F->end());
 628
 629   // Loop structure should be the following:
 630   //  Epilog             Prolog
 631   //
 632   // PreHeader         PreHeader
 633   // NewPreHeader      PrologPreHeader
 634   //   Header            PrologHeader
 635   //   ...               ...
 636   //   Latch             PrologLatch
 637   // NewExit           PrologExit
 638   // EpilogPreHeader   NewPreHeader
 639   //   EpilogHeader      Header
 640   //   ...               ...
 641   //   EpilogLatch       Latch
 642   // Exit              Exit
 643
 644   // Rewrite the cloned instruction operands to use the values created when the
 645   // clone is created.
 646   for (BasicBlock *BB : NewBlocks) {
 647     for (Instruction &I : *BB) {
 648       RemapInstruction(&I, VMap,
 649                        RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
 650     }
 651   }
 652
 653   if (UseEpilogRemainder) {
 654     // Connect the epilog code to the original loop and update the
 655     // PHI functions.
 656     ConnectEpilog(L, ModVal, NewExit, Exit, PreHeader,
 657                   EpilogPreHeader, NewPreHeader, VMap, DT, LI,
 658                   PreserveLCSSA);
 659
 660     // Update counter in loop for unrolling.
 661     // I should be multiply of Count.
 662     IRBuilder<> B2(NewPreHeader->getTerminator());
 663     Value *TestVal = B2.CreateSub(TripCount, ModVal, "unroll_iter");
 664     BranchInst *LatchBR = cast<BranchInst>(Latch->getTerminator());
 665     B2.SetInsertPoint(LatchBR);
 666     PHINode *NewIdx = PHINode::Create(TestVal->getType(), 2, "niter",
 667                                       Header->getFirstNonPHI());
 668     Value *IdxSub =
 669         B2.CreateSub(NewIdx, ConstantInt::get(NewIdx->getType(), 1),
 670                      NewIdx->getName() + ".nsub");
 671     Value *IdxCmp;
 672     if (LatchBR->getSuccessor(0) == Header)
 673       IdxCmp = B2.CreateIsNotNull(IdxSub, NewIdx->getName() + ".ncmp");
 674     else
 675       IdxCmp = B2.CreateIsNull(IdxSub, NewIdx->getName() + ".ncmp");
 676     NewIdx->addIncoming(TestVal, NewPreHeader);
 677     NewIdx->addIncoming(IdxSub, Latch);
 678     LatchBR->setCondition(IdxCmp);
 679   } else {
 680     // Connect the prolog code to the original loop and update the
 681     // PHI functions.
 682     ConnectProlog(L, BECount, Count, PrologExit, PreHeader, NewPreHeader,
 683                   VMap, DT, LI, PreserveLCSSA);
 684   }
 685
 686   // If this loop is nested, then the loop unroller changes the code in the
 687   // parent loop, so the Scalar Evolution pass needs to be run again.
 688   if (Loop *ParentLoop = L->getParentLoop())
 689     SE->forgetLoop(ParentLoop);
 690
 691   NumRuntimeUnrolled++;
 692   return true;
 693 }