2004-04-20 02:07:02 +08:00
|
|
|
//===-- LoopUnswitch.cpp - Hoist loop-invariant conditionals in loop ------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-04-20 02:07:02 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-04-20 02:07:02 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass transforms loops that contain branches on loop-invariant conditions
|
|
|
|
// to have multiple loops. For example, it turns the left into the right code:
|
|
|
|
//
|
|
|
|
// for (...) if (lic)
|
|
|
|
// A for (...)
|
|
|
|
// if (lic) A; B; C
|
|
|
|
// B else
|
|
|
|
// C for (...)
|
|
|
|
// A; C
|
|
|
|
//
|
|
|
|
// This can increase the size of the code exponentially (doubling it every time
|
|
|
|
// a loop is unswitched) so we only unswitch if the resultant code will be
|
|
|
|
// smaller than a threshold.
|
|
|
|
//
|
|
|
|
// This pass expects LICM to be run before it to hoist invariant conditions out
|
|
|
|
// of the loop, to make the unswitching opportunity obvious.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
2015-01-04 20:03:27 +08:00
|
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
2012-03-15 08:29:10 +08:00
|
|
|
#include "llvm/Analysis/CodeMetrics.h"
|
2010-04-20 13:33:18 +08:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
2004-04-20 02:07:02 +08:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
2007-03-07 08:26:10 +08:00
|
|
|
#include "llvm/Analysis/LoopPass.h"
|
2011-02-11 14:08:28 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolution.h"
|
2013-01-21 21:04:33 +08:00
|
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-01-13 17:26:24 +08:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
2015-03-10 10:37:25 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2015-06-23 13:31:09 +08:00
|
|
|
#include "llvm/IR/MDBuilder.h"
|
2006-02-10 04:15:48 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2007-02-06 07:32:05 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-25 08:23:56 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
|
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2004-09-04 02:19:51 +08:00
|
|
|
#include <algorithm>
|
2012-01-15 17:44:07 +08:00
|
|
|
#include <map>
|
2006-02-10 03:14:52 +08:00
|
|
|
#include <set>
|
2004-04-20 02:07:02 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "loop-unswitch"
|
|
|
|
|
2006-12-20 05:40:18 +08:00
|
|
|
STATISTIC(NumBranches, "Number of branches unswitched");
|
|
|
|
STATISTIC(NumSwitches, "Number of switches unswitched");
|
|
|
|
STATISTIC(NumSelects , "Number of selects unswitched");
|
|
|
|
STATISTIC(NumTrivial , "Number of unswitches that are trivial");
|
|
|
|
STATISTIC(NumSimplify, "Number of simplifications of unswitched code");
|
2012-01-11 16:40:51 +08:00
|
|
|
STATISTIC(TotalInsts, "Total number of instructions analyzed");
|
2006-12-20 05:40:18 +08:00
|
|
|
|
2012-01-17 04:48:04 +08:00
|
|
|
// The specific value of 100 here was chosen based only on intuition and a
|
2009-10-14 01:50:43 +08:00
|
|
|
// few specific examples.
|
2008-05-13 08:00:25 +08:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"),
|
2012-01-11 16:40:51 +08:00
|
|
|
cl::init(100), cl::Hidden);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
namespace {
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
class LUAnalysisCache {
|
|
|
|
|
|
|
|
typedef DenseMap<const SwitchInst*, SmallPtrSet<const Value *, 8> >
|
|
|
|
UnswitchedValsMap;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
typedef UnswitchedValsMap::iterator UnswitchedValsIt;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
struct LoopProperties {
|
|
|
|
unsigned CanBeUnswitchedCount;
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
unsigned WasUnswitchedCount;
|
2012-01-15 17:44:07 +08:00
|
|
|
unsigned SizeEstimation;
|
|
|
|
UnswitchedValsMap UnswitchedVals;
|
|
|
|
};
|
2012-04-10 13:14:37 +08:00
|
|
|
|
|
|
|
// Here we use std::map instead of DenseMap, since we need to keep valid
|
2012-01-15 17:44:07 +08:00
|
|
|
// LoopProperties pointer for current loop for better performance.
|
|
|
|
typedef std::map<const Loop*, LoopProperties> LoopPropsMap;
|
|
|
|
typedef LoopPropsMap::iterator LoopPropsMapIt;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
LoopPropsMap LoopsProperties;
|
2013-08-07 01:03:42 +08:00
|
|
|
UnswitchedValsMap *CurLoopInstructions;
|
|
|
|
LoopProperties *CurrentLoopProperties;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
// A loop unswitching with an estimated cost above this threshold
|
|
|
|
// is not performed. MaxSize is turned into unswitching quota for
|
|
|
|
// the current loop, and reduced correspondingly, though note that
|
|
|
|
// the quota is returned by releaseMemory() when the loop has been
|
|
|
|
// processed, so that MaxSize will return to its previous
|
|
|
|
// value. So in most cases MaxSize will equal the Threshold flag
|
|
|
|
// when a new loop is processed. An exception to that is that
|
|
|
|
// MaxSize will have a smaller value while processing nested loops
|
|
|
|
// that were introduced due to loop unswitching of an outer loop.
|
|
|
|
//
|
|
|
|
// FIXME: The way that MaxSize works is subtle and depends on the
|
|
|
|
// pass manager processing loops and calling releaseMemory() in a
|
|
|
|
// specific order. It would be good to find a more straightforward
|
|
|
|
// way of doing what MaxSize does.
|
2012-01-15 17:44:07 +08:00
|
|
|
unsigned MaxSize;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
public:
|
|
|
|
LUAnalysisCache()
|
|
|
|
: CurLoopInstructions(nullptr), CurrentLoopProperties(nullptr),
|
|
|
|
MaxSize(Threshold) {}
|
|
|
|
|
|
|
|
// Analyze loop. Check its size, calculate is it possible to unswitch
|
|
|
|
// it. Returns true if we can unswitch this loop.
|
|
|
|
bool countLoop(const Loop *L, const TargetTransformInfo &TTI,
|
|
|
|
AssumptionCache *AC);
|
|
|
|
|
|
|
|
// Clean all data related to given loop.
|
|
|
|
void forgetLoop(const Loop *L);
|
|
|
|
|
|
|
|
// Mark case value as unswitched.
|
|
|
|
// Since SI instruction can be partly unswitched, in order to avoid
|
|
|
|
// extra unswitching in cloned loops keep track all unswitched values.
|
|
|
|
void setUnswitched(const SwitchInst *SI, const Value *V);
|
|
|
|
|
|
|
|
// Check was this case value unswitched before or not.
|
|
|
|
bool isUnswitched(const SwitchInst *SI, const Value *V);
|
|
|
|
|
|
|
|
// Returns true if another unswitching could be done within the cost
|
|
|
|
// threshold.
|
|
|
|
bool CostAllowsUnswitching();
|
|
|
|
|
|
|
|
// Clone all loop-unswitch related loop properties.
|
|
|
|
// Redistribute unswitching quotas.
|
|
|
|
// Note, that new loop data is stored inside the VMap.
|
|
|
|
void cloneData(const Loop *NewLoop, const Loop *OldLoop,
|
|
|
|
const ValueToValueMapTy &VMap);
|
2012-01-15 17:44:07 +08:00
|
|
|
};
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-14 06:34:39 +08:00
|
|
|
class LoopUnswitch : public LoopPass {
|
|
|
|
LoopInfo *LI; // Loop information
|
|
|
|
LPPassManager *LPM;
|
2015-01-04 20:03:27 +08:00
|
|
|
AssumptionCache *AC;
|
2012-01-14 03:13:54 +08:00
|
|
|
|
2012-01-14 06:34:39 +08:00
|
|
|
// LoopProcessWorklist - Used to check if second loop needs processing
|
|
|
|
// after RewriteLoopBodyWithConditionConstant rewrites first loop.
|
|
|
|
std::vector<Loop*> LoopProcessWorklist;
|
2012-01-15 17:44:07 +08:00
|
|
|
|
|
|
|
LUAnalysisCache BranchesInfo;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2007-06-06 08:21:03 +08:00
|
|
|
bool OptimizeForSize;
|
2007-07-31 07:07:10 +08:00
|
|
|
bool redoLoop;
|
2007-10-06 06:29:34 +08:00
|
|
|
|
2008-07-02 09:18:13 +08:00
|
|
|
Loop *currentLoop;
|
2007-10-06 06:29:34 +08:00
|
|
|
DominatorTree *DT;
|
2008-07-02 09:18:13 +08:00
|
|
|
BasicBlock *loopHeader;
|
|
|
|
BasicBlock *loopPreheader;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2008-07-02 09:44:29 +08:00
|
|
|
// LoopBlocks contains all of the basic blocks of the loop, including the
|
2012-04-10 13:14:37 +08:00
|
|
|
// preheader of the loop, the body of the loop, and the exit blocks of the
|
2008-07-02 09:44:29 +08:00
|
|
|
// loop, in that order.
|
|
|
|
std::vector<BasicBlock*> LoopBlocks;
|
|
|
|
// NewBlocks contained cloned copy of basic blocks from LoopBlocks.
|
|
|
|
std::vector<BasicBlock*> NewBlocks;
|
2008-07-04 01:37:52 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
public:
|
2007-05-03 09:11:54 +08:00
|
|
|
static char ID; // Pass ID, replacement for typeid
|
2012-04-10 13:14:37 +08:00
|
|
|
explicit LoopUnswitch(bool Os = false) :
|
|
|
|
LoopPass(ID), OptimizeForSize(Os), redoLoop(false),
|
2014-04-25 13:29:35 +08:00
|
|
|
currentLoop(nullptr), DT(nullptr), loopHeader(nullptr),
|
|
|
|
loopPreheader(nullptr) {
|
2010-10-20 01:21:58 +08:00
|
|
|
initializeLoopUnswitchPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-02 05:15:47 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnLoop(Loop *L, LPPassManager &LPM) override;
|
2008-07-02 09:18:13 +08:00
|
|
|
bool processCurrentLoop();
|
2004-04-20 02:07:02 +08:00
|
|
|
|
|
|
|
/// This transformation requires natural loop information & requires that
|
2010-08-30 01:23:19 +08:00
|
|
|
/// loop preheaders be inserted into the CFG.
|
2004-04-20 02:07:02 +08:00
|
|
|
///
|
2014-03-05 17:10:37 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2015-01-04 20:03:27 +08:00
|
|
|
AU.addRequired<AssumptionCacheTracker>();
|
2004-04-20 02:07:02 +08:00
|
|
|
AU.addRequiredID(LoopSimplifyID);
|
2006-02-10 06:15:42 +08:00
|
|
|
AU.addPreservedID(LoopSimplifyID);
|
2015-01-17 22:16:18 +08:00
|
|
|
AU.addRequired<LoopInfoWrapperPass>();
|
|
|
|
AU.addPreserved<LoopInfoWrapperPass>();
|
2006-06-13 05:49:21 +08:00
|
|
|
AU.addRequiredID(LCSSAID);
|
2007-07-31 16:03:26 +08:00
|
|
|
AU.addPreservedID(LCSSAID);
|
2014-01-13 21:07:17 +08:00
|
|
|
AU.addPreserved<DominatorTreeWrapperPass>();
|
2011-02-11 14:08:28 +08:00
|
|
|
AU.addPreserved<ScalarEvolution>();
|
[PM] Change the core design of the TTI analysis to use a polymorphic
type erased interface and a single analysis pass rather than an
extremely complex analysis group.
The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.
I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface. These
aren't as clean as I would like and I'm planning to work on cleaning
some of this up, but I wanted to start by putting into the right form.
There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.
The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.
Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.
The downside of this change is that it is very, very verbose. I'm going
to work to improve that, but it is somewhat an implementation necessity
in C++ to do type erasure. =/ I discussed this design really extensively
with Eric and Hal prior to going down this path, and afterward showed
them the result. No one was really thrilled with it, but there doesn't
seem to be a substantially better alternative. Using a base class and
virtual method dispatch would make the code much shorter, but as
discussed in the update to the programmer's manual and elsewhere,
a polymorphic interface feels like the more principled approach even if
this is perhaps the least compelling example of it. ;]
Ultimately, there is still a lot more to be done here, but this was the
huge chunk that I couldn't really split things out of because this was
the interface change to TTI. I've tried to minimize all the other parts
of this. The follow up work should include at least:
1) Improving the TargetMachine interface by having it directly return
a TTI object. Because we have a non-pass object with value semantics
and an internal type erasure mechanism, we can narrow the interface
of the TargetMachine to *just* do what we need: build and return
a TTI object that we can then insert into the pass pipeline.
2) Make the TTI object be fully specialized for a particular function.
This will include splitting off a minimal form of it which is
sufficient for the inliner and the old pass manager.
3) Add a new pass manager analysis which produces TTI objects from the
target machine for each function. This may actually be done as part
of #2 in order to use the new analysis to implement #2.
4) Work on narrowing the API between TTI and the targets so that it is
easier to understand and less verbose to type erase.
5) Work on narrowing the API between TTI and its clients so that it is
easier to understand and less verbose to forward.
6) Try to improve the CRTP-based delegation. I feel like this code is
just a bit messy and exacerbating the complexity of implementing
the TTI in each target.
Many thanks to Eric and Hal for their help here. I ended up blocked on
this somewhat more abruptly than I expected, and so I appreciate getting
it sorted out very quickly.
Differential Revision: http://reviews.llvm.org/D7293
llvm-svn: 227669
2015-01-31 11:43:40 +08:00
|
|
|
AU.addRequired<TargetTransformInfoWrapperPass>();
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2007-07-31 16:03:26 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
void releaseMemory() override {
|
2012-01-15 17:44:07 +08:00
|
|
|
BranchesInfo.forgetLoop(currentLoop);
|
2009-09-08 23:45:00 +08:00
|
|
|
}
|
|
|
|
|
2008-07-02 09:18:13 +08:00
|
|
|
void initLoopData() {
|
|
|
|
loopHeader = currentLoop->getHeader();
|
|
|
|
loopPreheader = currentLoop->getLoopPreheader();
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2008-04-21 08:25:49 +08:00
|
|
|
/// Split all of the edges from inside the loop to their exit blocks.
|
|
|
|
/// Update the appropriate Phi nodes as we do so.
|
2013-07-14 12:42:23 +08:00
|
|
|
void SplitExitEdges(Loop *L, const SmallVectorImpl<BasicBlock *> &ExitBlocks);
|
2007-10-06 06:29:34 +08:00
|
|
|
|
2015-06-23 13:31:09 +08:00
|
|
|
bool UnswitchIfProfitable(Value *LoopCond, Constant *Val,
|
|
|
|
TerminatorInst *TI = nullptr);
|
2006-02-18 09:27:45 +08:00
|
|
|
void UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
|
2015-06-23 13:31:09 +08:00
|
|
|
BasicBlock *ExitBlock, TerminatorInst *TI);
|
|
|
|
void UnswitchNontrivialCondition(Value *LIC, Constant *OnVal, Loop *L,
|
|
|
|
TerminatorInst *TI);
|
2006-02-18 15:57:38 +08:00
|
|
|
|
|
|
|
void RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
|
|
|
|
Constant *Val, bool isEqual);
|
2007-06-28 08:49:00 +08:00
|
|
|
|
|
|
|
void EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
|
2012-04-10 13:14:37 +08:00
|
|
|
BasicBlock *TrueDest,
|
2007-06-28 08:49:00 +08:00
|
|
|
BasicBlock *FalseDest,
|
2015-06-23 13:31:09 +08:00
|
|
|
Instruction *InsertPt,
|
|
|
|
TerminatorInst *TI);
|
2007-06-28 08:49:00 +08:00
|
|
|
|
2007-07-31 16:03:26 +08:00
|
|
|
void SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L);
|
2014-04-25 13:29:35 +08:00
|
|
|
bool IsTrivialUnswitchCondition(Value *Cond, Constant **Val = nullptr,
|
|
|
|
BasicBlock **LoopExit = nullptr);
|
2008-07-02 09:18:13 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2012-01-15 17:44:07 +08:00
|
|
|
|
|
|
|
// Analyze loop. Check its size, calculate is it possible to unswitch
|
|
|
|
// it. Returns true if we can unswitch this loop.
|
2014-09-07 21:49:57 +08:00
|
|
|
bool LUAnalysisCache::countLoop(const Loop *L, const TargetTransformInfo &TTI,
|
2015-01-04 20:03:27 +08:00
|
|
|
AssumptionCache *AC) {
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2013-08-07 01:03:42 +08:00
|
|
|
LoopPropsMapIt PropsIt;
|
|
|
|
bool Inserted;
|
2014-03-02 21:30:33 +08:00
|
|
|
std::tie(PropsIt, Inserted) =
|
2012-01-15 17:44:07 +08:00
|
|
|
LoopsProperties.insert(std::make_pair(L, LoopProperties()));
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2013-08-07 01:03:42 +08:00
|
|
|
LoopProperties &Props = PropsIt->second;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2013-08-07 01:03:42 +08:00
|
|
|
if (Inserted) {
|
2012-01-15 17:44:07 +08:00
|
|
|
// New loop.
|
|
|
|
|
|
|
|
// Limit the number of instructions to avoid causing significant code
|
|
|
|
// expansion, and the number of basic blocks, to avoid loops with
|
|
|
|
// large numbers of branches which cause loop unswitching to go crazy.
|
|
|
|
// This is a very ad-hoc heuristic.
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2014-09-07 21:49:57 +08:00
|
|
|
SmallPtrSet<const Value *, 32> EphValues;
|
2015-01-04 20:03:27 +08:00
|
|
|
CodeMetrics::collectEphemeralValues(L, AC, EphValues);
|
2014-09-07 21:49:57 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
// FIXME: This is overly conservative because it does not take into
|
|
|
|
// consideration code simplification opportunities and code that can
|
|
|
|
// be shared by the resultant unswitched loops.
|
|
|
|
CodeMetrics Metrics;
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
for (Loop::block_iterator I = L->block_begin(), E = L->block_end(); I != E;
|
|
|
|
++I)
|
2014-09-07 21:49:57 +08:00
|
|
|
Metrics.analyzeBasicBlock(*I, TTI, EphValues);
|
2012-01-15 17:44:07 +08:00
|
|
|
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
Props.SizeEstimation = Metrics.NumInsts;
|
2012-01-15 17:44:07 +08:00
|
|
|
Props.CanBeUnswitchedCount = MaxSize / (Props.SizeEstimation);
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
Props.WasUnswitchedCount = 0;
|
2012-01-15 17:44:07 +08:00
|
|
|
MaxSize -= Props.SizeEstimation * Props.CanBeUnswitchedCount;
|
2012-12-21 00:04:27 +08:00
|
|
|
|
|
|
|
if (Metrics.notDuplicatable) {
|
|
|
|
DEBUG(dbgs() << "NOT unswitching loop %"
|
2013-08-07 01:03:42 +08:00
|
|
|
<< L->getHeader()->getName() << ", contents cannot be "
|
|
|
|
<< "duplicated!\n");
|
2012-12-21 00:04:27 +08:00
|
|
|
return false;
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
}
|
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
// Be careful. This links are good only before new loop addition.
|
|
|
|
CurrentLoopProperties = &Props;
|
|
|
|
CurLoopInstructions = &Props.UnswitchedVals;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clean all data related to given loop.
|
2013-08-07 01:03:42 +08:00
|
|
|
void LUAnalysisCache::forgetLoop(const Loop *L) {
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
LoopPropsMapIt LIt = LoopsProperties.find(L);
|
|
|
|
|
|
|
|
if (LIt != LoopsProperties.end()) {
|
2013-08-07 01:03:42 +08:00
|
|
|
LoopProperties &Props = LIt->second;
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
MaxSize += (Props.CanBeUnswitchedCount + Props.WasUnswitchedCount) *
|
|
|
|
Props.SizeEstimation;
|
2012-01-15 17:44:07 +08:00
|
|
|
LoopsProperties.erase(LIt);
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2014-04-25 13:29:35 +08:00
|
|
|
CurrentLoopProperties = nullptr;
|
|
|
|
CurLoopInstructions = nullptr;
|
2012-01-15 17:44:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Mark case value as unswitched.
|
|
|
|
// Since SI instruction can be partly unswitched, in order to avoid
|
|
|
|
// extra unswitching in cloned loops keep track all unswitched values.
|
2013-08-07 01:03:42 +08:00
|
|
|
void LUAnalysisCache::setUnswitched(const SwitchInst *SI, const Value *V) {
|
2012-01-15 17:44:07 +08:00
|
|
|
(*CurLoopInstructions)[SI].insert(V);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check was this case value unswitched before or not.
|
2013-08-07 01:03:42 +08:00
|
|
|
bool LUAnalysisCache::isUnswitched(const SwitchInst *SI, const Value *V) {
|
2012-04-10 13:14:37 +08:00
|
|
|
return (*CurLoopInstructions)[SI].count(V);
|
2012-01-15 17:44:07 +08:00
|
|
|
}
|
|
|
|
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
bool LUAnalysisCache::CostAllowsUnswitching() {
|
|
|
|
return CurrentLoopProperties->CanBeUnswitchedCount > 0;
|
|
|
|
}
|
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
// Clone all loop-unswitch related loop properties.
|
|
|
|
// Redistribute unswitching quotas.
|
|
|
|
// Note, that new loop data is stored inside the VMap.
|
2013-08-07 01:03:42 +08:00
|
|
|
void LUAnalysisCache::cloneData(const Loop *NewLoop, const Loop *OldLoop,
|
|
|
|
const ValueToValueMapTy &VMap) {
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2013-08-07 01:03:42 +08:00
|
|
|
LoopProperties &NewLoopProps = LoopsProperties[NewLoop];
|
|
|
|
LoopProperties &OldLoopProps = *CurrentLoopProperties;
|
|
|
|
UnswitchedValsMap &Insts = OldLoopProps.UnswitchedVals;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
// Reallocate "can-be-unswitched quota"
|
|
|
|
|
|
|
|
--OldLoopProps.CanBeUnswitchedCount;
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
++OldLoopProps.WasUnswitchedCount;
|
|
|
|
NewLoopProps.WasUnswitchedCount = 0;
|
2012-01-15 17:44:07 +08:00
|
|
|
unsigned Quota = OldLoopProps.CanBeUnswitchedCount;
|
|
|
|
NewLoopProps.CanBeUnswitchedCount = Quota / 2;
|
|
|
|
OldLoopProps.CanBeUnswitchedCount = Quota - Quota / 2;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
NewLoopProps.SizeEstimation = OldLoopProps.SizeEstimation;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
// Clone unswitched values info:
|
|
|
|
// for new loop switches we clone info about values that was
|
|
|
|
// already unswitched and has redundant successors.
|
|
|
|
for (UnswitchedValsIt I = Insts.begin(); I != Insts.end(); ++I) {
|
2013-08-07 01:03:42 +08:00
|
|
|
const SwitchInst *OldInst = I->first;
|
|
|
|
Value *NewI = VMap.lookup(OldInst);
|
|
|
|
const SwitchInst *NewInst = cast_or_null<SwitchInst>(NewI);
|
2012-01-15 17:44:07 +08:00
|
|
|
assert(NewInst && "All instructions that are in SrcBB must be in VMap.");
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
NewLoopProps.UnswitchedVals[NewInst] = OldLoopProps.UnswitchedVals[OldInst];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char LoopUnswitch::ID = 0;
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(LoopUnswitch, "loop-unswitch", "Unswitch loops",
|
|
|
|
false, false)
|
[PM] Change the core design of the TTI analysis to use a polymorphic
type erased interface and a single analysis pass rather than an
extremely complex analysis group.
The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.
I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface. These
aren't as clean as I would like and I'm planning to work on cleaning
some of this up, but I wanted to start by putting into the right form.
There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.
The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.
Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.
The downside of this change is that it is very, very verbose. I'm going
to work to improve that, but it is somewhat an implementation necessity
in C++ to do type erasure. =/ I discussed this design really extensively
with Eric and Hal prior to going down this path, and afterward showed
them the result. No one was really thrilled with it, but there doesn't
seem to be a substantially better alternative. Using a base class and
virtual method dispatch would make the code much shorter, but as
discussed in the update to the programmer's manual and elsewhere,
a polymorphic interface feels like the more principled approach even if
this is perhaps the least compelling example of it. ;]
Ultimately, there is still a lot more to be done here, but this was the
huge chunk that I couldn't really split things out of because this was
the interface change to TTI. I've tried to minimize all the other parts
of this. The follow up work should include at least:
1) Improving the TargetMachine interface by having it directly return
a TTI object. Because we have a non-pass object with value semantics
and an internal type erasure mechanism, we can narrow the interface
of the TargetMachine to *just* do what we need: build and return
a TTI object that we can then insert into the pass pipeline.
2) Make the TTI object be fully specialized for a particular function.
This will include splitting off a minimal form of it which is
sufficient for the inliner and the old pass manager.
3) Add a new pass manager analysis which produces TTI objects from the
target machine for each function. This may actually be done as part
of #2 in order to use the new analysis to implement #2.
4) Work on narrowing the API between TTI and the targets so that it is
easier to understand and less verbose to type erase.
5) Work on narrowing the API between TTI and its clients so that it is
easier to understand and less verbose to forward.
6) Try to improve the CRTP-based delegation. I feel like this code is
just a bit messy and exacerbating the complexity of implementing
the TTI in each target.
Many thanks to Eric and Hal for their help here. I ended up blocked on
this somewhat more abruptly than I expected, and so I appreciate getting
it sorted out very quickly.
Differential Revision: http://reviews.llvm.org/D7293
llvm-svn: 227669
2015-01-31 11:43:40 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
|
2015-01-04 20:03:27 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
|
2015-01-17 22:16:18 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(LCSSA)
|
|
|
|
INITIALIZE_PASS_END(LoopUnswitch, "loop-unswitch", "Unswitch loops",
|
|
|
|
false, false)
|
2004-04-20 02:07:02 +08:00
|
|
|
|
2012-04-10 13:14:37 +08:00
|
|
|
Pass *llvm::createLoopUnswitchPass(bool Os) {
|
|
|
|
return new LoopUnswitch(Os);
|
2007-06-06 08:21:03 +08:00
|
|
|
}
|
2004-04-20 02:07:02 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
/// FindLIVLoopCondition - Cond is a condition that occurs in L. If it is
|
|
|
|
/// invariant in the loop, or has an invariant piece, return the invariant.
|
|
|
|
/// Otherwise, return null.
|
|
|
|
static Value *FindLIVLoopCondition(Value *Cond, Loop *L, bool &Changed) {
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-11 16:40:51 +08:00
|
|
|
// We started analyze new instruction, increment scanned instructions counter.
|
|
|
|
++TotalInsts;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2010-02-02 10:26:54 +08:00
|
|
|
// We can never unswitch on vector conditions.
|
2010-02-16 19:11:14 +08:00
|
|
|
if (Cond->getType()->isVectorTy())
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2010-02-02 10:26:54 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
// Constants should be folded, not unswitched on!
|
2014-04-25 13:29:35 +08:00
|
|
|
if (isa<Constant>(Cond)) return nullptr;
|
2007-06-28 08:44:10 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
// TODO: Handle: br (VARIANT|INVARIANT).
|
2008-11-04 03:38:07 +08:00
|
|
|
|
2009-07-14 09:37:59 +08:00
|
|
|
// Hoist simple values out.
|
2009-07-15 09:25:43 +08:00
|
|
|
if (L->makeLoopInvariant(Cond, Changed))
|
2009-07-14 09:37:59 +08:00
|
|
|
return Cond;
|
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Cond))
|
|
|
|
if (BO->getOpcode() == Instruction::And ||
|
|
|
|
BO->getOpcode() == Instruction::Or) {
|
|
|
|
// If either the left or right side is invariant, we can unswitch on this,
|
|
|
|
// which will cause the branch to go away in one loop and the condition to
|
|
|
|
// simplify in the other one.
|
|
|
|
if (Value *LHS = FindLIVLoopCondition(BO->getOperand(0), L, Changed))
|
|
|
|
return LHS;
|
|
|
|
if (Value *RHS = FindLIVLoopCondition(BO->getOperand(1), L, Changed))
|
|
|
|
return RHS;
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2006-02-18 15:57:38 +08:00
|
|
|
}
|
|
|
|
|
2007-03-07 08:26:10 +08:00
|
|
|
bool LoopUnswitch::runOnLoop(Loop *L, LPPassManager &LPM_Ref) {
|
2014-02-06 08:07:05 +08:00
|
|
|
if (skipOptnoneFunction(L))
|
|
|
|
return false;
|
|
|
|
|
2015-01-04 20:03:27 +08:00
|
|
|
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
|
|
|
|
*L->getHeader()->getParent());
|
2015-01-17 22:16:18 +08:00
|
|
|
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
|
2007-03-07 08:26:10 +08:00
|
|
|
LPM = &LPM_Ref;
|
2014-01-13 21:07:17 +08:00
|
|
|
DominatorTreeWrapperPass *DTWP =
|
|
|
|
getAnalysisIfAvailable<DominatorTreeWrapperPass>();
|
2014-04-25 13:29:35 +08:00
|
|
|
DT = DTWP ? &DTWP->getDomTree() : nullptr;
|
2008-07-02 09:18:13 +08:00
|
|
|
currentLoop = L;
|
2008-09-05 06:43:59 +08:00
|
|
|
Function *F = currentLoop->getHeader()->getParent();
|
2006-02-18 15:57:38 +08:00
|
|
|
bool Changed = false;
|
2007-07-31 07:07:10 +08:00
|
|
|
do {
|
2010-03-11 03:38:49 +08:00
|
|
|
assert(currentLoop->isLCSSAForm(*DT));
|
2007-07-31 07:07:10 +08:00
|
|
|
redoLoop = false;
|
2008-07-02 09:18:13 +08:00
|
|
|
Changed |= processCurrentLoop();
|
2007-07-31 07:07:10 +08:00
|
|
|
} while(redoLoop);
|
|
|
|
|
2008-09-05 06:43:59 +08:00
|
|
|
if (Changed) {
|
|
|
|
// FIXME: Reconstruct dom info, because it is not preserved properly.
|
|
|
|
if (DT)
|
2014-01-13 21:07:17 +08:00
|
|
|
DT->recalculate(*F);
|
2008-09-05 06:43:59 +08:00
|
|
|
}
|
2007-07-31 07:07:10 +08:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2012-04-10 13:14:37 +08:00
|
|
|
/// processCurrentLoop - Do actual work and unswitch loop if possible
|
2008-07-02 09:18:13 +08:00
|
|
|
/// and profitable.
|
|
|
|
bool LoopUnswitch::processCurrentLoop() {
|
2007-07-31 07:07:10 +08:00
|
|
|
bool Changed = false;
|
2012-01-11 16:40:51 +08:00
|
|
|
|
|
|
|
initLoopData();
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-11 16:40:51 +08:00
|
|
|
// If LoopSimplify was unable to form a preheader, don't do any unswitching.
|
|
|
|
if (!loopPreheader)
|
|
|
|
return false;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-04-10 13:14:42 +08:00
|
|
|
// Loops with indirectbr cannot be cloned.
|
|
|
|
if (!currentLoop->isSafeToClone())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Without dedicated exits, splitting the exit edge may fail.
|
|
|
|
if (!currentLoop->hasDedicatedExits())
|
|
|
|
return false;
|
|
|
|
|
2012-01-11 16:40:51 +08:00
|
|
|
LLVMContext &Context = loopHeader->getContext();
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-11 16:40:51 +08:00
|
|
|
// Probably we reach the quota of branches for this loop. If so
|
|
|
|
// stop unswitching.
|
[PM] Change the core design of the TTI analysis to use a polymorphic
type erased interface and a single analysis pass rather than an
extremely complex analysis group.
The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.
I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface. These
aren't as clean as I would like and I'm planning to work on cleaning
some of this up, but I wanted to start by putting into the right form.
There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.
The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.
Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.
The downside of this change is that it is very, very verbose. I'm going
to work to improve that, but it is somewhat an implementation necessity
in C++ to do type erasure. =/ I discussed this design really extensively
with Eric and Hal prior to going down this path, and afterward showed
them the result. No one was really thrilled with it, but there doesn't
seem to be a substantially better alternative. Using a base class and
virtual method dispatch would make the code much shorter, but as
discussed in the update to the programmer's manual and elsewhere,
a polymorphic interface feels like the more principled approach even if
this is perhaps the least compelling example of it. ;]
Ultimately, there is still a lot more to be done here, but this was the
huge chunk that I couldn't really split things out of because this was
the interface change to TTI. I've tried to minimize all the other parts
of this. The follow up work should include at least:
1) Improving the TargetMachine interface by having it directly return
a TTI object. Because we have a non-pass object with value semantics
and an internal type erasure mechanism, we can narrow the interface
of the TargetMachine to *just* do what we need: build and return
a TTI object that we can then insert into the pass pipeline.
2) Make the TTI object be fully specialized for a particular function.
This will include splitting off a minimal form of it which is
sufficient for the inliner and the old pass manager.
3) Add a new pass manager analysis which produces TTI objects from the
target machine for each function. This may actually be done as part
of #2 in order to use the new analysis to implement #2.
4) Work on narrowing the API between TTI and the targets so that it is
easier to understand and less verbose to type erase.
5) Work on narrowing the API between TTI and its clients so that it is
easier to understand and less verbose to forward.
6) Try to improve the CRTP-based delegation. I feel like this code is
just a bit messy and exacerbating the complexity of implementing
the TTI in each target.
Many thanks to Eric and Hal for their help here. I ended up blocked on
this somewhat more abruptly than I expected, and so I appreciate getting
it sorted out very quickly.
Differential Revision: http://reviews.llvm.org/D7293
llvm-svn: 227669
2015-01-31 11:43:40 +08:00
|
|
|
if (!BranchesInfo.countLoop(
|
2015-02-01 20:01:35 +08:00
|
|
|
currentLoop, getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
|
|
|
|
*currentLoop->getHeader()->getParent()),
|
[PM] Change the core design of the TTI analysis to use a polymorphic
type erased interface and a single analysis pass rather than an
extremely complex analysis group.
The end result is that the TTI analysis can contain a type erased
implementation that supports the polymorphic TTI interface. We can build
one from a target-specific implementation or from a dummy one in the IR.
I've also factored all of the code into "mix-in"-able base classes,
including CRTP base classes to facilitate calling back up to the most
specialized form when delegating horizontally across the surface. These
aren't as clean as I would like and I'm planning to work on cleaning
some of this up, but I wanted to start by putting into the right form.
There are a number of reasons for this change, and this particular
design. The first and foremost reason is that an analysis group is
complete overkill, and the chaining delegation strategy was so opaque,
confusing, and high overhead that TTI was suffering greatly for it.
Several of the TTI functions had failed to be implemented in all places
because of the chaining-based delegation making there be no checking of
this. A few other functions were implemented with incorrect delegation.
The message to me was very clear working on this -- the delegation and
analysis group structure was too confusing to be useful here.
The other reason of course is that this is *much* more natural fit for
the new pass manager. This will lay the ground work for a type-erased
per-function info object that can look up the correct subtarget and even
cache it.
Yet another benefit is that this will significantly simplify the
interaction of the pass managers and the TargetMachine. See the future
work below.
The downside of this change is that it is very, very verbose. I'm going
to work to improve that, but it is somewhat an implementation necessity
in C++ to do type erasure. =/ I discussed this design really extensively
with Eric and Hal prior to going down this path, and afterward showed
them the result. No one was really thrilled with it, but there doesn't
seem to be a substantially better alternative. Using a base class and
virtual method dispatch would make the code much shorter, but as
discussed in the update to the programmer's manual and elsewhere,
a polymorphic interface feels like the more principled approach even if
this is perhaps the least compelling example of it. ;]
Ultimately, there is still a lot more to be done here, but this was the
huge chunk that I couldn't really split things out of because this was
the interface change to TTI. I've tried to minimize all the other parts
of this. The follow up work should include at least:
1) Improving the TargetMachine interface by having it directly return
a TTI object. Because we have a non-pass object with value semantics
and an internal type erasure mechanism, we can narrow the interface
of the TargetMachine to *just* do what we need: build and return
a TTI object that we can then insert into the pass pipeline.
2) Make the TTI object be fully specialized for a particular function.
This will include splitting off a minimal form of it which is
sufficient for the inliner and the old pass manager.
3) Add a new pass manager analysis which produces TTI objects from the
target machine for each function. This may actually be done as part
of #2 in order to use the new analysis to implement #2.
4) Work on narrowing the API between TTI and the targets so that it is
easier to understand and less verbose to type erase.
5) Work on narrowing the API between TTI and its clients so that it is
easier to understand and less verbose to forward.
6) Try to improve the CRTP-based delegation. I feel like this code is
just a bit messy and exacerbating the complexity of implementing
the TTI in each target.
Many thanks to Eric and Hal for their help here. I ended up blocked on
this somewhat more abruptly than I expected, and so I appreciate getting
it sorted out very quickly.
Differential Revision: http://reviews.llvm.org/D7293
llvm-svn: 227669
2015-01-31 11:43:40 +08:00
|
|
|
AC))
|
2012-01-11 16:40:51 +08:00
|
|
|
return false;
|
2007-07-31 07:07:10 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
// Loop over all of the basic blocks in the loop. If we find an interior
|
|
|
|
// block that is branching on a loop-invariant condition, we can unswitch this
|
|
|
|
// loop.
|
2012-04-10 13:14:37 +08:00
|
|
|
for (Loop::block_iterator I = currentLoop->block_begin(),
|
2010-04-06 05:18:32 +08:00
|
|
|
E = currentLoop->block_end(); I != E; ++I) {
|
2006-02-18 15:57:38 +08:00
|
|
|
TerminatorInst *TI = (*I)->getTerminator();
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
|
|
|
// If this isn't branching on an invariant condition, we can't unswitch
|
|
|
|
// it.
|
|
|
|
if (BI->isConditional()) {
|
|
|
|
// See if this, or some part of it, is loop invariant. If so, we can
|
|
|
|
// unswitch on it if we desire.
|
2012-04-10 13:14:37 +08:00
|
|
|
Value *LoopCond = FindLIVLoopCondition(BI->getCondition(),
|
2008-07-02 09:18:13 +08:00
|
|
|
currentLoop, Changed);
|
2015-06-23 13:31:09 +08:00
|
|
|
if (LoopCond &&
|
|
|
|
UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context), TI)) {
|
2006-02-18 15:57:38 +08:00
|
|
|
++NumBranches;
|
|
|
|
return true;
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
}
|
2006-02-18 15:57:38 +08:00
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
2012-04-10 13:14:37 +08:00
|
|
|
Value *LoopCond = FindLIVLoopCondition(SI->getCondition(),
|
2008-07-02 09:18:13 +08:00
|
|
|
currentLoop, Changed);
|
2012-04-10 13:14:37 +08:00
|
|
|
unsigned NumCases = SI->getNumCases();
|
SwitchInst refactoring.
The purpose of refactoring is to hide operand roles from SwitchInst user (programmer). If you want to play with operands directly, probably you will need lower level methods than SwitchInst ones (TerminatorInst or may be User). After this patch we can reorganize SwitchInst operands and successors as we want.
What was done:
1. Changed semantics of index inside the getCaseValue method:
getCaseValue(0) means "get first case", not a condition. Use getCondition() if you want to resolve the condition. I propose don't mix SwitchInst case indexing with low level indexing (TI successors indexing, User's operands indexing), since it may be dangerous.
2. By the same reason findCaseValue(ConstantInt*) returns actual number of case value. 0 means first case, not default. If there is no case with given value, ErrorIndex will returned.
3. Added getCaseSuccessor method. I propose to avoid usage of TerminatorInst::getSuccessor if you want to resolve case successor BB. Use getCaseSuccessor instead, since internal SwitchInst organization of operands/successors is hidden and may be changed in any moment.
4. Added resolveSuccessorIndex and resolveCaseIndex. The main purpose of these methods is to see how case successors are really mapped in TerminatorInst.
4.1 "resolveSuccessorIndex" was created if you need to level down from SwitchInst to TerminatorInst. It returns TerminatorInst's successor index for given case successor.
4.2 "resolveCaseIndex" converts low level successors index to case index that curresponds to the given successor.
Note: There are also related compatability fix patches for dragonegg, klee, llvm-gcc-4.0, llvm-gcc-4.2, safecode, clang.
llvm-svn: 149481
2012-02-01 15:49:51 +08:00
|
|
|
if (LoopCond && NumCases) {
|
2006-02-18 15:57:38 +08:00
|
|
|
// Find a value to unswitch on:
|
|
|
|
// FIXME: this should chose the most expensive case!
|
2011-06-03 14:27:15 +08:00
|
|
|
// FIXME: scan for a case with a non-critical edge?
|
2014-04-25 13:29:35 +08:00
|
|
|
Constant *UnswitchVal = nullptr;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2007-02-27 03:31:58 +08:00
|
|
|
// Do not process same value again and again.
|
2011-12-23 05:10:46 +08:00
|
|
|
// At this point we have some cases already unswitched and
|
|
|
|
// some not yet unswitched. Let's find the first not yet unswitched one.
|
2012-03-11 14:09:17 +08:00
|
|
|
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
|
2012-03-08 15:06:20 +08:00
|
|
|
i != e; ++i) {
|
2013-08-07 01:03:42 +08:00
|
|
|
Constant *UnswitchValCandidate = i.getCaseValue();
|
2012-01-15 17:44:07 +08:00
|
|
|
if (!BranchesInfo.isUnswitched(SI, UnswitchValCandidate)) {
|
2011-12-23 05:10:46 +08:00
|
|
|
UnswitchVal = UnswitchValCandidate;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2011-12-23 05:10:46 +08:00
|
|
|
if (!UnswitchVal)
|
2007-02-27 03:31:58 +08:00
|
|
|
continue;
|
|
|
|
|
2008-07-02 09:18:13 +08:00
|
|
|
if (UnswitchIfProfitable(LoopCond, UnswitchVal)) {
|
2006-02-18 15:57:38 +08:00
|
|
|
++NumSwitches;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
// Scan the instructions to check for unswitchable values.
|
2012-04-10 13:14:37 +08:00
|
|
|
for (BasicBlock::iterator BBI = (*I)->begin(), E = (*I)->end();
|
2006-02-18 15:57:38 +08:00
|
|
|
BBI != E; ++BBI)
|
|
|
|
if (SelectInst *SI = dyn_cast<SelectInst>(BBI)) {
|
2012-04-10 13:14:37 +08:00
|
|
|
Value *LoopCond = FindLIVLoopCondition(SI->getCondition(),
|
2008-07-02 09:18:13 +08:00
|
|
|
currentLoop, Changed);
|
2012-04-10 13:14:37 +08:00
|
|
|
if (LoopCond && UnswitchIfProfitable(LoopCond,
|
2009-08-01 01:39:07 +08:00
|
|
|
ConstantInt::getTrue(Context))) {
|
2006-02-18 15:57:38 +08:00
|
|
|
++NumSelects;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-04-20 02:07:02 +08:00
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2010-09-02 05:46:45 +08:00
|
|
|
/// isTrivialLoopExitBlock - Check to see if all paths from BB exit the
|
|
|
|
/// loop with no side effects (including infinite loops).
|
2006-02-16 06:03:36 +08:00
|
|
|
///
|
2010-09-02 05:46:45 +08:00
|
|
|
/// If true, we return true and set ExitBB to the block we
|
2006-02-16 06:03:36 +08:00
|
|
|
/// exit through.
|
|
|
|
///
|
|
|
|
static bool isTrivialLoopExitBlockHelper(Loop *L, BasicBlock *BB,
|
|
|
|
BasicBlock *&ExitBB,
|
|
|
|
std::set<BasicBlock*> &Visited) {
|
2006-02-17 14:39:56 +08:00
|
|
|
if (!Visited.insert(BB).second) {
|
2011-12-24 07:49:25 +08:00
|
|
|
// Already visited. Without more analysis, this could indicate an infinite
|
|
|
|
// loop.
|
2010-09-02 05:46:45 +08:00
|
|
|
return false;
|
2013-08-07 01:03:42 +08:00
|
|
|
}
|
|
|
|
if (!L->contains(BB)) {
|
2006-02-17 14:39:56 +08:00
|
|
|
// Otherwise, this is a loop exit, this is fine so long as this is the
|
|
|
|
// first exit.
|
2014-04-25 13:29:35 +08:00
|
|
|
if (ExitBB) return false;
|
2006-02-17 14:39:56 +08:00
|
|
|
ExitBB = BB;
|
2009-11-25 13:38:41 +08:00
|
|
|
return true;
|
2006-02-17 14:39:56 +08:00
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-17 14:39:56 +08:00
|
|
|
// Otherwise, this is an unvisited intra-loop node. Check all successors.
|
2014-07-22 01:06:51 +08:00
|
|
|
for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) {
|
2006-02-17 14:39:56 +08:00
|
|
|
// Check to see if the successor is a trivial loop exit.
|
2014-07-22 01:06:51 +08:00
|
|
|
if (!isTrivialLoopExitBlockHelper(L, *SI, ExitBB, Visited))
|
2006-02-17 14:39:56 +08:00
|
|
|
return false;
|
2006-02-10 10:30:37 +08:00
|
|
|
}
|
2006-02-16 06:03:36 +08:00
|
|
|
|
|
|
|
// Okay, everything after this looks good, check to make sure that this block
|
|
|
|
// doesn't include any side effects.
|
2006-02-16 06:52:05 +08:00
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
|
2009-05-06 14:49:50 +08:00
|
|
|
if (I->mayHaveSideEffects())
|
2006-02-16 06:03:36 +08:00
|
|
|
return false;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-16 06:03:36 +08:00
|
|
|
return true;
|
2006-02-10 10:30:37 +08:00
|
|
|
}
|
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
/// isTrivialLoopExitBlock - Return true if the specified block unconditionally
|
2012-04-10 13:14:37 +08:00
|
|
|
/// leads to an exit from the specified loop, and has no side-effects in the
|
2006-02-18 15:57:38 +08:00
|
|
|
/// process. If so, return the block that is exited to, otherwise return null.
|
2006-02-16 06:03:36 +08:00
|
|
|
static BasicBlock *isTrivialLoopExitBlock(Loop *L, BasicBlock *BB) {
|
|
|
|
std::set<BasicBlock*> Visited;
|
2010-09-02 05:46:45 +08:00
|
|
|
Visited.insert(L->getHeader()); // Branches to header make infinite loops.
|
2014-04-25 13:29:35 +08:00
|
|
|
BasicBlock *ExitBB = nullptr;
|
2006-02-16 06:03:36 +08:00
|
|
|
if (isTrivialLoopExitBlockHelper(L, BB, ExitBB, Visited))
|
|
|
|
return ExitBB;
|
2014-04-25 13:29:35 +08:00
|
|
|
return nullptr;
|
2006-02-16 06:03:36 +08:00
|
|
|
}
|
2006-02-10 10:30:37 +08:00
|
|
|
|
2006-02-10 09:24:09 +08:00
|
|
|
/// IsTrivialUnswitchCondition - Check to see if this unswitch condition is
|
|
|
|
/// trivial: that is, that the condition controls whether or not the loop does
|
|
|
|
/// anything at all. If this is a trivial condition, unswitching produces no
|
|
|
|
/// code duplications (equivalently, it produces a simpler loop and a new empty
|
|
|
|
/// loop, which gets deleted).
|
|
|
|
///
|
2006-02-22 14:37:14 +08:00
|
|
|
/// If this is a trivial condition, return true, otherwise return false. When
|
|
|
|
/// returning true, this sets Cond and Val to the condition that controls the
|
|
|
|
/// trivial condition: when Cond dynamically equals Val, the loop is known to
|
|
|
|
/// exit. Finally, this sets LoopExit to the BB that the loop exits to when
|
|
|
|
/// Cond == Val.
|
|
|
|
///
|
2008-07-02 09:18:13 +08:00
|
|
|
bool LoopUnswitch::IsTrivialUnswitchCondition(Value *Cond, Constant **Val,
|
|
|
|
BasicBlock **LoopExit) {
|
|
|
|
BasicBlock *Header = currentLoop->getHeader();
|
2006-02-16 06:52:05 +08:00
|
|
|
TerminatorInst *HeaderTerm = Header->getTerminator();
|
2009-07-22 08:24:57 +08:00
|
|
|
LLVMContext &Context = Header->getContext();
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2014-04-25 13:29:35 +08:00
|
|
|
BasicBlock *LoopExitBB = nullptr;
|
2006-02-16 06:52:05 +08:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(HeaderTerm)) {
|
|
|
|
// If the header block doesn't end with a conditional branch on Cond, we
|
|
|
|
// can't handle it.
|
|
|
|
if (!BI->isConditional() || BI->getCondition() != Cond)
|
|
|
|
return false;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
|
|
|
// Check to see if a successor of the branch is guaranteed to
|
|
|
|
// exit through a unique exit block without having any
|
2006-02-16 06:52:05 +08:00
|
|
|
// side-effects. If so, determine the value of Cond that causes it to do
|
|
|
|
// this.
|
2012-04-10 13:14:37 +08:00
|
|
|
if ((LoopExitBB = isTrivialLoopExitBlock(currentLoop,
|
2008-07-02 09:18:13 +08:00
|
|
|
BI->getSuccessor(0)))) {
|
2009-08-01 01:39:07 +08:00
|
|
|
if (Val) *Val = ConstantInt::getTrue(Context);
|
2012-04-10 13:14:37 +08:00
|
|
|
} else if ((LoopExitBB = isTrivialLoopExitBlock(currentLoop,
|
2008-07-02 09:18:13 +08:00
|
|
|
BI->getSuccessor(1)))) {
|
2009-08-01 01:39:07 +08:00
|
|
|
if (Val) *Val = ConstantInt::getFalse(Context);
|
2006-02-16 06:52:05 +08:00
|
|
|
}
|
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(HeaderTerm)) {
|
|
|
|
// If this isn't a switch on Cond, we can't handle it.
|
|
|
|
if (SI->getCondition() != Cond) return false;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-16 06:52:05 +08:00
|
|
|
// Check to see if a successor of the switch is guaranteed to go to the
|
2012-04-10 13:14:37 +08:00
|
|
|
// latch block or exit through a one exit block without having any
|
2006-02-16 06:52:05 +08:00
|
|
|
// side-effects. If so, determine the value of Cond that causes it to do
|
2012-04-10 13:14:37 +08:00
|
|
|
// this.
|
2011-12-23 05:10:46 +08:00
|
|
|
// Note that we can't trivially unswitch on the default case or
|
|
|
|
// on already unswitched cases.
|
2012-03-11 14:09:17 +08:00
|
|
|
for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
|
2012-03-08 15:06:20 +08:00
|
|
|
i != e; ++i) {
|
2013-08-07 01:03:42 +08:00
|
|
|
BasicBlock *LoopExitCandidate;
|
2012-04-10 13:14:37 +08:00
|
|
|
if ((LoopExitCandidate = isTrivialLoopExitBlock(currentLoop,
|
2012-03-08 15:06:20 +08:00
|
|
|
i.getCaseSuccessor()))) {
|
2006-02-16 06:52:05 +08:00
|
|
|
// Okay, we found a trivial case, remember the value that is trivial.
|
2013-08-07 01:03:42 +08:00
|
|
|
ConstantInt *CaseVal = i.getCaseValue();
|
2011-12-23 05:10:46 +08:00
|
|
|
|
|
|
|
// Check that it was not unswitched before, since already unswitched
|
|
|
|
// trivial vals are looks trivial too.
|
2012-01-15 17:44:07 +08:00
|
|
|
if (BranchesInfo.isUnswitched(SI, CaseVal))
|
2011-12-23 05:10:46 +08:00
|
|
|
continue;
|
|
|
|
LoopExitBB = LoopExitCandidate;
|
|
|
|
if (Val) *Val = CaseVal;
|
2006-02-16 06:52:05 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-12-23 05:10:46 +08:00
|
|
|
}
|
2015-07-16 06:41:13 +08:00
|
|
|
} else
|
|
|
|
return false;
|
2006-02-16 06:03:36 +08:00
|
|
|
|
2006-02-23 07:55:00 +08:00
|
|
|
// If we didn't find a single unique LoopExit block, or if the loop exit block
|
|
|
|
// contains phi nodes, this isn't trivial.
|
|
|
|
if (!LoopExitBB || isa<PHINode>(LoopExitBB->begin()))
|
2006-02-16 06:03:36 +08:00
|
|
|
return false; // Can't handle this.
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-16 06:52:05 +08:00
|
|
|
if (LoopExit) *LoopExit = LoopExitBB;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-10 09:24:09 +08:00
|
|
|
// We already know that nothing uses any scalar values defined inside of this
|
|
|
|
// loop. As such, we just have to check to see if this loop will execute any
|
|
|
|
// side-effecting instructions (e.g. stores, calls, volatile loads) in the
|
2006-02-16 06:03:36 +08:00
|
|
|
// part of the loop that the code *would* execute. We already checked the
|
|
|
|
// tail, check the header now.
|
2006-02-10 09:24:09 +08:00
|
|
|
for (BasicBlock::iterator I = Header->begin(), E = Header->end(); I != E; ++I)
|
2009-05-06 14:49:50 +08:00
|
|
|
if (I->mayHaveSideEffects())
|
2006-02-10 10:01:22 +08:00
|
|
|
return false;
|
|
|
|
return true;
|
2006-02-10 09:24:09 +08:00
|
|
|
}
|
|
|
|
|
2008-07-02 09:18:13 +08:00
|
|
|
/// UnswitchIfProfitable - We have found that we can unswitch currentLoop when
|
2006-02-11 08:43:37 +08:00
|
|
|
/// LoopCond == Val to simplify the loop. If we decide that this is profitable,
|
|
|
|
/// unswitch the loop, reprocess the pieces, then return true.
|
2015-06-23 13:31:09 +08:00
|
|
|
bool LoopUnswitch::UnswitchIfProfitable(Value *LoopCond, Constant *Val,
|
|
|
|
TerminatorInst *TI) {
|
2009-12-10 06:55:01 +08:00
|
|
|
Function *F = loopHeader->getParent();
|
2014-04-25 13:29:35 +08:00
|
|
|
Constant *CondVal = nullptr;
|
|
|
|
BasicBlock *ExitBlock = nullptr;
|
2012-04-30 17:23:48 +08:00
|
|
|
|
2010-04-03 10:23:43 +08:00
|
|
|
if (IsTrivialUnswitchCondition(LoopCond, &CondVal, &ExitBlock)) {
|
|
|
|
// If the condition is trivial, always unswitch. There is no code growth
|
|
|
|
// for this case.
|
2015-06-23 13:31:09 +08:00
|
|
|
UnswitchTrivialCondition(currentLoop, LoopCond, CondVal, ExitBlock, TI);
|
2010-04-03 10:23:43 +08:00
|
|
|
return true;
|
|
|
|
}
|
2008-09-05 02:55:13 +08:00
|
|
|
|
2010-04-03 10:23:43 +08:00
|
|
|
// Check to see if it would be profitable to unswitch current loop.
|
This change fixes three bugs in loop unswitching. This change causes an 81% speed-up on a benchmark that is based on EigenConvolutionKernel2D from Eigen3, where the lack of loop unswitching blocks hoisting of loads out of a nested loop (see bug 23816 for how loop unswitching and load hoisting are related).
Change 1: Unswitching on trivial conditions should always happen regardless of the computed unswitching cost, as really the cost is zero. While there is code to make that happen, the logic that checks the unswitching cost against a threshold was moved to an earlier point (revision 147935) than the point where trivial unswitching is detected, so trivial unswitching is currently blocked by the cost threshold. This change fixes that.
Change 2: Before revision 147935 (from 2012-01-11), the threshold parameter was a per-loop threshold. So an unswitching happened only if the cost of the unswitching was less than the threshold. In an indirect way (and I believe unintentionally), the logic for this since then has been that the threshold is an over-all budget across all loops for all loop unswitching done by a given LoopUnswitch loop pass object. So if an unswitching with cost 100 happens in one function, that in effect reduces the threshold from 100 to 0 for the loops even in another function. This persists for the lifetime of that loop pass object. This makes no difference for most small examples but it is important for large examples. This revision fixes that.
Change 3: The cost is currently calculated as std::min(NumInstructions, 5 * NumBlocks). So a loop with 2 blocks and a million instructions will have an unswitching cost of 10. I changed this to just NumInstructions, as it were before revision 147935, though I'm open to e.g. instead replacing std::min with std::max.
I've tried to make the change minimally invasive while staying with what I think was the original intent of the code.
Submitted on behalf of broune@.
llvm-svn: 240438
2015-06-24 02:26:50 +08:00
|
|
|
if (!BranchesInfo.CostAllowsUnswitching()) {
|
|
|
|
DEBUG(dbgs() << "NOT unswitching loop %"
|
|
|
|
<< currentLoop->getHeader()->getName()
|
|
|
|
<< " at non-trivial condition '" << *Val
|
|
|
|
<< "' == " << *LoopCond << "\n"
|
|
|
|
<< ". Cost too high.\n");
|
|
|
|
return false;
|
|
|
|
}
|
2007-06-06 08:21:03 +08:00
|
|
|
|
2010-04-03 10:23:43 +08:00
|
|
|
// Do not do non-trivial unswitch while optimizing for size.
|
2015-02-14 09:11:29 +08:00
|
|
|
if (OptimizeForSize || F->hasFnAttribute(Attribute::OptimizeForSize))
|
2010-04-03 10:23:43 +08:00
|
|
|
return false;
|
2008-07-02 09:18:13 +08:00
|
|
|
|
2015-06-23 13:31:09 +08:00
|
|
|
UnswitchNontrivialCondition(LoopCond, Val, currentLoop, TI);
|
2012-04-10 13:14:42 +08:00
|
|
|
return true;
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// CloneLoop - Recursively clone the specified loop and all of its children,
|
|
|
|
/// mapping the blocks with the specified map.
|
2010-10-13 09:36:30 +08:00
|
|
|
static Loop *CloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
|
2007-03-07 08:26:10 +08:00
|
|
|
LoopInfo *LI, LPPassManager *LPM) {
|
2004-04-20 02:07:02 +08:00
|
|
|
Loop *New = new Loop();
|
2007-03-07 08:26:10 +08:00
|
|
|
LPM->insertLoop(New, PL);
|
2004-04-20 02:07:02 +08:00
|
|
|
|
|
|
|
// Add all of the blocks in L to the new loop.
|
|
|
|
for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
|
|
|
|
I != E; ++I)
|
|
|
|
if (LI->getLoopFor(*I) == L)
|
2015-01-18 09:25:51 +08:00
|
|
|
New->addBasicBlockToLoop(cast<BasicBlock>(VM[*I]), *LI);
|
2004-04-20 02:07:02 +08:00
|
|
|
|
|
|
|
// Add all of the subloops to the new loop.
|
|
|
|
for (Loop::iterator I = L->begin(), E = L->end(); I != E; ++I)
|
2007-03-07 08:26:10 +08:00
|
|
|
CloneLoop(*I, New, VM, LI, LPM);
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
return New;
|
|
|
|
}
|
|
|
|
|
2015-06-23 13:31:09 +08:00
|
|
|
static void copyMetadata(Instruction *DstInst, const Instruction *SrcInst,
|
|
|
|
bool Swapped) {
|
|
|
|
if (!SrcInst || !SrcInst->hasMetadata())
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
|
|
|
SrcInst->getAllMetadata(MDs);
|
|
|
|
for (auto &MD : MDs) {
|
|
|
|
switch (MD.first) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case LLVMContext::MD_prof:
|
|
|
|
if (Swapped && MD.second->getNumOperands() == 3 &&
|
|
|
|
isa<MDString>(MD.second->getOperand(0))) {
|
|
|
|
MDString *MDName = cast<MDString>(MD.second->getOperand(0));
|
|
|
|
if (MDName->getString() == "branch_weights") {
|
|
|
|
auto *ValT = cast_or_null<ConstantAsMetadata>(
|
|
|
|
MD.second->getOperand(1))->getValue();
|
|
|
|
auto *ValF = cast_or_null<ConstantAsMetadata>(
|
|
|
|
MD.second->getOperand(2))->getValue();
|
|
|
|
assert(ValT && ValF && "Invalid Operands of branch_weights");
|
|
|
|
auto NewMD =
|
|
|
|
MDBuilder(DstInst->getParent()->getContext())
|
|
|
|
.createBranchWeights(cast<ConstantInt>(ValF)->getZExtValue(),
|
|
|
|
cast<ConstantInt>(ValT)->getZExtValue());
|
|
|
|
MD.second = NewMD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// fallthrough.
|
|
|
|
case LLVMContext::MD_dbg:
|
|
|
|
DstInst->setMetadata(MD.first, MD.second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-15 08:07:43 +08:00
|
|
|
/// EmitPreheaderBranchOnCondition - Emit a conditional branch on two values
|
|
|
|
/// if LIC == Val, branch to TrueDst, otherwise branch to FalseDest. Insert the
|
|
|
|
/// code immediately before InsertPt.
|
2007-06-28 08:49:00 +08:00
|
|
|
void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
|
|
|
|
BasicBlock *TrueDest,
|
|
|
|
BasicBlock *FalseDest,
|
2015-06-23 13:31:09 +08:00
|
|
|
Instruction *InsertPt,
|
|
|
|
TerminatorInst *TI) {
|
2006-02-15 08:07:43 +08:00
|
|
|
// Insert a conditional branch on LIC to the two preheaders. The original
|
|
|
|
// code is the true version and the new code is the false version.
|
|
|
|
Value *BranchVal = LIC;
|
2015-06-23 13:31:09 +08:00
|
|
|
bool Swapped = false;
|
2009-08-14 05:58:54 +08:00
|
|
|
if (!isa<ConstantInt>(Val) ||
|
|
|
|
Val->getType() != Type::getInt1Ty(LIC->getContext()))
|
2011-09-28 04:39:19 +08:00
|
|
|
BranchVal = new ICmpInst(InsertPt, ICmpInst::ICMP_EQ, LIC, Val);
|
2015-06-23 13:31:09 +08:00
|
|
|
else if (Val != ConstantInt::getTrue(Val->getContext())) {
|
2006-02-15 08:07:43 +08:00
|
|
|
// We want to enter the new loop when the condition is true.
|
|
|
|
std::swap(TrueDest, FalseDest);
|
2015-06-23 13:31:09 +08:00
|
|
|
Swapped = true;
|
|
|
|
}
|
2006-02-15 08:07:43 +08:00
|
|
|
|
|
|
|
// Insert the new branch.
|
2009-09-08 23:45:00 +08:00
|
|
|
BranchInst *BI = BranchInst::Create(TrueDest, FalseDest, BranchVal, InsertPt);
|
2015-06-23 13:31:09 +08:00
|
|
|
copyMetadata(BI, TI, Swapped);
|
2009-09-08 23:45:00 +08:00
|
|
|
|
|
|
|
// If either edge is critical, split it. This helps preserve LoopSimplify
|
|
|
|
// form for enclosing loops.
|
2015-01-19 20:12:00 +08:00
|
|
|
auto Options = CriticalEdgeSplittingOptions(DT, LI).setPreserveLCSSA();
|
2015-01-19 20:09:11 +08:00
|
|
|
SplitCriticalEdge(BI, 0, Options);
|
|
|
|
SplitCriticalEdge(BI, 1, Options);
|
2006-02-15 08:07:43 +08:00
|
|
|
}
|
|
|
|
|
2006-02-10 09:24:09 +08:00
|
|
|
/// UnswitchTrivialCondition - Given a loop that has a trivial unswitchable
|
|
|
|
/// condition in it (a cond branch from its header block to its latch block,
|
2012-04-10 13:14:37 +08:00
|
|
|
/// where the path through the loop that doesn't execute its body has no
|
2006-02-10 09:24:09 +08:00
|
|
|
/// side-effects), unswitch it. This doesn't involve any code duplication, just
|
|
|
|
/// moving the conditional branch outside of the loop and updating loop info.
|
2015-06-23 13:31:09 +08:00
|
|
|
void LoopUnswitch::UnswitchTrivialCondition(Loop *L, Value *Cond, Constant *Val,
|
|
|
|
BasicBlock *ExitBlock,
|
|
|
|
TerminatorInst *TI) {
|
2010-01-05 09:27:04 +08:00
|
|
|
DEBUG(dbgs() << "loop-unswitch: Trivial-Unswitch loop %"
|
2015-06-23 13:31:09 +08:00
|
|
|
<< loopHeader->getName() << " [" << L->getBlocks().size()
|
|
|
|
<< " blocks] in Function "
|
|
|
|
<< L->getHeader()->getParent()->getName() << " on cond: " << *Val
|
|
|
|
<< " == " << *Cond << "\n");
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-11 07:16:39 +08:00
|
|
|
// First step, split the preheader, so that we know that there is a safe place
|
2008-07-02 09:18:13 +08:00
|
|
|
// to insert the conditional branch. We will change loopPreheader to have a
|
2006-02-10 09:24:09 +08:00
|
|
|
// conditional branch on Cond.
|
2015-01-19 20:36:53 +08:00
|
|
|
BasicBlock *NewPH = SplitEdge(loopPreheader, loopHeader, DT, LI);
|
2006-02-10 09:24:09 +08:00
|
|
|
|
|
|
|
// Now that we have a place to insert the conditional branch, create a place
|
2006-02-10 10:01:22 +08:00
|
|
|
// to branch to: this is the exit block out of the loop that we should
|
|
|
|
// short-circuit to.
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-16 06:03:36 +08:00
|
|
|
// Split this block now, so that the loop maintains its exit block, and so
|
|
|
|
// that the jump from the preheader can execute the contents of the exit block
|
|
|
|
// without actually branching to it (the exit block should be dominated by the
|
|
|
|
// loop header, not the preheader).
|
2006-02-10 10:01:22 +08:00
|
|
|
assert(!L->contains(ExitBlock) && "Exit block is in the loop?");
|
2015-01-18 10:39:37 +08:00
|
|
|
BasicBlock *NewExit = SplitBlock(ExitBlock, ExitBlock->begin(), DT, LI);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
|
|
|
// Okay, now we have a position to branch from and a position to branch to,
|
2006-02-10 09:24:09 +08:00
|
|
|
// insert the new conditional branch.
|
2012-04-10 13:14:37 +08:00
|
|
|
EmitPreheaderBranchOnCondition(Cond, Val, NewExit, NewPH,
|
2015-06-23 13:31:09 +08:00
|
|
|
loopPreheader->getTerminator(), TI);
|
2008-07-02 09:18:13 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(loopPreheader->getTerminator(), L);
|
|
|
|
loopPreheader->getTerminator()->eraseFromParent();
|
2006-02-10 09:24:09 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
// We need to reprocess this loop, it could be unswitched again.
|
2007-07-31 07:07:10 +08:00
|
|
|
redoLoop = true;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-10 09:24:09 +08:00
|
|
|
// Now that we know that the loop is never entered when this condition is a
|
|
|
|
// particular value, rewrite the loop with this info. We know that this will
|
|
|
|
// at least eliminate the old branch.
|
2006-02-22 14:37:14 +08:00
|
|
|
RewriteLoopBodyWithConditionConstant(L, Cond, Val, false);
|
2006-02-14 09:01:41 +08:00
|
|
|
++NumTrivial;
|
2006-02-10 09:24:09 +08:00
|
|
|
}
|
|
|
|
|
2008-04-21 08:25:49 +08:00
|
|
|
/// SplitExitEdges - Split all of the edges from inside the loop to their exit
|
|
|
|
/// blocks. Update the appropriate Phi nodes as we do so.
|
2012-04-10 13:14:37 +08:00
|
|
|
void LoopUnswitch::SplitExitEdges(Loop *L,
|
2013-07-14 12:42:23 +08:00
|
|
|
const SmallVectorImpl<BasicBlock *> &ExitBlocks){
|
2007-10-06 06:29:34 +08:00
|
|
|
|
2006-02-10 09:24:09 +08:00
|
|
|
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
|
2006-02-11 07:16:39 +08:00
|
|
|
BasicBlock *ExitBlock = ExitBlocks[i];
|
2009-09-08 23:45:00 +08:00
|
|
|
SmallVector<BasicBlock *, 4> Preds(pred_begin(ExitBlock),
|
|
|
|
pred_end(ExitBlock));
|
2011-09-27 08:59:31 +08:00
|
|
|
|
2011-06-03 14:27:15 +08:00
|
|
|
// Although SplitBlockPredecessors doesn't preserve loop-simplify in
|
|
|
|
// general, if we call it on all predecessors of all exits then it does.
|
2015-01-29 07:06:47 +08:00
|
|
|
SplitBlockPredecessors(ExitBlock, Preds, ".us-lcssa",
|
|
|
|
/*AliasAnalysis*/ nullptr, DT, LI,
|
|
|
|
/*PreserveLCSSA*/ true);
|
2006-02-10 09:24:09 +08:00
|
|
|
}
|
2007-10-04 05:16:08 +08:00
|
|
|
}
|
|
|
|
|
2012-04-10 13:14:37 +08:00
|
|
|
/// UnswitchNontrivialCondition - We determined that the loop is profitable
|
|
|
|
/// to unswitch when LIC equal Val. Split it into loop versions and test the
|
2007-10-04 05:17:43 +08:00
|
|
|
/// condition outside of either loop. Return the loops created as Out1/Out2.
|
2012-04-10 13:14:42 +08:00
|
|
|
void LoopUnswitch::UnswitchNontrivialCondition(Value *LIC, Constant *Val,
|
2015-06-23 13:31:09 +08:00
|
|
|
Loop *L, TerminatorInst *TI) {
|
2008-07-02 09:18:13 +08:00
|
|
|
Function *F = loopHeader->getParent();
|
2010-01-05 09:27:04 +08:00
|
|
|
DEBUG(dbgs() << "loop-unswitch: Unswitching loop %"
|
2009-07-25 08:23:56 +08:00
|
|
|
<< loopHeader->getName() << " [" << L->getBlocks().size()
|
|
|
|
<< " blocks] in Function " << F->getName()
|
|
|
|
<< " when '" << *Val << "' == " << *LIC << "\n");
|
2007-10-04 05:16:08 +08:00
|
|
|
|
2011-02-11 14:08:28 +08:00
|
|
|
if (ScalarEvolution *SE = getAnalysisIfAvailable<ScalarEvolution>())
|
|
|
|
SE->forgetLoop(L);
|
|
|
|
|
2008-07-02 09:44:29 +08:00
|
|
|
LoopBlocks.clear();
|
|
|
|
NewBlocks.clear();
|
2007-10-04 05:16:08 +08:00
|
|
|
|
|
|
|
// First step, split the preheader and exit blocks, and add these blocks to
|
|
|
|
// the LoopBlocks list.
|
2015-01-19 20:36:53 +08:00
|
|
|
BasicBlock *NewPreheader = SplitEdge(loopPreheader, loopHeader, DT, LI);
|
2007-10-04 05:16:08 +08:00
|
|
|
LoopBlocks.push_back(NewPreheader);
|
|
|
|
|
|
|
|
// We want the loop to come after the preheader, but before the exit blocks.
|
|
|
|
LoopBlocks.insert(LoopBlocks.end(), L->block_begin(), L->block_end());
|
|
|
|
|
|
|
|
SmallVector<BasicBlock*, 8> ExitBlocks;
|
|
|
|
L->getUniqueExitBlocks(ExitBlocks);
|
|
|
|
|
|
|
|
// Split all of the edges from inside the loop to their exit blocks. Update
|
|
|
|
// the appropriate Phi nodes as we do so.
|
2008-07-04 01:37:52 +08:00
|
|
|
SplitExitEdges(L, ExitBlocks);
|
2007-10-04 05:16:08 +08:00
|
|
|
|
2006-02-11 07:16:39 +08:00
|
|
|
// The exit blocks may have been changed due to edge splitting, recompute.
|
|
|
|
ExitBlocks.clear();
|
2006-08-30 06:29:16 +08:00
|
|
|
L->getUniqueExitBlocks(ExitBlocks);
|
|
|
|
|
2006-02-11 07:16:39 +08:00
|
|
|
// Add exit blocks to the loop blocks.
|
|
|
|
LoopBlocks.insert(LoopBlocks.end(), ExitBlocks.begin(), ExitBlocks.end());
|
2004-04-20 02:07:02 +08:00
|
|
|
|
|
|
|
// Next step, clone all of the basic blocks that make up the loop (including
|
|
|
|
// the loop preheader and exit blocks), keeping track of the mapping between
|
|
|
|
// the instructions and blocks.
|
|
|
|
NewBlocks.reserve(LoopBlocks.size());
|
2010-10-13 09:36:30 +08:00
|
|
|
ValueToValueMapTy VMap;
|
2004-04-20 02:07:02 +08:00
|
|
|
for (unsigned i = 0, e = LoopBlocks.size(); i != e; ++i) {
|
2010-06-24 08:33:28 +08:00
|
|
|
BasicBlock *NewBB = CloneBasicBlock(LoopBlocks[i], VMap, ".us", F);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2010-04-06 05:16:25 +08:00
|
|
|
NewBlocks.push_back(NewBB);
|
2010-06-24 08:33:28 +08:00
|
|
|
VMap[LoopBlocks[i]] = NewBB; // Keep the BB mapping.
|
2010-04-06 05:16:25 +08:00
|
|
|
LPM->cloneBasicBlockSimpleAnalysis(LoopBlocks[i], NewBB, L);
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Splice the newly inserted blocks into the function right before the
|
|
|
|
// original preheader.
|
2010-04-06 05:16:25 +08:00
|
|
|
F->getBasicBlockList().splice(NewPreheader, F->getBasicBlockList(),
|
2004-04-20 02:07:02 +08:00
|
|
|
NewBlocks[0], F->end());
|
|
|
|
|
2014-09-07 20:44:26 +08:00
|
|
|
// FIXME: We could register any cloned assumptions instead of clearing the
|
|
|
|
// whole function's cache.
|
2015-01-04 20:03:27 +08:00
|
|
|
AC->clear();
|
2014-09-07 20:44:26 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
// Now we create the new Loop object for the versioned loop.
|
2010-06-24 08:33:28 +08:00
|
|
|
Loop *NewLoop = CloneLoop(L, L->getParentLoop(), VMap, LI, LPM);
|
2012-01-15 17:44:07 +08:00
|
|
|
|
|
|
|
// Recalculate unswitching quota, inherit simplified switches info for NewBB,
|
|
|
|
// Probably clone more loop-unswitch related loop properties.
|
|
|
|
BranchesInfo.cloneData(NewLoop, L, VMap);
|
|
|
|
|
2006-02-11 07:26:14 +08:00
|
|
|
Loop *ParentLoop = L->getParentLoop();
|
|
|
|
if (ParentLoop) {
|
2004-04-20 02:07:02 +08:00
|
|
|
// Make sure to add the cloned preheader and exit blocks to the parent loop
|
|
|
|
// as well.
|
2015-01-18 09:25:51 +08:00
|
|
|
ParentLoop->addBasicBlockToLoop(NewBlocks[0], *LI);
|
2006-02-11 07:26:14 +08:00
|
|
|
}
|
2011-09-27 08:59:31 +08:00
|
|
|
|
2006-02-11 07:26:14 +08:00
|
|
|
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
|
2010-06-24 08:33:28 +08:00
|
|
|
BasicBlock *NewExit = cast<BasicBlock>(VMap[ExitBlocks[i]]);
|
2006-02-18 08:55:32 +08:00
|
|
|
// The new exit block should be in the same loop as the old one.
|
|
|
|
if (Loop *ExitBBLoop = LI->getLoopFor(ExitBlocks[i]))
|
2015-01-18 09:25:51 +08:00
|
|
|
ExitBBLoop->addBasicBlockToLoop(NewExit, *LI);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-11 07:26:14 +08:00
|
|
|
assert(NewExit->getTerminator()->getNumSuccessors() == 1 &&
|
|
|
|
"Exit block should have been split to have one successor!");
|
|
|
|
BasicBlock *ExitSucc = NewExit->getTerminator()->getSuccessor(0);
|
2008-07-04 01:37:52 +08:00
|
|
|
|
2006-02-11 07:26:14 +08:00
|
|
|
// If the successor of the exit block had PHI nodes, add an entry for
|
|
|
|
// NewExit.
|
2013-08-07 01:03:42 +08:00
|
|
|
for (BasicBlock::iterator I = ExitSucc->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(I); ++I) {
|
2006-02-11 07:26:14 +08:00
|
|
|
Value *V = PN->getIncomingValueForBlock(ExitBlocks[i]);
|
2010-10-13 09:36:30 +08:00
|
|
|
ValueToValueMapTy::iterator It = VMap.find(V);
|
2010-06-24 08:33:28 +08:00
|
|
|
if (It != VMap.end()) V = It->second;
|
2006-02-11 07:26:14 +08:00
|
|
|
PN->addIncoming(V, NewExit);
|
|
|
|
}
|
2011-09-27 08:59:31 +08:00
|
|
|
|
|
|
|
if (LandingPadInst *LPad = NewExit->getLandingPadInst()) {
|
2013-08-07 01:03:42 +08:00
|
|
|
PHINode *PN = PHINode::Create(LPad->getType(), 0, "",
|
|
|
|
ExitSucc->getFirstInsertionPt());
|
2011-09-27 08:59:31 +08:00
|
|
|
|
2014-07-22 01:06:51 +08:00
|
|
|
for (pred_iterator I = pred_begin(ExitSucc), E = pred_end(ExitSucc);
|
|
|
|
I != E; ++I) {
|
|
|
|
BasicBlock *BB = *I;
|
2011-09-27 08:59:31 +08:00
|
|
|
LandingPadInst *LPI = BB->getLandingPadInst();
|
|
|
|
LPI->replaceAllUsesWith(PN);
|
|
|
|
PN->addIncoming(LPI, BB);
|
|
|
|
}
|
|
|
|
}
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Rewrite the code to refer to itself.
|
2008-04-26 00:53:59 +08:00
|
|
|
for (unsigned i = 0, e = NewBlocks.size(); i != e; ++i)
|
|
|
|
for (BasicBlock::iterator I = NewBlocks[i]->begin(),
|
|
|
|
E = NewBlocks[i]->end(); I != E; ++I)
|
2011-01-08 16:15:20 +08:00
|
|
|
RemapInstruction(I, VMap,RF_NoModuleLevelChanges|RF_IgnoreMissingEntries);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
// Rewrite the original preheader to select between versions of the loop.
|
2008-07-02 09:18:13 +08:00
|
|
|
BranchInst *OldBR = cast<BranchInst>(loopPreheader->getTerminator());
|
2006-02-15 08:07:43 +08:00
|
|
|
assert(OldBR->isUnconditional() && OldBR->getSuccessor(0) == LoopBlocks[0] &&
|
2004-04-20 02:07:02 +08:00
|
|
|
"Preheader splitting did not work correctly!");
|
|
|
|
|
2006-02-15 08:07:43 +08:00
|
|
|
// Emit the new branch that selects between the two versions of this loop.
|
2015-06-23 13:31:09 +08:00
|
|
|
EmitPreheaderBranchOnCondition(LIC, Val, NewBlocks[0], LoopBlocks[0], OldBR,
|
|
|
|
TI);
|
2007-07-31 16:03:26 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(OldBR, L);
|
2007-09-21 07:45:50 +08:00
|
|
|
OldBR->eraseFromParent();
|
2007-08-02 23:25:57 +08:00
|
|
|
|
2006-02-18 15:57:38 +08:00
|
|
|
LoopProcessWorklist.push_back(NewLoop);
|
2007-07-31 07:07:10 +08:00
|
|
|
redoLoop = true;
|
2004-04-20 02:07:02 +08:00
|
|
|
|
2010-04-20 13:09:16 +08:00
|
|
|
// Keep a WeakVH holding onto LIC. If the first call to RewriteLoopBody
|
|
|
|
// deletes the instruction (for example by simplifying a PHI that feeds into
|
|
|
|
// the condition that we're unswitching on), we don't rewrite the second
|
|
|
|
// iteration.
|
|
|
|
WeakVH LICHandle(LIC);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
// Now we rewrite the original code to know that the condition is true and the
|
|
|
|
// new code to know that the condition is false.
|
2010-04-06 05:16:25 +08:00
|
|
|
RewriteLoopBodyWithConditionConstant(L, LIC, Val, false);
|
2008-07-04 01:37:52 +08:00
|
|
|
|
2010-04-20 13:09:16 +08:00
|
|
|
// It's possible that simplifying one loop could cause the other to be
|
|
|
|
// changed to another value or a constant. If its a constant, don't simplify
|
|
|
|
// it.
|
|
|
|
if (!LoopProcessWorklist.empty() && LoopProcessWorklist.back() == NewLoop &&
|
|
|
|
LICHandle && !isa<Constant>(LICHandle))
|
|
|
|
RewriteLoopBodyWithConditionConstant(NewLoop, LICHandle, Val, true);
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
/// RemoveFromWorklist - Remove all instances of I from the worklist vector
|
|
|
|
/// specified.
|
2012-04-10 13:14:37 +08:00
|
|
|
static void RemoveFromWorklist(Instruction *I,
|
2006-02-17 08:31:07 +08:00
|
|
|
std::vector<Instruction*> &Worklist) {
|
2012-10-17 03:52:32 +08:00
|
|
|
|
|
|
|
Worklist.erase(std::remove(Worklist.begin(), Worklist.end(), I),
|
|
|
|
Worklist.end());
|
2006-02-17 08:31:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// ReplaceUsesOfWith - When we find that I really equals V, remove I from the
|
|
|
|
/// program, replacing all uses with V and update the worklist.
|
2012-04-10 13:14:37 +08:00
|
|
|
static void ReplaceUsesOfWith(Instruction *I, Value *V,
|
2007-07-31 16:03:26 +08:00
|
|
|
std::vector<Instruction*> &Worklist,
|
|
|
|
Loop *L, LPPassManager *LPM) {
|
2010-01-05 09:27:04 +08:00
|
|
|
DEBUG(dbgs() << "Replace with '" << *V << "': " << *I);
|
2006-02-17 08:31:07 +08:00
|
|
|
|
|
|
|
// Add uses to the worklist, which may be dead now.
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
|
|
|
|
if (Instruction *Use = dyn_cast<Instruction>(I->getOperand(i)))
|
|
|
|
Worklist.push_back(Use);
|
|
|
|
|
|
|
|
// Add users to the worklist which may be simplified now.
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : I->users())
|
|
|
|
Worklist.push_back(cast<Instruction>(U));
|
2007-07-31 16:03:26 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(I, L);
|
2006-02-17 08:31:07 +08:00
|
|
|
RemoveFromWorklist(I, Worklist);
|
2007-09-21 07:45:50 +08:00
|
|
|
I->replaceAllUsesWith(V);
|
|
|
|
I->eraseFromParent();
|
2006-02-17 08:31:07 +08:00
|
|
|
++NumSimplify;
|
|
|
|
}
|
|
|
|
|
2006-02-11 08:43:37 +08:00
|
|
|
// RewriteLoopBodyWithConditionConstant - We know either that the value LIC has
|
|
|
|
// the value specified by Val in the specified loop, or we know it does NOT have
|
|
|
|
// that value. Rewrite any uses of LIC or of properties correlated to it.
|
2004-04-20 02:07:02 +08:00
|
|
|
void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
|
2006-02-11 08:43:37 +08:00
|
|
|
Constant *Val,
|
|
|
|
bool IsEqual) {
|
2006-02-10 09:24:09 +08:00
|
|
|
assert(!isa<Constant>(LIC) && "Why are we unswitching on a constant?");
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2004-04-20 02:07:02 +08:00
|
|
|
// FIXME: Support correlated properties, like:
|
|
|
|
// for (...)
|
|
|
|
// if (li1 < li2)
|
|
|
|
// ...
|
|
|
|
// if (li1 > li2)
|
|
|
|
// ...
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-10 10:30:37 +08:00
|
|
|
// FOLD boolean conditions (X|LIC), (X&LIC). Fold conditional branches,
|
|
|
|
// selects, switches.
|
2006-02-17 08:31:07 +08:00
|
|
|
std::vector<Instruction*> Worklist;
|
2009-07-22 08:24:57 +08:00
|
|
|
LLVMContext &Context = Val->getContext();
|
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// If we know that LIC == Val, or that LIC == NotVal, just replace uses of LIC
|
|
|
|
// in the loop with the appropriate one directly.
|
2009-08-14 05:58:54 +08:00
|
|
|
if (IsEqual || (isa<ConstantInt>(Val) &&
|
2010-02-16 00:12:20 +08:00
|
|
|
Val->getType()->isIntegerTy(1))) {
|
2006-02-22 14:37:14 +08:00
|
|
|
Value *Replacement;
|
|
|
|
if (IsEqual)
|
|
|
|
Replacement = Val;
|
|
|
|
else
|
2012-04-10 13:14:37 +08:00
|
|
|
Replacement = ConstantInt::get(Type::getInt1Ty(Val->getContext()),
|
2007-01-12 12:24:46 +08:00
|
|
|
!cast<ConstantInt>(Val)->getZExtValue());
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : LIC->users()) {
|
|
|
|
Instruction *UI = dyn_cast<Instruction>(U);
|
|
|
|
if (!UI || !L->contains(UI))
|
2011-05-25 07:12:57 +08:00
|
|
|
continue;
|
2014-03-09 11:16:01 +08:00
|
|
|
Worklist.push_back(UI);
|
2011-05-25 07:12:57 +08:00
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2013-08-07 01:03:42 +08:00
|
|
|
for (std::vector<Instruction*>::iterator UI = Worklist.begin(),
|
|
|
|
UE = Worklist.end(); UI != UE; ++UI)
|
2012-04-10 13:14:37 +08:00
|
|
|
(*UI)->replaceUsesOfWith(LIC, Replacement);
|
|
|
|
|
2010-04-06 05:18:32 +08:00
|
|
|
SimplifyCode(Worklist, L);
|
|
|
|
return;
|
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2010-04-06 05:18:32 +08:00
|
|
|
// Otherwise, we don't know the precise value of LIC, but we do know that it
|
|
|
|
// is certainly NOT "Val". As such, simplify any uses in the loop that we
|
|
|
|
// can. This case occurs when we unswitch switch statements.
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : LIC->users()) {
|
|
|
|
Instruction *UI = dyn_cast<Instruction>(U);
|
|
|
|
if (!UI || !L->contains(UI))
|
2010-04-06 05:18:32 +08:00
|
|
|
continue;
|
2006-02-17 08:31:07 +08:00
|
|
|
|
2014-03-09 11:16:01 +08:00
|
|
|
Worklist.push_back(UI);
|
2006-02-17 08:31:07 +08:00
|
|
|
|
2012-04-10 13:14:37 +08:00
|
|
|
// TODO: We could do other simplifications, for example, turning
|
2010-04-06 05:18:32 +08:00
|
|
|
// 'icmp eq LIC, Val' -> false.
|
|
|
|
|
|
|
|
// If we know that LIC is not Val, use this info to simplify code.
|
2014-03-09 11:16:01 +08:00
|
|
|
SwitchInst *SI = dyn_cast<SwitchInst>(UI);
|
2014-04-25 13:29:35 +08:00
|
|
|
if (!SI || !isa<ConstantInt>(Val)) continue;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-03-08 15:06:20 +08:00
|
|
|
SwitchInst::CaseIt DeadCase = SI->findCaseValue(cast<ConstantInt>(Val));
|
SwitchInst refactoring.
The purpose of refactoring is to hide operand roles from SwitchInst user (programmer). If you want to play with operands directly, probably you will need lower level methods than SwitchInst ones (TerminatorInst or may be User). After this patch we can reorganize SwitchInst operands and successors as we want.
What was done:
1. Changed semantics of index inside the getCaseValue method:
getCaseValue(0) means "get first case", not a condition. Use getCondition() if you want to resolve the condition. I propose don't mix SwitchInst case indexing with low level indexing (TI successors indexing, User's operands indexing), since it may be dangerous.
2. By the same reason findCaseValue(ConstantInt*) returns actual number of case value. 0 means first case, not default. If there is no case with given value, ErrorIndex will returned.
3. Added getCaseSuccessor method. I propose to avoid usage of TerminatorInst::getSuccessor if you want to resolve case successor BB. Use getCaseSuccessor instead, since internal SwitchInst organization of operands/successors is hidden and may be changed in any moment.
4. Added resolveSuccessorIndex and resolveCaseIndex. The main purpose of these methods is to see how case successors are really mapped in TerminatorInst.
4.1 "resolveSuccessorIndex" was created if you need to level down from SwitchInst to TerminatorInst. It returns TerminatorInst's successor index for given case successor.
4.2 "resolveCaseIndex" converts low level successors index to case index that curresponds to the given successor.
Note: There are also related compatability fix patches for dragonegg, klee, llvm-gcc-4.0, llvm-gcc-4.2, safecode, clang.
llvm-svn: 149481
2012-02-01 15:49:51 +08:00
|
|
|
// Default case is live for multiple values.
|
2012-03-11 14:09:17 +08:00
|
|
|
if (DeadCase == SI->case_default()) continue;
|
2012-04-10 13:14:37 +08:00
|
|
|
|
|
|
|
// Found a dead case value. Don't remove PHI nodes in the
|
2010-04-06 05:18:32 +08:00
|
|
|
// successor if they become single-entry, those PHI nodes may
|
|
|
|
// be in the Users list.
|
2011-06-03 14:27:15 +08:00
|
|
|
|
2011-05-25 07:12:57 +08:00
|
|
|
BasicBlock *Switch = SI->getParent();
|
2012-03-08 15:06:20 +08:00
|
|
|
BasicBlock *SISucc = DeadCase.getCaseSuccessor();
|
2011-05-25 07:12:57 +08:00
|
|
|
BasicBlock *Latch = L->getLoopLatch();
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2012-01-15 17:44:07 +08:00
|
|
|
BranchesInfo.setUnswitched(SI, Val);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2011-06-03 14:27:15 +08:00
|
|
|
if (!SI->findCaseDest(SISucc)) continue; // Edge is critical.
|
2011-05-26 02:17:13 +08:00
|
|
|
// If the DeadCase successor dominates the loop latch, then the
|
|
|
|
// transformation isn't safe since it will delete the sole predecessor edge
|
|
|
|
// to the latch.
|
|
|
|
if (Latch && DT->dominates(SISucc, Latch))
|
|
|
|
continue;
|
2011-05-25 07:12:57 +08:00
|
|
|
|
2010-04-06 05:18:32 +08:00
|
|
|
// FIXME: This is a hack. We need to keep the successor around
|
|
|
|
// and hooked up so as to preserve the loop structure, because
|
|
|
|
// trying to update it is complicated. So instead we preserve the
|
|
|
|
// loop structure and put the block on a dead code path.
|
2015-01-19 20:36:53 +08:00
|
|
|
SplitEdge(Switch, SISucc, DT, LI);
|
2010-04-06 05:18:32 +08:00
|
|
|
// Compute the successors instead of relying on the return value
|
|
|
|
// of SplitEdge, since it may have split the switch successor
|
|
|
|
// after PHI nodes.
|
2012-03-08 15:06:20 +08:00
|
|
|
BasicBlock *NewSISucc = DeadCase.getCaseSuccessor();
|
2010-04-06 05:18:32 +08:00
|
|
|
BasicBlock *OldSISucc = *succ_begin(NewSISucc);
|
|
|
|
// Create an "unreachable" destination.
|
|
|
|
BasicBlock *Abort = BasicBlock::Create(Context, "us-unreachable",
|
|
|
|
Switch->getParent(),
|
|
|
|
OldSISucc);
|
|
|
|
new UnreachableInst(Context, Abort);
|
|
|
|
// Force the new case destination to branch to the "unreachable"
|
|
|
|
// block while maintaining a (dead) CFG edge to the old block.
|
|
|
|
NewSISucc->getTerminator()->eraseFromParent();
|
|
|
|
BranchInst::Create(Abort, OldSISucc,
|
|
|
|
ConstantInt::getTrue(Context), NewSISucc);
|
|
|
|
// Release the PHI operands for this edge.
|
|
|
|
for (BasicBlock::iterator II = NewSISucc->begin();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(II); ++II)
|
|
|
|
PN->setIncomingValue(PN->getBasicBlockIndex(Switch),
|
|
|
|
UndefValue::get(PN->getType()));
|
|
|
|
// Tell the domtree about the new block. We don't fully update the
|
|
|
|
// domtree here -- instead we force it to do a full recomputation
|
|
|
|
// after the pass is complete -- but we do need to inform it of
|
|
|
|
// new blocks.
|
|
|
|
if (DT)
|
|
|
|
DT->addNewBlock(Abort, NewSISucc);
|
2006-02-17 08:31:07 +08:00
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2007-07-31 16:03:26 +08:00
|
|
|
SimplifyCode(Worklist, L);
|
2006-02-18 15:57:38 +08:00
|
|
|
}
|
|
|
|
|
2009-09-10 01:57:16 +08:00
|
|
|
/// SimplifyCode - Okay, now that we have simplified some instructions in the
|
2006-02-18 15:57:38 +08:00
|
|
|
/// loop, walk over it and constant prop, dce, and fold control flow where
|
|
|
|
/// possible. Note that this is effectively a very simple loop-structure-aware
|
|
|
|
/// optimizer. During processing of this loop, L could very well be deleted, so
|
|
|
|
/// it must not be used.
|
|
|
|
///
|
|
|
|
/// FIXME: When the loop optimizer is more mature, separate this out to a new
|
|
|
|
/// pass.
|
|
|
|
///
|
2007-07-31 16:03:26 +08:00
|
|
|
void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
|
2015-03-10 10:37:25 +08:00
|
|
|
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
|
2006-02-17 08:31:07 +08:00
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Instruction *I = Worklist.back();
|
|
|
|
Worklist.pop_back();
|
2010-11-24 04:24:21 +08:00
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Simple DCE.
|
|
|
|
if (isInstructionTriviallyDead(I)) {
|
2010-01-05 09:27:04 +08:00
|
|
|
DEBUG(dbgs() << "Remove dead instruction '" << *I);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Add uses to the worklist, which may be dead now.
|
|
|
|
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
|
|
|
|
if (Instruction *Use = dyn_cast<Instruction>(I->getOperand(i)))
|
|
|
|
Worklist.push_back(Use);
|
2007-07-31 16:03:26 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(I, L);
|
2006-02-17 08:31:07 +08:00
|
|
|
RemoveFromWorklist(I, Worklist);
|
2007-09-21 07:45:50 +08:00
|
|
|
I->eraseFromParent();
|
2006-02-17 08:31:07 +08:00
|
|
|
++NumSimplify;
|
|
|
|
continue;
|
|
|
|
}
|
2010-11-19 03:59:41 +08:00
|
|
|
|
2010-04-20 13:33:18 +08:00
|
|
|
// See if instruction simplification can hack this up. This is common for
|
|
|
|
// things like "select false, X, Y" after unswitching made the condition be
|
2012-05-20 09:32:09 +08:00
|
|
|
// 'false'. TODO: update the domtree properly so we can pass it here.
|
2015-03-10 10:37:25 +08:00
|
|
|
if (Value *V = SimplifyInstruction(I, DL))
|
2010-11-19 03:59:41 +08:00
|
|
|
if (LI->replacementPreservesLCSSAForm(I, V)) {
|
|
|
|
ReplaceUsesOfWith(I, V, Worklist, L, LPM);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Special case hacks that appear commonly in unswitched code.
|
2010-04-20 13:33:18 +08:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
|
2006-02-17 08:31:07 +08:00
|
|
|
if (BI->isUnconditional()) {
|
|
|
|
// If BI's parent is the only pred of the successor, fold the two blocks
|
|
|
|
// together.
|
|
|
|
BasicBlock *Pred = BI->getParent();
|
|
|
|
BasicBlock *Succ = BI->getSuccessor(0);
|
|
|
|
BasicBlock *SinglePred = Succ->getSinglePredecessor();
|
|
|
|
if (!SinglePred) continue; // Nothing to do.
|
|
|
|
assert(SinglePred == Pred && "CFG broken");
|
|
|
|
|
2012-04-10 13:14:37 +08:00
|
|
|
DEBUG(dbgs() << "Merging blocks: " << Pred->getName() << " <- "
|
2009-07-25 08:23:56 +08:00
|
|
|
<< Succ->getName() << "\n");
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Resolve any single entry PHI nodes in Succ.
|
|
|
|
while (PHINode *PN = dyn_cast<PHINode>(Succ->begin()))
|
2007-07-31 16:03:26 +08:00
|
|
|
ReplaceUsesOfWith(PN, PN->getIncomingValue(0), Worklist, L, LPM);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2011-06-23 17:09:15 +08:00
|
|
|
// If Succ has any successors with PHI nodes, update them to have
|
|
|
|
// entries coming from Pred instead of Succ.
|
|
|
|
Succ->replaceAllUsesWith(Pred);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Move all of the successor contents from Succ to Pred.
|
|
|
|
Pred->getInstList().splice(BI, Succ->getInstList(), Succ->begin(),
|
|
|
|
Succ->end());
|
2007-07-31 16:03:26 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(BI, L);
|
2007-09-21 07:45:50 +08:00
|
|
|
BI->eraseFromParent();
|
2006-02-17 08:31:07 +08:00
|
|
|
RemoveFromWorklist(BI, Worklist);
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2006-02-17 08:31:07 +08:00
|
|
|
// Remove Succ from the loop tree.
|
|
|
|
LI->removeBlock(Succ);
|
2007-07-31 16:03:26 +08:00
|
|
|
LPM->deleteSimpleAnalysisValue(Succ, L);
|
2007-09-21 07:45:50 +08:00
|
|
|
Succ->eraseFromParent();
|
2006-02-18 09:27:45 +08:00
|
|
|
++NumSimplify;
|
2010-04-20 13:33:18 +08:00
|
|
|
continue;
|
2010-04-06 05:18:32 +08:00
|
|
|
}
|
2012-04-10 13:14:37 +08:00
|
|
|
|
2010-04-20 13:33:18 +08:00
|
|
|
continue;
|
2006-02-17 08:31:07 +08:00
|
|
|
}
|
|
|
|
}
|
2004-04-20 02:07:02 +08:00
|
|
|
}
|