forked from llvm-mirror/llvm
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[LoopDist/LoopVer] Move LoopVersioning to a new module, NFC
Summary: The class will obviously need improvement down the road. For one, there is no reason that addPHINodes would have to be exposed like that. I will make this and other improvements in follow-up patches. The main goal is to be able to share this functionality. The LoopLoadElimination pass I am working on needs it too. Later we can move other clients as well (LV and Ashutosh's LICMVer). Reviewers: hfinkel, ashutosh.nema Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D10577 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@241932 91177308-0d34-0410-b5e6-96231b3b80d8
- Loading branch information
Showing
4 changed files
with
208 additions
and
115 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,100 @@ | ||
| //===- LoopVersioning.h - Utility to version a loop -------------*- C++ -*-===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
| // | ||
| // This file defines a utility class to perform loop versioning. The versioned | ||
| // loop speculates that otherwise may-aliasing memory accesses don't overlap and | ||
| // emits checks to prove this. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #ifndef LLVM_TRANSFORMS_UTILS_LOOPVERSIONING_H | ||
| #define LLVM_TRANSFORMS_UTILS_LOOPVERSIONING_H | ||
|
|
||
| #include "llvm/Transforms/Utils/ValueMapper.h" | ||
|
|
||
| namespace llvm { | ||
|
|
||
| class Loop; | ||
| class LoopAccessInfo; | ||
| class LoopInfo; | ||
|
|
||
| /// \brief This class emits a version of the loop where run-time checks ensure | ||
| /// that may-alias pointers can't overlap. | ||
| /// | ||
| /// It currently only supports single-exit loops and assumes that the loop | ||
| /// already has a preheader. | ||
| class LoopVersioning { | ||
| public: | ||
| LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI, | ||
| DominatorTree *DT, | ||
| const SmallVector<int, 8> *PtrToPartition = nullptr); | ||
|
|
||
| /// \brief Returns true if we need memchecks to disambiguate may-aliasing | ||
| /// accesses. | ||
| bool needsRuntimeChecks() const; | ||
|
|
||
| /// \brief Performs the CFG manipulation part of versioning the loop including | ||
| /// the DominatorTree and LoopInfo updates. | ||
| /// | ||
| /// The loop that was used to construct the class will be the "versioned" loop | ||
| /// i.e. the loop that will receive control if all the memchecks pass. | ||
| /// | ||
| /// This allows the loop transform pass to operate on the same loop regardless | ||
| /// of whether versioning was necessary or not: | ||
| /// | ||
| /// for each loop L: | ||
| /// analyze L | ||
| /// if versioning is necessary version L | ||
| /// transform L | ||
| void versionLoop(Pass *P); | ||
|
|
||
| /// \brief Adds the necessary PHI nodes for the versioned loops based on the | ||
| /// loop-defined values used outside of the loop. | ||
| /// | ||
| /// This needs to be called after versionLoop if there are defs in the loop | ||
| /// that are used outside the loop. FIXME: this should be invoked internally | ||
| /// by versionLoop and made private. | ||
| void addPHINodes(const SmallVectorImpl<Instruction *> &DefsUsedOutside); | ||
|
|
||
| /// \brief Returns the versioned loop. Control flows here if pointers in the | ||
| /// loop don't alias (i.e. all memchecks passed). (This loop is actually the | ||
| /// same as the original loop that we got constructed with.) | ||
| Loop *getVersionedLoop() { return VersionedLoop; } | ||
|
|
||
| /// \brief Returns the fall-back loop. Control flows here if pointers in the | ||
| /// loop may alias (i.e. one of the memchecks failed). | ||
| Loop *getNonVersionedLoop() { return NonVersionedLoop; } | ||
|
|
||
| private: | ||
| /// \brief The original loop. This becomes the "versioned" one. I.e., | ||
| /// control flows here if pointers in the loop don't alias. | ||
| Loop *VersionedLoop; | ||
| /// \brief The fall-back loop. I.e. control flows here if pointers in the | ||
| /// loop may alias (memchecks failed). | ||
| Loop *NonVersionedLoop; | ||
|
|
||
| /// \brief For each memory pointer it contains the partitionId it is used in. | ||
| /// If nullptr, no partitioning is used. | ||
| /// | ||
| /// The I-th entry corresponds to I-th entry in LAI.getRuntimePointerCheck(). | ||
| /// If the pointer is used in multiple partitions the entry is set to -1. | ||
| const SmallVector<int, 8> *PtrToPartition; | ||
|
|
||
| /// \brief This maps the instructions from VersionedLoop to their counterpart | ||
| /// in NonVersionedLoop. | ||
| ValueToValueMapTy VMap; | ||
|
|
||
| /// \brief Analyses used. | ||
| const LoopAccessInfo &LAI; | ||
| LoopInfo *LI; | ||
| DominatorTree *DT; | ||
| }; | ||
| } | ||
|
|
||
| #endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,106 @@ | ||
| //===- LoopVersioning.cpp - Utility to version a loop ---------------------===// | ||
| // | ||
| // The LLVM Compiler Infrastructure | ||
| // | ||
| // This file is distributed under the University of Illinois Open Source | ||
| // License. See LICENSE.TXT for details. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
| // | ||
| // This file defines a utility class to perform loop versioning. The versioned | ||
| // loop speculates that otherwise may-aliasing memory accesses don't overlap and | ||
| // emits checks to prove this. | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "llvm/Analysis/LoopAccessAnalysis.h" | ||
| #include "llvm/Analysis/LoopInfo.h" | ||
| #include "llvm/IR/Dominators.h" | ||
| #include "llvm/Transforms/Utils/BasicBlockUtils.h" | ||
| #include "llvm/Transforms/Utils/Cloning.h" | ||
| #include "llvm/Transforms/Utils/LoopVersioning.h" | ||
|
|
||
| using namespace llvm; | ||
|
|
||
| LoopVersioning::LoopVersioning(const LoopAccessInfo &LAI, Loop *L, LoopInfo *LI, | ||
| DominatorTree *DT, | ||
| const SmallVector<int, 8> *PtrToPartition) | ||
| : VersionedLoop(L), NonVersionedLoop(nullptr), | ||
| PtrToPartition(PtrToPartition), LAI(LAI), LI(LI), DT(DT) { | ||
| assert(L->getExitBlock() && "No single exit block"); | ||
| assert(L->getLoopPreheader() && "No preheader"); | ||
| } | ||
|
|
||
| bool LoopVersioning::needsRuntimeChecks() const { | ||
| return LAI.getRuntimePointerCheck()->needsAnyChecking(PtrToPartition); | ||
| } | ||
|
|
||
| void LoopVersioning::versionLoop(Pass *P) { | ||
| Instruction *FirstCheckInst; | ||
| Instruction *MemRuntimeCheck; | ||
| // Add the memcheck in the original preheader (this is empty initially). | ||
| BasicBlock *MemCheckBB = VersionedLoop->getLoopPreheader(); | ||
| std::tie(FirstCheckInst, MemRuntimeCheck) = | ||
| LAI.addRuntimeCheck(MemCheckBB->getTerminator(), PtrToPartition); | ||
| assert(MemRuntimeCheck && "called even though needsAnyChecking = false"); | ||
|
|
||
| // Rename the block to make the IR more readable. | ||
| MemCheckBB->setName(VersionedLoop->getHeader()->getName() + ".lver.memcheck"); | ||
|
|
||
| // Create empty preheader for the loop (and after cloning for the | ||
| // non-versioned loop). | ||
| BasicBlock *PH = SplitBlock(MemCheckBB, MemCheckBB->getTerminator(), DT, LI); | ||
| PH->setName(VersionedLoop->getHeader()->getName() + ".ph"); | ||
|
|
||
| // Clone the loop including the preheader. | ||
| // | ||
| // FIXME: This does not currently preserve SimplifyLoop because the exit | ||
| // block is a join between the two loops. | ||
| SmallVector<BasicBlock *, 8> NonVersionedLoopBlocks; | ||
| NonVersionedLoop = | ||
| cloneLoopWithPreheader(PH, MemCheckBB, VersionedLoop, VMap, ".lver.orig", | ||
| LI, DT, NonVersionedLoopBlocks); | ||
| remapInstructionsInBlocks(NonVersionedLoopBlocks, VMap); | ||
|
|
||
| // Insert the conditional branch based on the result of the memchecks. | ||
| Instruction *OrigTerm = MemCheckBB->getTerminator(); | ||
| BranchInst::Create(NonVersionedLoop->getLoopPreheader(), | ||
| VersionedLoop->getLoopPreheader(), MemRuntimeCheck, | ||
| OrigTerm); | ||
| OrigTerm->eraseFromParent(); | ||
|
|
||
| // The loops merge in the original exit block. This is now dominated by the | ||
| // memchecking block. | ||
| DT->changeImmediateDominator(VersionedLoop->getExitBlock(), MemCheckBB); | ||
| } | ||
|
|
||
| void LoopVersioning::addPHINodes( | ||
| const SmallVectorImpl<Instruction *> &DefsUsedOutside) { | ||
| BasicBlock *PHIBlock = VersionedLoop->getExitBlock(); | ||
| assert(PHIBlock && "No single successor to loop exit block"); | ||
|
|
||
| for (auto *Inst : DefsUsedOutside) { | ||
| auto *NonVersionedLoopInst = cast<Instruction>(VMap[Inst]); | ||
| PHINode *PN; | ||
|
|
||
| // First see if we have a single-operand PHI with the value defined by the | ||
| // original loop. | ||
| for (auto I = PHIBlock->begin(); (PN = dyn_cast<PHINode>(I)); ++I) { | ||
| assert(PN->getNumOperands() == 1 && | ||
| "Exit block should only have on predecessor"); | ||
| if (PN->getIncomingValue(0) == Inst) | ||
| break; | ||
| } | ||
| // If not create it. | ||
| if (!PN) { | ||
| PN = PHINode::Create(Inst->getType(), 2, Inst->getName() + ".lver", | ||
| PHIBlock->begin()); | ||
| for (auto *User : Inst->users()) | ||
| if (!VersionedLoop->contains(cast<Instruction>(User)->getParent())) | ||
| User->replaceUsesOfWith(Inst, PN); | ||
| PN->addIncoming(Inst, VersionedLoop->getExitingBlock()); | ||
| } | ||
| // Add the new incoming value from the non-versioned loop. | ||
| PN->addIncoming(NonVersionedLoopInst, NonVersionedLoop->getExitingBlock()); | ||
| } | ||
| } |