2002-05-21 20:50:24 +00:00
|
|
|
//===- SimplifyCFG.cpp - Code to perform CFG simplification ---------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-05-21 20:50:24 +00:00
|
|
|
//
|
2002-10-08 21:36:33 +00:00
|
|
|
// Peephole optimize the CFG.
|
2002-05-21 20:50:24 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-06-20 01:13:18 +00:00
|
|
|
#define DEBUG_TYPE "simplifycfg"
|
2002-05-21 20:50:24 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2004-02-11 03:36:04 +00:00
|
|
|
#include "llvm/Constants.h"
|
|
|
|
#include "llvm/Instructions.h"
|
2004-02-24 05:38:11 +00:00
|
|
|
#include "llvm/Type.h"
|
2007-01-19 21:13:56 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2002-05-21 20:50:24 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2007-01-30 23:46:24 +00:00
|
|
|
#include "llvm/Analysis/ConstantFolding.h"
|
2005-09-19 23:49:37 +00:00
|
|
|
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
|
2007-02-13 02:10:56 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2007-04-02 01:44:59 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2008-06-12 21:15:59 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2002-05-21 20:50:24 +00:00
|
|
|
#include <algorithm>
|
|
|
|
#include <functional>
|
2004-02-24 07:23:58 +00:00
|
|
|
#include <set>
|
2004-10-18 04:07:22 +00:00
|
|
|
#include <map>
|
2004-01-09 06:12:26 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2008-06-12 21:15:59 +00:00
|
|
|
STATISTIC(NumSpeculations, "Number of speculative executed instructions");
|
|
|
|
|
2005-08-03 00:19:45 +00:00
|
|
|
/// SafeToMergeTerminators - Return true if it is safe to merge these two
|
|
|
|
/// terminator instructions together.
|
|
|
|
///
|
|
|
|
static bool SafeToMergeTerminators(TerminatorInst *SI1, TerminatorInst *SI2) {
|
|
|
|
if (SI1 == SI2) return false; // Can't merge with self!
|
|
|
|
|
|
|
|
// It is not safe to merge these two switch instructions if they have a common
|
|
|
|
// successor, and if that successor has a PHI node, and if *that* PHI node has
|
|
|
|
// conflicting incoming values from the two switch blocks.
|
|
|
|
BasicBlock *SI1BB = SI1->getParent();
|
|
|
|
BasicBlock *SI2BB = SI2->getParent();
|
2007-04-02 01:44:59 +00:00
|
|
|
SmallPtrSet<BasicBlock*, 16> SI1Succs(succ_begin(SI1BB), succ_end(SI1BB));
|
2005-08-03 00:19:45 +00:00
|
|
|
|
|
|
|
for (succ_iterator I = succ_begin(SI2BB), E = succ_end(SI2BB); I != E; ++I)
|
|
|
|
if (SI1Succs.count(*I))
|
|
|
|
for (BasicBlock::iterator BBI = (*I)->begin();
|
|
|
|
isa<PHINode>(BBI); ++BBI) {
|
|
|
|
PHINode *PN = cast<PHINode>(BBI);
|
|
|
|
if (PN->getIncomingValueForBlock(SI1BB) !=
|
|
|
|
PN->getIncomingValueForBlock(SI2BB))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// AddPredecessorToBlock - Update PHI nodes in Succ to indicate that there will
|
|
|
|
/// now be entries in it from the 'NewPred' block. The values that will be
|
|
|
|
/// flowing into the PHI nodes will be the same as those coming in from
|
|
|
|
/// ExistPred, an existing predecessor of Succ.
|
|
|
|
static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
|
|
|
|
BasicBlock *ExistPred) {
|
|
|
|
assert(std::find(succ_begin(ExistPred), succ_end(ExistPred), Succ) !=
|
|
|
|
succ_end(ExistPred) && "ExistPred is not a predecessor of Succ!");
|
|
|
|
if (!isa<PHINode>(Succ->begin())) return; // Quick exit if nothing to do
|
|
|
|
|
2008-07-13 22:23:11 +00:00
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator I = Succ->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(I)); ++I)
|
|
|
|
PN->addIncoming(PN->getIncomingValueForBlock(ExistPred), NewPred);
|
2005-08-03 00:19:45 +00:00
|
|
|
}
|
|
|
|
|
2005-08-03 00:29:26 +00:00
|
|
|
// CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an
|
|
|
|
// almost-empty BB ending in an unconditional branch to Succ, into succ.
|
2002-05-21 20:50:24 +00:00
|
|
|
//
|
|
|
|
// Assumption: Succ is the single successor for BB.
|
|
|
|
//
|
2005-08-03 00:29:26 +00:00
|
|
|
static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
|
2002-05-21 20:50:24 +00:00
|
|
|
assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!");
|
2002-09-24 00:09:26 +00:00
|
|
|
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
DOUT << "Looking to fold " << BB->getNameStart() << " into "
|
|
|
|
<< Succ->getNameStart() << "\n";
|
|
|
|
// Shortcut, if there is only a single predecessor is must be BB and merging
|
|
|
|
// is always safe
|
|
|
|
if (Succ->getSinglePredecessor()) return true;
|
|
|
|
|
|
|
|
typedef SmallPtrSet<Instruction*, 16> InstrSet;
|
|
|
|
InstrSet BBPHIs;
|
|
|
|
|
|
|
|
// Make a list of all phi nodes in BB
|
|
|
|
BasicBlock::iterator BBI = BB->begin();
|
|
|
|
while (isa<PHINode>(*BBI)) BBPHIs.insert(BBI++);
|
|
|
|
|
|
|
|
// Make a list of the predecessors of BB
|
|
|
|
typedef SmallPtrSet<BasicBlock*, 16> BlockSet;
|
|
|
|
BlockSet BBPreds(pred_begin(BB), pred_end(BB));
|
|
|
|
|
|
|
|
// Use that list to make another list of common predecessors of BB and Succ
|
|
|
|
BlockSet CommonPreds;
|
|
|
|
for (pred_iterator PI = pred_begin(Succ), PE = pred_end(Succ);
|
|
|
|
PI != PE; ++PI)
|
|
|
|
if (BBPreds.count(*PI))
|
|
|
|
CommonPreds.insert(*PI);
|
|
|
|
|
|
|
|
// Shortcut, if there are no common predecessors, merging is always safe
|
2008-08-14 18:13:49 +00:00
|
|
|
if (CommonPreds.empty())
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Look at all the phi nodes in Succ, to see if they present a conflict when
|
|
|
|
// merging these blocks
|
|
|
|
for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
|
|
|
|
|
|
|
// If the incoming value from BB is again a PHINode in
|
|
|
|
// BB which has the same incoming value for *PI as PN does, we can
|
|
|
|
// merge the phi nodes and then the blocks can still be merged
|
|
|
|
PHINode *BBPN = dyn_cast<PHINode>(PN->getIncomingValueForBlock(BB));
|
|
|
|
if (BBPN && BBPN->getParent() == BB) {
|
|
|
|
for (BlockSet::iterator PI = CommonPreds.begin(), PE = CommonPreds.end();
|
|
|
|
PI != PE; PI++) {
|
|
|
|
if (BBPN->getIncomingValueForBlock(*PI)
|
|
|
|
!= PN->getIncomingValueForBlock(*PI)) {
|
|
|
|
DOUT << "Can't fold, phi node " << *PN->getNameStart() << " in "
|
|
|
|
<< Succ->getNameStart() << " is conflicting with "
|
|
|
|
<< BBPN->getNameStart() << " with regard to common predecessor "
|
|
|
|
<< (*PI)->getNameStart() << "\n";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Remove this phinode from the list of phis in BB, since it has been
|
|
|
|
// handled.
|
|
|
|
BBPHIs.erase(BBPN);
|
|
|
|
} else {
|
|
|
|
Value* Val = PN->getIncomingValueForBlock(BB);
|
|
|
|
for (BlockSet::iterator PI = CommonPreds.begin(), PE = CommonPreds.end();
|
|
|
|
PI != PE; PI++) {
|
|
|
|
// See if the incoming value for the common predecessor is equal to the
|
|
|
|
// one for BB, in which case this phi node will not prevent the merging
|
|
|
|
// of the block.
|
|
|
|
if (Val != PN->getIncomingValueForBlock(*PI)) {
|
|
|
|
DOUT << "Can't fold, phi node " << *PN->getNameStart() << " in "
|
|
|
|
<< Succ->getNameStart() << " is conflicting with regard to common "
|
|
|
|
<< "predecessor " << (*PI)->getNameStart() << "\n";
|
|
|
|
return false;
|
2005-08-03 00:38:27 +00:00
|
|
|
}
|
|
|
|
}
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
}
|
2005-08-03 00:38:27 +00:00
|
|
|
}
|
2002-05-21 20:50:24 +00:00
|
|
|
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
// If there are any other phi nodes in BB that don't have a phi node in Succ
|
|
|
|
// to merge with, they must be moved to Succ completely. However, for any
|
|
|
|
// predecessors of Succ, branches will be added to the phi node that just
|
|
|
|
// point to itself. So, for any common predecessors, this must not cause
|
|
|
|
// conflicts.
|
|
|
|
for (InstrSet::iterator I = BBPHIs.begin(), E = BBPHIs.end();
|
|
|
|
I != E; I++) {
|
|
|
|
PHINode *PN = cast<PHINode>(*I);
|
|
|
|
for (BlockSet::iterator PI = CommonPreds.begin(), PE = CommonPreds.end();
|
|
|
|
PI != PE; PI++)
|
|
|
|
if (PN->getIncomingValueForBlock(*PI) != PN) {
|
|
|
|
DOUT << "Can't fold, phi node " << *PN->getNameStart() << " in "
|
|
|
|
<< BB->getNameStart() << " is conflicting with regard to common "
|
|
|
|
<< "predecessor " << (*PI)->getNameStart() << "\n";
|
2005-12-03 18:25:58 +00:00
|
|
|
return false;
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
}
|
2005-08-03 00:59:12 +00:00
|
|
|
}
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
|
2005-12-03 18:25:58 +00:00
|
|
|
return true;
|
2002-05-21 20:50:24 +00:00
|
|
|
}
|
|
|
|
|
2005-08-03 00:11:16 +00:00
|
|
|
/// TryToSimplifyUncondBranchFromEmptyBlock - BB contains an unconditional
|
|
|
|
/// branch to Succ, and contains no instructions other than PHI nodes and the
|
|
|
|
/// branch. If possible, eliminate BB.
|
|
|
|
static bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB,
|
|
|
|
BasicBlock *Succ) {
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
// Check to see if merging these blocks would cause conflicts for any of the
|
|
|
|
// phi nodes in BB or Succ. If not, we can safely merge.
|
2005-08-03 00:29:26 +00:00
|
|
|
if (!CanPropagatePredecessorsForPHIs(BB, Succ)) return false;
|
2005-08-03 00:11:16 +00:00
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Killing Trivial BB: \n" << *BB;
|
2005-08-03 00:11:16 +00:00
|
|
|
|
2005-08-03 00:29:26 +00:00
|
|
|
if (isa<PHINode>(Succ->begin())) {
|
|
|
|
// If there is more than one pred of succ, and there are PHI nodes in
|
|
|
|
// the successor, then we need to add incoming edges for the PHI nodes
|
|
|
|
//
|
2008-02-18 07:42:56 +00:00
|
|
|
const SmallVector<BasicBlock*, 16> BBPreds(pred_begin(BB), pred_end(BB));
|
2005-08-03 00:29:26 +00:00
|
|
|
|
|
|
|
// Loop over all of the PHI nodes in the successor of BB.
|
|
|
|
for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
|
|
|
|
PHINode *PN = cast<PHINode>(I);
|
|
|
|
Value *OldVal = PN->removeIncomingValue(BB, false);
|
|
|
|
assert(OldVal && "No entry in PHI for Pred BB!");
|
|
|
|
|
2005-08-03 00:38:27 +00:00
|
|
|
// If this incoming value is one of the PHI nodes in BB, the new entries
|
|
|
|
// in the PHI node are the entries from the old PHI.
|
2005-08-03 00:29:26 +00:00
|
|
|
if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
|
|
|
|
PHINode *OldValPN = cast<PHINode>(OldVal);
|
|
|
|
for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i)
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
// Note that, since we are merging phi nodes and BB and Succ might
|
|
|
|
// have common predecessors, we could end up with a phi node with
|
|
|
|
// identical incoming branches. This will be cleaned up later (and
|
|
|
|
// will trigger asserts if we try to clean it up now, without also
|
|
|
|
// simplifying the corresponding conditional branch).
|
2005-08-03 00:29:26 +00:00
|
|
|
PN->addIncoming(OldValPN->getIncomingValue(i),
|
|
|
|
OldValPN->getIncomingBlock(i));
|
|
|
|
} else {
|
2008-02-18 07:42:56 +00:00
|
|
|
// Add an incoming value for each of the new incoming values.
|
|
|
|
for (unsigned i = 0, e = BBPreds.size(); i != e; ++i)
|
|
|
|
PN->addIncoming(OldVal, BBPreds[i]);
|
2005-08-03 00:29:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-03 00:11:16 +00:00
|
|
|
if (isa<PHINode>(&BB->front())) {
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 16>
|
2005-08-03 00:11:16 +00:00
|
|
|
OldSuccPreds(pred_begin(Succ), pred_end(Succ));
|
|
|
|
|
|
|
|
// Move all PHI nodes in BB to Succ if they are alive, otherwise
|
|
|
|
// delete them.
|
|
|
|
while (PHINode *PN = dyn_cast<PHINode>(&BB->front()))
|
2005-08-03 00:38:27 +00:00
|
|
|
if (PN->use_empty()) {
|
|
|
|
// Just remove the dead phi. This happens if Succ's PHIs were the only
|
|
|
|
// users of the PHI nodes.
|
|
|
|
PN->eraseFromParent();
|
2005-08-03 00:11:16 +00:00
|
|
|
} else {
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
// The instruction is alive, so this means that BB must dominate all
|
|
|
|
// predecessors of Succ (Since all uses of the PN are after its
|
|
|
|
// definition, so in Succ or a block dominated by Succ. If a predecessor
|
|
|
|
// of Succ would not be dominated by BB, PN would violate the def before
|
|
|
|
// use SSA demand). Therefore, we can simply move the phi node to the
|
|
|
|
// next block.
|
2005-08-03 00:23:42 +00:00
|
|
|
Succ->getInstList().splice(Succ->begin(),
|
|
|
|
BB->getInstList(), BB->begin());
|
2005-08-03 00:11:16 +00:00
|
|
|
|
|
|
|
// We need to add new entries for the PHI node to account for
|
|
|
|
// predecessors of Succ that the PHI node does not take into
|
Restucture a part of the SimplifyCFG pass and include a testcase.
The SimplifyCFG pass looks at basic blocks that contain only phi nodes,
followed by an unconditional branch. In a lot of cases, such a block (BB) can
be merged into their successor (Succ).
This merging is performed by TryToSimplifyUncondBranchFromEmptyBlock. It does
this by taking all phi nodes in the succesor block Succ and expanding them to
include the predecessors of BB. Furthermore, any phi nodes in BB are moved to
Succ and expanded to include the predecessors of Succ as well.
Before attempting this merge, CanPropagatePredecessorsForPHIs checks to see if
all phi nodes can be properly merged. All functional changes are made to
this function, only comments were updated in
TryToSimplifyUncondBranchFromEmptyBlock.
In the original code, CanPropagatePredecessorsForPHIs looks quite convoluted
and more like stack of checks added to handle different kinds of situations
than a comprehensive check. In particular the first check in the function did
some value checking for the case that BB and Succ have a common predecessor,
while the last check in the function simply rejected all cases where BB and
Succ have a common predecessor. The first check was still useful in the case
that BB did not contain any phi nodes at all, though, so it was not completely
useless.
Now, CanPropagatePredecessorsForPHIs is restructured to to look a lot more
similar to the code that actually performs the merge. Both functions now look
at the same phi nodes in about the same order. Any conflicts (phi nodes with
different values for the same source) that could arise from merging or moving
phi nodes are detected. If no conflicts are found, the merge can happen.
Apart from only restructuring the checks, two main changes in functionality
happened.
Firstly, the old code rejected blocks with common predecessors in most cases.
The new code performs some extra checks so common predecessors can be handled
in a lot of cases. Wherever common predecessors still pose problems, the
blocks are left untouched.
Secondly, the old code rejected the merge when values (phi nodes) from BB were
used in any other place than Succ. However, it does not seem that there is any
situation that would require this check. Even more, this can be proven.
Consider that BB is a block containing of a single phi node "%a" and a branch
to Succ. Now, since the definition of %a will dominate all of its uses, BB
will dominate all blocks that use %a. Furthermore, since the branch from BB to
Succ is unconditional, Succ will also dominate all uses of %a.
Now, assume that one predecessor of Succ is not dominated by BB (and thus not
dominated by Succ). Since at least one use of %a (but in reality all of them)
is reachable from Succ, you could end up at a use of %a without passing
through it's definition in BB (by coming from X through Succ). This is a
contradiction, meaning that our original assumption is wrong. Thus, all
predecessors of Succ must also be dominated by BB (and thus also by Succ).
This means that moving the phi node %a from BB to Succ does not pose any
problems when the two blocks are merged, and any use checks are not needed.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51478 91177308-0d34-0410-b5e6-96231b3b80d8
2008-05-23 09:09:41 +00:00
|
|
|
// account. At this point, since we know that BB dominated succ and all
|
|
|
|
// of its predecessors, this means that we should any newly added
|
|
|
|
// incoming edges should use the PHI node itself as the value for these
|
|
|
|
// edges, because they are loop back edges.
|
2005-08-03 00:11:16 +00:00
|
|
|
for (unsigned i = 0, e = OldSuccPreds.size(); i != e; ++i)
|
|
|
|
if (OldSuccPreds[i] != BB)
|
|
|
|
PN->addIncoming(PN, OldSuccPreds[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Everything that jumped to BB now goes to Succ.
|
|
|
|
BB->replaceAllUsesWith(Succ);
|
2007-02-11 01:37:51 +00:00
|
|
|
if (!Succ->hasName()) Succ->takeName(BB);
|
2005-08-03 00:11:16 +00:00
|
|
|
BB->eraseFromParent(); // Delete the old basic block.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2004-02-11 03:36:04 +00:00
|
|
|
/// GetIfCondition - Given a basic block (BB) with two predecessors (and
|
|
|
|
/// presumably PHI nodes in it), check to see if the merge at this block is due
|
|
|
|
/// to an "if condition". If so, return the boolean condition that determines
|
|
|
|
/// which entry into BB will be taken. Also, return by references the block
|
|
|
|
/// that will be entered from if the condition is true, and the block that will
|
|
|
|
/// be entered if the condition is false.
|
2005-04-21 23:48:37 +00:00
|
|
|
///
|
2004-02-11 03:36:04 +00:00
|
|
|
///
|
|
|
|
static Value *GetIfCondition(BasicBlock *BB,
|
|
|
|
BasicBlock *&IfTrue, BasicBlock *&IfFalse) {
|
|
|
|
assert(std::distance(pred_begin(BB), pred_end(BB)) == 2 &&
|
|
|
|
"Function can only handle blocks with 2 predecessors!");
|
|
|
|
BasicBlock *Pred1 = *pred_begin(BB);
|
|
|
|
BasicBlock *Pred2 = *++pred_begin(BB);
|
|
|
|
|
|
|
|
// We can only handle branches. Other control flow will be lowered to
|
|
|
|
// branches if possible anyway.
|
|
|
|
if (!isa<BranchInst>(Pred1->getTerminator()) ||
|
|
|
|
!isa<BranchInst>(Pred2->getTerminator()))
|
|
|
|
return 0;
|
|
|
|
BranchInst *Pred1Br = cast<BranchInst>(Pred1->getTerminator());
|
|
|
|
BranchInst *Pred2Br = cast<BranchInst>(Pred2->getTerminator());
|
|
|
|
|
|
|
|
// Eliminate code duplication by ensuring that Pred1Br is conditional if
|
|
|
|
// either are.
|
|
|
|
if (Pred2Br->isConditional()) {
|
|
|
|
// If both branches are conditional, we don't have an "if statement". In
|
|
|
|
// reality, we could transform this case, but since the condition will be
|
|
|
|
// required anyway, we stand no chance of eliminating it, so the xform is
|
|
|
|
// probably not profitable.
|
|
|
|
if (Pred1Br->isConditional())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::swap(Pred1, Pred2);
|
|
|
|
std::swap(Pred1Br, Pred2Br);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Pred1Br->isConditional()) {
|
|
|
|
// If we found a conditional branch predecessor, make sure that it branches
|
|
|
|
// to BB and Pred2Br. If it doesn't, this isn't an "if statement".
|
|
|
|
if (Pred1Br->getSuccessor(0) == BB &&
|
|
|
|
Pred1Br->getSuccessor(1) == Pred2) {
|
|
|
|
IfTrue = Pred1;
|
|
|
|
IfFalse = Pred2;
|
|
|
|
} else if (Pred1Br->getSuccessor(0) == Pred2 &&
|
|
|
|
Pred1Br->getSuccessor(1) == BB) {
|
|
|
|
IfTrue = Pred2;
|
|
|
|
IfFalse = Pred1;
|
|
|
|
} else {
|
|
|
|
// We know that one arm of the conditional goes to BB, so the other must
|
|
|
|
// go somewhere unrelated, and this must not be an "if statement".
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The only thing we have to watch out for here is to make sure that Pred2
|
|
|
|
// doesn't have incoming edges from other blocks. If it does, the condition
|
|
|
|
// doesn't dominate BB.
|
|
|
|
if (++pred_begin(Pred2) != pred_end(Pred2))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return Pred1Br->getCondition();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ok, if we got here, both predecessors end with an unconditional branch to
|
|
|
|
// BB. Don't panic! If both blocks only have a single (identical)
|
|
|
|
// predecessor, and THAT is a conditional branch, then we're all ok!
|
|
|
|
if (pred_begin(Pred1) == pred_end(Pred1) ||
|
|
|
|
++pred_begin(Pred1) != pred_end(Pred1) ||
|
|
|
|
pred_begin(Pred2) == pred_end(Pred2) ||
|
|
|
|
++pred_begin(Pred2) != pred_end(Pred2) ||
|
|
|
|
*pred_begin(Pred1) != *pred_begin(Pred2))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Otherwise, if this is a conditional branch, then we can use it!
|
|
|
|
BasicBlock *CommonPred = *pred_begin(Pred1);
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator())) {
|
|
|
|
assert(BI->isConditional() && "Two successors but not conditional?");
|
|
|
|
if (BI->getSuccessor(0) == Pred1) {
|
|
|
|
IfTrue = Pred1;
|
|
|
|
IfFalse = Pred2;
|
|
|
|
} else {
|
|
|
|
IfTrue = Pred2;
|
|
|
|
IfFalse = Pred1;
|
|
|
|
}
|
|
|
|
return BI->getCondition();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// If we have a merge point of an "if condition" as accepted above, return true
|
|
|
|
// if the specified value dominates the block. We don't handle the true
|
|
|
|
// generality of domination here, just a special case which works well enough
|
|
|
|
// for us.
|
2004-10-14 05:13:36 +00:00
|
|
|
//
|
|
|
|
// If AggressiveInsts is non-null, and if V does not dominate BB, we check to
|
|
|
|
// see if V (which must be an instruction) is cheap to compute and is
|
|
|
|
// non-trapping. If both are true, the instruction is inserted into the set and
|
|
|
|
// true is returned.
|
|
|
|
static bool DominatesMergePoint(Value *V, BasicBlock *BB,
|
|
|
|
std::set<Instruction*> *AggressiveInsts) {
|
2004-04-09 22:50:22 +00:00
|
|
|
Instruction *I = dyn_cast<Instruction>(V);
|
2006-10-20 00:42:07 +00:00
|
|
|
if (!I) {
|
|
|
|
// Non-instructions all dominate instructions, but not all constantexprs
|
|
|
|
// can be executed unconditionally.
|
|
|
|
if (ConstantExpr *C = dyn_cast<ConstantExpr>(V))
|
|
|
|
if (C->canTrap())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
2004-04-09 22:50:22 +00:00
|
|
|
BasicBlock *PBB = I->getParent();
|
|
|
|
|
2005-02-27 06:18:25 +00:00
|
|
|
// We don't want to allow weird loops that might have the "if condition" in
|
2004-04-09 22:50:22 +00:00
|
|
|
// the bottom of this block.
|
|
|
|
if (PBB == BB) return false;
|
|
|
|
|
|
|
|
// If this instruction is defined in a block that contains an unconditional
|
|
|
|
// branch to BB, then it must be in the 'conditional' part of the "if
|
|
|
|
// statement".
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator()))
|
|
|
|
if (BI->isUnconditional() && BI->getSuccessor(0) == BB) {
|
2004-10-14 05:13:36 +00:00
|
|
|
if (!AggressiveInsts) return false;
|
2004-04-09 22:50:22 +00:00
|
|
|
// Okay, it looks like the instruction IS in the "condition". Check to
|
|
|
|
// see if its a cheap instruction to unconditionally compute, and if it
|
|
|
|
// only uses stuff defined outside of the condition. If so, hoist it out.
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
default: return false; // Cannot hoist this out safely.
|
|
|
|
case Instruction::Load:
|
|
|
|
// We can hoist loads that are non-volatile and obviously cannot trap.
|
|
|
|
if (cast<LoadInst>(I)->isVolatile())
|
|
|
|
return false;
|
|
|
|
if (!isa<AllocaInst>(I->getOperand(0)) &&
|
2004-07-18 00:32:14 +00:00
|
|
|
!isa<Constant>(I->getOperand(0)))
|
2004-04-09 22:50:22 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Finally, we have to check to make sure there are no instructions
|
|
|
|
// before the load in its basic block, as we are going to hoist the loop
|
|
|
|
// out to its predecessor.
|
|
|
|
if (PBB->begin() != BasicBlock::iterator(I))
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
|
|
|
case Instruction::Shl:
|
2006-11-08 06:47:33 +00:00
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
2006-12-23 06:05:41 +00:00
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
2008-01-03 07:25:26 +00:00
|
|
|
if (I->getOperand(0)->getType()->isFPOrFPVector())
|
|
|
|
return false; // FP arithmetic might trap.
|
2004-04-09 22:50:22 +00:00
|
|
|
break; // These are all cheap and non-trapping instructions.
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-04-09 22:50:22 +00:00
|
|
|
// Okay, we can only really hoist these out if their operands are not
|
|
|
|
// defined in the conditional region.
|
2008-06-10 22:03:26 +00:00
|
|
|
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i)
|
|
|
|
if (!DominatesMergePoint(*i, BB, 0))
|
2004-04-09 22:50:22 +00:00
|
|
|
return false;
|
2004-10-14 05:13:36 +00:00
|
|
|
// Okay, it's safe to do this! Remember this instruction.
|
|
|
|
AggressiveInsts->insert(I);
|
2004-04-09 22:50:22 +00:00
|
|
|
}
|
2004-02-11 03:36:04 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2002-05-21 20:50:24 +00:00
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
// GatherConstantSetEQs - Given a potentially 'or'd together collection of
|
|
|
|
// icmp_eq instructions that compare a value against a constant, return the
|
|
|
|
// value being compared, and stick the constant into the Values vector.
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
static Value *GatherConstantSetEQs(Value *V, std::vector<ConstantInt*> &Values){
|
2008-02-20 11:26:25 +00:00
|
|
|
if (Instruction *Inst = dyn_cast<Instruction>(V)) {
|
2006-12-23 06:05:41 +00:00
|
|
|
if (Inst->getOpcode() == Instruction::ICmp &&
|
|
|
|
cast<ICmpInst>(Inst)->getPredicate() == ICmpInst::ICMP_EQ) {
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(1))) {
|
2004-02-24 05:38:11 +00:00
|
|
|
Values.push_back(C);
|
|
|
|
return Inst->getOperand(0);
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
} else if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(0))) {
|
2004-02-24 05:38:11 +00:00
|
|
|
Values.push_back(C);
|
|
|
|
return Inst->getOperand(1);
|
|
|
|
}
|
|
|
|
} else if (Inst->getOpcode() == Instruction::Or) {
|
|
|
|
if (Value *LHS = GatherConstantSetEQs(Inst->getOperand(0), Values))
|
|
|
|
if (Value *RHS = GatherConstantSetEQs(Inst->getOperand(1), Values))
|
|
|
|
if (LHS == RHS)
|
|
|
|
return LHS;
|
|
|
|
}
|
2008-02-20 11:26:25 +00:00
|
|
|
}
|
2004-02-24 05:38:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// GatherConstantSetNEs - Given a potentially 'and'd together collection of
|
|
|
|
// setne instructions that compare a value against a constant, return the value
|
|
|
|
// being compared, and stick the constant into the Values vector.
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
static Value *GatherConstantSetNEs(Value *V, std::vector<ConstantInt*> &Values){
|
2008-02-20 11:26:25 +00:00
|
|
|
if (Instruction *Inst = dyn_cast<Instruction>(V)) {
|
2006-12-23 06:05:41 +00:00
|
|
|
if (Inst->getOpcode() == Instruction::ICmp &&
|
|
|
|
cast<ICmpInst>(Inst)->getPredicate() == ICmpInst::ICMP_NE) {
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(1))) {
|
2004-02-24 05:38:11 +00:00
|
|
|
Values.push_back(C);
|
|
|
|
return Inst->getOperand(0);
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
} else if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(0))) {
|
2004-02-24 05:38:11 +00:00
|
|
|
Values.push_back(C);
|
|
|
|
return Inst->getOperand(1);
|
|
|
|
}
|
|
|
|
} else if (Inst->getOpcode() == Instruction::And) {
|
|
|
|
if (Value *LHS = GatherConstantSetNEs(Inst->getOperand(0), Values))
|
|
|
|
if (Value *RHS = GatherConstantSetNEs(Inst->getOperand(1), Values))
|
|
|
|
if (LHS == RHS)
|
|
|
|
return LHS;
|
|
|
|
}
|
2008-02-20 11:26:25 +00:00
|
|
|
}
|
2004-02-24 05:38:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// GatherValueComparisons - If the specified Cond is an 'and' or 'or' of a
|
|
|
|
/// bunch of comparisons of one value against constants, return the value and
|
|
|
|
/// the constants being compared.
|
|
|
|
static bool GatherValueComparisons(Instruction *Cond, Value *&CompVal,
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
std::vector<ConstantInt*> &Values) {
|
2004-02-24 05:38:11 +00:00
|
|
|
if (Cond->getOpcode() == Instruction::Or) {
|
|
|
|
CompVal = GatherConstantSetEQs(Cond, Values);
|
|
|
|
|
|
|
|
// Return true to indicate that the condition is true if the CompVal is
|
|
|
|
// equal to one of the constants.
|
|
|
|
return true;
|
|
|
|
} else if (Cond->getOpcode() == Instruction::And) {
|
|
|
|
CompVal = GatherConstantSetNEs(Cond, Values);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
// Return false to indicate that the condition is false if the CompVal is
|
|
|
|
// equal to one of the constants.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// ErasePossiblyDeadInstructionTree - If the specified instruction is dead and
|
|
|
|
/// has no side effects, nuke it. If it uses any instructions that become dead
|
|
|
|
/// because the instruction is now gone, nuke them too.
|
|
|
|
static void ErasePossiblyDeadInstructionTree(Instruction *I) {
|
2006-08-03 21:40:24 +00:00
|
|
|
if (!isInstructionTriviallyDead(I)) return;
|
|
|
|
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<Instruction*, 16> InstrsToInspect;
|
2006-08-03 21:40:24 +00:00
|
|
|
InstrsToInspect.push_back(I);
|
|
|
|
|
|
|
|
while (!InstrsToInspect.empty()) {
|
|
|
|
I = InstrsToInspect.back();
|
|
|
|
InstrsToInspect.pop_back();
|
|
|
|
|
|
|
|
if (!isInstructionTriviallyDead(I)) continue;
|
|
|
|
|
|
|
|
// If I is in the work list multiple times, remove previous instances.
|
|
|
|
for (unsigned i = 0, e = InstrsToInspect.size(); i != e; ++i)
|
|
|
|
if (InstrsToInspect[i] == I) {
|
|
|
|
InstrsToInspect.erase(InstrsToInspect.begin()+i);
|
|
|
|
--i, --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add operands of dead instruction to worklist.
|
2008-06-10 22:03:26 +00:00
|
|
|
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i)
|
|
|
|
if (Instruction *OpI = dyn_cast<Instruction>(*i))
|
2006-08-03 21:40:24 +00:00
|
|
|
InstrsToInspect.push_back(OpI);
|
|
|
|
|
|
|
|
// Remove dead instruction.
|
|
|
|
I->eraseFromParent();
|
2004-02-24 05:38:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
// isValueEqualityComparison - Return true if the specified terminator checks to
|
|
|
|
// see if a value is equal to constant integer value.
|
|
|
|
static Value *isValueEqualityComparison(TerminatorInst *TI) {
|
2004-03-16 19:45:22 +00:00
|
|
|
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
|
|
|
// Do not permit merging of large switch instructions into their
|
|
|
|
// predecessors unless there is only one predecessor.
|
|
|
|
if (SI->getNumSuccessors() * std::distance(pred_begin(SI->getParent()),
|
|
|
|
pred_end(SI->getParent())) > 128)
|
|
|
|
return 0;
|
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
return SI->getCondition();
|
2004-03-16 19:45:22 +00:00
|
|
|
}
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI))
|
|
|
|
if (BI->isConditional() && BI->getCondition()->hasOneUse())
|
2006-12-23 06:05:41 +00:00
|
|
|
if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition()))
|
|
|
|
if ((ICI->getPredicate() == ICmpInst::ICMP_EQ ||
|
|
|
|
ICI->getPredicate() == ICmpInst::ICMP_NE) &&
|
|
|
|
isa<ConstantInt>(ICI->getOperand(1)))
|
|
|
|
return ICI->getOperand(0);
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Given a value comparison instruction, decode all of the 'cases' that it
|
|
|
|
// represents and return the 'default' block.
|
|
|
|
static BasicBlock *
|
2005-04-21 23:48:37 +00:00
|
|
|
GetValueEqualityComparisonCases(TerminatorInst *TI,
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
std::vector<std::pair<ConstantInt*,
|
|
|
|
BasicBlock*> > &Cases) {
|
|
|
|
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
|
|
|
Cases.reserve(SI->getNumCases());
|
|
|
|
for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i)
|
2005-02-26 18:33:28 +00:00
|
|
|
Cases.push_back(std::make_pair(SI->getCaseValue(i), SI->getSuccessor(i)));
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
return SI->getDefaultDest();
|
|
|
|
}
|
|
|
|
|
|
|
|
BranchInst *BI = cast<BranchInst>(TI);
|
2006-12-23 06:05:41 +00:00
|
|
|
ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());
|
|
|
|
Cases.push_back(std::make_pair(cast<ConstantInt>(ICI->getOperand(1)),
|
|
|
|
BI->getSuccessor(ICI->getPredicate() ==
|
|
|
|
ICmpInst::ICMP_NE)));
|
|
|
|
return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-24 14:36:04 +00:00
|
|
|
// EliminateBlockCases - Given a vector of bb/value pairs, remove any entries
|
2005-02-24 06:17:52 +00:00
|
|
|
// in the list that match the specified block.
|
2005-04-21 23:48:37 +00:00
|
|
|
static void EliminateBlockCases(BasicBlock *BB,
|
2005-02-24 06:17:52 +00:00
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > &Cases) {
|
|
|
|
for (unsigned i = 0, e = Cases.size(); i != e; ++i)
|
|
|
|
if (Cases[i].second == BB) {
|
|
|
|
Cases.erase(Cases.begin()+i);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ValuesOverlap - Return true if there are any keys in C1 that exist in C2 as
|
|
|
|
// well.
|
|
|
|
static bool
|
|
|
|
ValuesOverlap(std::vector<std::pair<ConstantInt*, BasicBlock*> > &C1,
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > &C2) {
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > *V1 = &C1, *V2 = &C2;
|
|
|
|
|
|
|
|
// Make V1 be smaller than V2.
|
|
|
|
if (V1->size() > V2->size())
|
|
|
|
std::swap(V1, V2);
|
|
|
|
|
|
|
|
if (V1->size() == 0) return false;
|
|
|
|
if (V1->size() == 1) {
|
|
|
|
// Just scan V2.
|
|
|
|
ConstantInt *TheVal = (*V1)[0].first;
|
|
|
|
for (unsigned i = 0, e = V2->size(); i != e; ++i)
|
|
|
|
if (TheVal == (*V2)[i].first)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, just sort both lists and compare element by element.
|
|
|
|
std::sort(V1->begin(), V1->end());
|
|
|
|
std::sort(V2->begin(), V2->end());
|
|
|
|
unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size();
|
|
|
|
while (i1 != e1 && i2 != e2) {
|
|
|
|
if ((*V1)[i1].first == (*V2)[i2].first)
|
|
|
|
return true;
|
|
|
|
if ((*V1)[i1].first < (*V2)[i2].first)
|
|
|
|
++i1;
|
|
|
|
else
|
|
|
|
++i2;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// SimplifyEqualityComparisonWithOnlyPredecessor - If TI is known to be a
|
|
|
|
// terminator instruction and its block is known to only have a single
|
|
|
|
// predecessor block, check to see if that predecessor is also a value
|
|
|
|
// comparison with the same value, and if that comparison determines the outcome
|
|
|
|
// of this comparison. If so, simplify TI. This does a very limited form of
|
|
|
|
// jump threading.
|
|
|
|
static bool SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
|
|
|
|
BasicBlock *Pred) {
|
|
|
|
Value *PredVal = isValueEqualityComparison(Pred->getTerminator());
|
|
|
|
if (!PredVal) return false; // Not a value comparison in predecessor.
|
|
|
|
|
|
|
|
Value *ThisVal = isValueEqualityComparison(TI);
|
|
|
|
assert(ThisVal && "This isn't a value comparison!!");
|
|
|
|
if (ThisVal != PredVal) return false; // Different predicates.
|
|
|
|
|
|
|
|
// Find out information about when control will move from Pred to TI's block.
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases;
|
|
|
|
BasicBlock *PredDef = GetValueEqualityComparisonCases(Pred->getTerminator(),
|
|
|
|
PredCases);
|
|
|
|
EliminateBlockCases(PredDef, PredCases); // Remove default from cases.
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2005-02-24 06:17:52 +00:00
|
|
|
// Find information about how control leaves this block.
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > ThisCases;
|
|
|
|
BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases);
|
|
|
|
EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases.
|
|
|
|
|
|
|
|
// If TI's block is the default block from Pred's comparison, potentially
|
|
|
|
// simplify TI based on this knowledge.
|
|
|
|
if (PredDef == TI->getParent()) {
|
|
|
|
// If we are here, we know that the value is none of those cases listed in
|
|
|
|
// PredCases. If there are any cases in ThisCases that are in PredCases, we
|
|
|
|
// can simplify TI.
|
|
|
|
if (ValuesOverlap(PredCases, ThisCases)) {
|
|
|
|
if (BranchInst *BTI = dyn_cast<BranchInst>(TI)) {
|
|
|
|
// Okay, one of the successors of this condbr is dead. Convert it to a
|
|
|
|
// uncond br.
|
|
|
|
assert(ThisCases.size() == 1 && "Branch can only have one case!");
|
|
|
|
Value *Cond = BTI->getCondition();
|
|
|
|
// Insert the new branch.
|
2008-04-06 20:25:17 +00:00
|
|
|
Instruction *NI = BranchInst::Create(ThisDef, TI);
|
2005-02-24 06:17:52 +00:00
|
|
|
|
|
|
|
// Remove PHI node entries for the dead edge.
|
|
|
|
ThisCases[0].second->removePredecessor(TI->getParent());
|
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Threading pred instr: " << *Pred->getTerminator()
|
|
|
|
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n";
|
2005-02-24 06:17:52 +00:00
|
|
|
|
|
|
|
TI->eraseFromParent(); // Nuke the old one.
|
|
|
|
// If condition is now dead, nuke it.
|
|
|
|
if (Instruction *CondI = dyn_cast<Instruction>(Cond))
|
|
|
|
ErasePossiblyDeadInstructionTree(CondI);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
SwitchInst *SI = cast<SwitchInst>(TI);
|
|
|
|
// Okay, TI has cases that are statically dead, prune them away.
|
2007-04-02 01:44:59 +00:00
|
|
|
SmallPtrSet<Constant*, 16> DeadCases;
|
2005-02-24 06:17:52 +00:00
|
|
|
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
|
|
|
|
DeadCases.insert(PredCases[i].first);
|
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Threading pred instr: " << *Pred->getTerminator()
|
|
|
|
<< "Through successor TI: " << *TI;
|
2005-02-24 06:17:52 +00:00
|
|
|
|
|
|
|
for (unsigned i = SI->getNumCases()-1; i != 0; --i)
|
|
|
|
if (DeadCases.count(SI->getCaseValue(i))) {
|
|
|
|
SI->getSuccessor(i)->removePredecessor(TI->getParent());
|
|
|
|
SI->removeCase(i);
|
|
|
|
}
|
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Leaving: " << *TI << "\n";
|
2005-02-24 06:17:52 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// Otherwise, TI's block must correspond to some matched value. Find out
|
|
|
|
// which value (or set of values) this is.
|
|
|
|
ConstantInt *TIV = 0;
|
|
|
|
BasicBlock *TIBB = TI->getParent();
|
|
|
|
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
|
2008-02-20 11:26:25 +00:00
|
|
|
if (PredCases[i].second == TIBB) {
|
2005-02-24 06:17:52 +00:00
|
|
|
if (TIV == 0)
|
|
|
|
TIV = PredCases[i].first;
|
|
|
|
else
|
|
|
|
return false; // Cannot handle multiple values coming to this block.
|
2008-02-20 11:26:25 +00:00
|
|
|
}
|
2005-02-24 06:17:52 +00:00
|
|
|
assert(TIV && "No edge from pred to succ?");
|
|
|
|
|
|
|
|
// Okay, we found the one constant that our value can be if we get into TI's
|
|
|
|
// BB. Find out which successor will unconditionally be branched to.
|
|
|
|
BasicBlock *TheRealDest = 0;
|
|
|
|
for (unsigned i = 0, e = ThisCases.size(); i != e; ++i)
|
|
|
|
if (ThisCases[i].first == TIV) {
|
|
|
|
TheRealDest = ThisCases[i].second;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If not handled by any explicit cases, it is handled by the default case.
|
|
|
|
if (TheRealDest == 0) TheRealDest = ThisDef;
|
|
|
|
|
|
|
|
// Remove PHI node entries for dead edges.
|
|
|
|
BasicBlock *CheckEdge = TheRealDest;
|
|
|
|
for (succ_iterator SI = succ_begin(TIBB), e = succ_end(TIBB); SI != e; ++SI)
|
|
|
|
if (*SI != CheckEdge)
|
|
|
|
(*SI)->removePredecessor(TIBB);
|
|
|
|
else
|
|
|
|
CheckEdge = 0;
|
|
|
|
|
|
|
|
// Insert the new branch.
|
2008-04-06 20:25:17 +00:00
|
|
|
Instruction *NI = BranchInst::Create(TheRealDest, TI);
|
2005-02-24 06:17:52 +00:00
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Threading pred instr: " << *Pred->getTerminator()
|
|
|
|
<< "Through successor TI: " << *TI << "Leaving: " << *NI << "\n";
|
2005-02-24 06:17:52 +00:00
|
|
|
Instruction *Cond = 0;
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI))
|
|
|
|
Cond = dyn_cast<Instruction>(BI->getCondition());
|
|
|
|
TI->eraseFromParent(); // Nuke the old one.
|
|
|
|
|
|
|
|
if (Cond) ErasePossiblyDeadInstructionTree(Cond);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
// FoldValueComparisonIntoPredecessors - The specified terminator is a value
|
|
|
|
// equality comparison instruction (either a switch or a branch on "X == c").
|
|
|
|
// See if any of the predecessors of the terminator block are value comparisons
|
|
|
|
// on the same value. If so, and if safe to do so, fold them together.
|
|
|
|
static bool FoldValueComparisonIntoPredecessors(TerminatorInst *TI) {
|
|
|
|
BasicBlock *BB = TI->getParent();
|
|
|
|
Value *CV = isValueEqualityComparison(TI); // CondVal
|
|
|
|
assert(CV && "Not a comparison?");
|
|
|
|
bool Changed = false;
|
|
|
|
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 16> Preds(pred_begin(BB), pred_end(BB));
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
while (!Preds.empty()) {
|
|
|
|
BasicBlock *Pred = Preds.back();
|
|
|
|
Preds.pop_back();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
// See if the predecessor is a comparison with the same value.
|
|
|
|
TerminatorInst *PTI = Pred->getTerminator();
|
|
|
|
Value *PCV = isValueEqualityComparison(PTI); // PredCondVal
|
|
|
|
|
|
|
|
if (PCV == CV && SafeToMergeTerminators(TI, PTI)) {
|
|
|
|
// Figure out which 'cases' to copy from SI to PSI.
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > BBCases;
|
|
|
|
BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases);
|
|
|
|
|
|
|
|
std::vector<std::pair<ConstantInt*, BasicBlock*> > PredCases;
|
|
|
|
BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases);
|
|
|
|
|
|
|
|
// Based on whether the default edge from PTI goes to BB or not, fill in
|
|
|
|
// PredCases and PredDefault with the new switch cases we would like to
|
|
|
|
// build.
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 8> NewSuccessors;
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
|
|
|
|
if (PredDefault == BB) {
|
|
|
|
// If this is the default destination from PTI, only the edges in TI
|
|
|
|
// that don't occur in PTI, or that branch to BB will be activated.
|
|
|
|
std::set<ConstantInt*> PTIHandled;
|
|
|
|
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
|
|
|
|
if (PredCases[i].second != BB)
|
|
|
|
PTIHandled.insert(PredCases[i].first);
|
|
|
|
else {
|
|
|
|
// The default destination is BB, we don't need explicit targets.
|
|
|
|
std::swap(PredCases[i], PredCases.back());
|
|
|
|
PredCases.pop_back();
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reconstruct the new switch statement we will be building.
|
|
|
|
if (PredDefault != BBDefault) {
|
|
|
|
PredDefault->removePredecessor(Pred);
|
|
|
|
PredDefault = BBDefault;
|
|
|
|
NewSuccessors.push_back(BBDefault);
|
|
|
|
}
|
|
|
|
for (unsigned i = 0, e = BBCases.size(); i != e; ++i)
|
|
|
|
if (!PTIHandled.count(BBCases[i].first) &&
|
|
|
|
BBCases[i].second != BBDefault) {
|
|
|
|
PredCases.push_back(BBCases[i]);
|
|
|
|
NewSuccessors.push_back(BBCases[i].second);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
// If this is not the default destination from PSI, only the edges
|
|
|
|
// in SI that occur in PSI with a destination of BB will be
|
|
|
|
// activated.
|
|
|
|
std::set<ConstantInt*> PTIHandled;
|
|
|
|
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
|
|
|
|
if (PredCases[i].second == BB) {
|
|
|
|
PTIHandled.insert(PredCases[i].first);
|
|
|
|
std::swap(PredCases[i], PredCases.back());
|
|
|
|
PredCases.pop_back();
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, now we know which constants were sent to BB from the
|
|
|
|
// predecessor. Figure out where they will all go now.
|
|
|
|
for (unsigned i = 0, e = BBCases.size(); i != e; ++i)
|
|
|
|
if (PTIHandled.count(BBCases[i].first)) {
|
|
|
|
// If this is one we are capable of getting...
|
|
|
|
PredCases.push_back(BBCases[i]);
|
|
|
|
NewSuccessors.push_back(BBCases[i].second);
|
|
|
|
PTIHandled.erase(BBCases[i].first);// This constant is taken care of
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there are any constants vectored to BB that TI doesn't handle,
|
|
|
|
// they must go to the default destination of TI.
|
|
|
|
for (std::set<ConstantInt*>::iterator I = PTIHandled.begin(),
|
|
|
|
E = PTIHandled.end(); I != E; ++I) {
|
|
|
|
PredCases.push_back(std::make_pair(*I, BBDefault));
|
|
|
|
NewSuccessors.push_back(BBDefault);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Okay, at this point, we know which new successor Pred will get. Make
|
|
|
|
// sure we update the number of entries in the PHI nodes for these
|
|
|
|
// successors.
|
|
|
|
for (unsigned i = 0, e = NewSuccessors.size(); i != e; ++i)
|
|
|
|
AddPredecessorToBlock(NewSuccessors[i], Pred, BB);
|
|
|
|
|
|
|
|
// Now that the successors are updated, create the new Switch instruction.
|
2008-05-15 10:04:30 +00:00
|
|
|
SwitchInst *NewSI = SwitchInst::Create(CV, PredDefault,
|
|
|
|
PredCases.size(), PTI);
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
|
|
|
|
NewSI->addCase(PredCases[i].first, PredCases[i].second);
|
2005-01-01 16:02:12 +00:00
|
|
|
|
|
|
|
Instruction *DeadCond = 0;
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
|
|
|
|
// If PTI is a branch, remember the condition.
|
|
|
|
DeadCond = dyn_cast<Instruction>(BI->getCondition());
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
Pred->getInstList().erase(PTI);
|
|
|
|
|
2005-01-01 16:02:12 +00:00
|
|
|
// If the condition is dead now, remove the instruction tree.
|
|
|
|
if (DeadCond) ErasePossiblyDeadInstructionTree(DeadCond);
|
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
// Okay, last check. If BB is still a successor of PSI, then we must
|
|
|
|
// have an infinite loop case. If so, add an infinitely looping block
|
|
|
|
// to handle the case to preserve the behavior of the code.
|
|
|
|
BasicBlock *InfLoopBlock = 0;
|
|
|
|
for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i)
|
|
|
|
if (NewSI->getSuccessor(i) == BB) {
|
|
|
|
if (InfLoopBlock == 0) {
|
2008-07-13 22:23:11 +00:00
|
|
|
// Insert it at the end of the function, because it's either code,
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
// or it won't matter if it's hot. :)
|
2008-04-06 20:25:17 +00:00
|
|
|
InfLoopBlock = BasicBlock::Create("infloop", BB->getParent());
|
|
|
|
BranchInst::Create(InfLoopBlock, InfLoopBlock);
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
}
|
|
|
|
NewSI->setSuccessor(i, InfLoopBlock);
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2005-08-03 17:59:45 +00:00
|
|
|
/// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and
|
2004-11-30 00:29:14 +00:00
|
|
|
/// BB2, hoist any common code in the two blocks up into the branch block. The
|
|
|
|
/// caller of this function guarantees that BI's block dominates BB1 and BB2.
|
|
|
|
static bool HoistThenElseCodeToIf(BranchInst *BI) {
|
|
|
|
// This does very trivial matching, with limited scanning, to find identical
|
|
|
|
// instructions in the two blocks. In particular, we don't want to get into
|
|
|
|
// O(M*N) situations here where M and N are the sizes of BB1 and BB2. As
|
|
|
|
// such, we currently just scan for obviously identical instructions in an
|
|
|
|
// identical order.
|
|
|
|
BasicBlock *BB1 = BI->getSuccessor(0); // The true destination.
|
|
|
|
BasicBlock *BB2 = BI->getSuccessor(1); // The false destination
|
|
|
|
|
|
|
|
Instruction *I1 = BB1->begin(), *I2 = BB2->begin();
|
2006-12-23 06:05:41 +00:00
|
|
|
if (I1->getOpcode() != I2->getOpcode() || isa<PHINode>(I1) ||
|
|
|
|
isa<InvokeInst>(I1) || !I1->isIdenticalTo(I2))
|
2004-11-30 00:29:14 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// If we get here, we can hoist at least one instruction.
|
|
|
|
BasicBlock *BIParent = BI->getParent();
|
|
|
|
|
|
|
|
do {
|
|
|
|
// If we are hoisting the terminator instruction, don't move one (making a
|
|
|
|
// broken BB), instead clone it, and remove BI.
|
|
|
|
if (isa<TerminatorInst>(I1))
|
|
|
|
goto HoistTerminator;
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-30 00:29:14 +00:00
|
|
|
// For a normal instruction, we just move one to right before the branch,
|
|
|
|
// then replace all uses of the other with the first. Finally, we remove
|
|
|
|
// the now redundant second instruction.
|
|
|
|
BIParent->getInstList().splice(BI, BB1->getInstList(), I1);
|
|
|
|
if (!I2->use_empty())
|
|
|
|
I2->replaceAllUsesWith(I1);
|
|
|
|
BB2->getInstList().erase(I2);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-30 00:29:14 +00:00
|
|
|
I1 = BB1->begin();
|
|
|
|
I2 = BB2->begin();
|
|
|
|
} while (I1->getOpcode() == I2->getOpcode() && I1->isIdenticalTo(I2));
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
HoistTerminator:
|
|
|
|
// Okay, it is safe to hoist the terminator.
|
|
|
|
Instruction *NT = I1->clone();
|
|
|
|
BIParent->getInstList().insert(BI, NT);
|
|
|
|
if (NT->getType() != Type::VoidTy) {
|
|
|
|
I1->replaceAllUsesWith(NT);
|
|
|
|
I2->replaceAllUsesWith(NT);
|
2007-02-11 01:37:51 +00:00
|
|
|
NT->takeName(I1);
|
2004-11-30 00:29:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Hoisting one of the terminators from our successor is a great thing.
|
|
|
|
// Unfortunately, the successors of the if/else blocks may have PHI nodes in
|
|
|
|
// them. If they do, all PHI entries for BB1/BB2 must agree for all PHI
|
|
|
|
// nodes, so we insert select instruction to compute the final result.
|
|
|
|
std::map<std::pair<Value*,Value*>, SelectInst*> InsertedSelects;
|
|
|
|
for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI) {
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator BBI = SI->begin();
|
2004-11-30 07:47:34 +00:00
|
|
|
(PN = dyn_cast<PHINode>(BBI)); ++BBI) {
|
2004-11-30 00:29:14 +00:00
|
|
|
Value *BB1V = PN->getIncomingValueForBlock(BB1);
|
|
|
|
Value *BB2V = PN->getIncomingValueForBlock(BB2);
|
|
|
|
if (BB1V != BB2V) {
|
|
|
|
// These values do not agree. Insert a select instruction before NT
|
|
|
|
// that determines the right value.
|
|
|
|
SelectInst *&SI = InsertedSelects[std::make_pair(BB1V, BB2V)];
|
|
|
|
if (SI == 0)
|
2008-04-06 20:25:17 +00:00
|
|
|
SI = SelectInst::Create(BI->getCondition(), BB1V, BB2V,
|
|
|
|
BB1V->getName()+"."+BB2V->getName(), NT);
|
2004-11-30 00:29:14 +00:00
|
|
|
// Make the PHI node use the select for all incoming values for BB1/BB2
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
if (PN->getIncomingBlock(i) == BB1 || PN->getIncomingBlock(i) == BB2)
|
|
|
|
PN->setIncomingValue(i, SI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update any PHI nodes in our new successors.
|
|
|
|
for (succ_iterator SI = succ_begin(BB1), E = succ_end(BB1); SI != E; ++SI)
|
|
|
|
AddPredecessorToBlock(*SI, BIParent, BB1);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-30 00:29:14 +00:00
|
|
|
BI->eraseFromParent();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-06-07 08:52:29 +00:00
|
|
|
/// SpeculativelyExecuteBB - Given a conditional branch that goes to BB1
|
|
|
|
/// and an BB2 and the only successor of BB1 is BB2, hoist simple code
|
|
|
|
/// (for now, restricted to a single instruction that's side effect free) from
|
|
|
|
/// the BB1 into the branch block to speculatively execute it.
|
|
|
|
static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *BB1) {
|
|
|
|
// Only speculatively execution a single instruction (not counting the
|
|
|
|
// terminator) for now.
|
2008-06-25 07:50:12 +00:00
|
|
|
BasicBlock::iterator BBI = BB1->begin();
|
|
|
|
++BBI; // must have at least a terminator
|
|
|
|
if (BBI == BB1->end()) return false; // only one inst
|
|
|
|
++BBI;
|
|
|
|
if (BBI != BB1->end()) return false; // more than 2 insts.
|
2008-06-07 08:52:29 +00:00
|
|
|
|
2008-06-11 19:18:20 +00:00
|
|
|
// Be conservative for now. FP select instruction can often be expensive.
|
|
|
|
Value *BrCond = BI->getCondition();
|
|
|
|
if (isa<Instruction>(BrCond) &&
|
|
|
|
cast<Instruction>(BrCond)->getOpcode() == Instruction::FCmp)
|
|
|
|
return false;
|
|
|
|
|
2008-06-07 08:52:29 +00:00
|
|
|
// If BB1 is actually on the false edge of the conditional branch, remember
|
|
|
|
// to swap the select operands later.
|
|
|
|
bool Invert = false;
|
|
|
|
if (BB1 != BI->getSuccessor(0)) {
|
|
|
|
assert(BB1 == BI->getSuccessor(1) && "No edge from 'if' block?");
|
|
|
|
Invert = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Turn
|
|
|
|
// BB:
|
|
|
|
// %t1 = icmp
|
|
|
|
// br i1 %t1, label %BB1, label %BB2
|
|
|
|
// BB1:
|
|
|
|
// %t3 = add %t2, c
|
|
|
|
// br label BB2
|
|
|
|
// BB2:
|
|
|
|
// =>
|
|
|
|
// BB:
|
|
|
|
// %t1 = icmp
|
|
|
|
// %t4 = add %t2, c
|
|
|
|
// %t3 = select i1 %t1, %t2, %t3
|
|
|
|
Instruction *I = BB1->begin();
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
default: return false; // Not safe / profitable to hoist.
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
2008-06-25 07:50:12 +00:00
|
|
|
if (!I->getOperand(0)->getType()->isInteger())
|
|
|
|
// FP arithmetic might trap. Not worth doing for vector ops.
|
|
|
|
return false;
|
2008-06-07 08:52:29 +00:00
|
|
|
break; // These are all cheap and non-trapping instructions.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Can we speculatively execute the instruction? And what is the value
|
|
|
|
// if the condition is false? Consider the phi uses, if the incoming value
|
|
|
|
// from the "if" block are all the same V, then V is the value of the
|
|
|
|
// select if the condition is false.
|
|
|
|
BasicBlock *BIParent = BI->getParent();
|
|
|
|
SmallVector<PHINode*, 4> PHIUses;
|
|
|
|
Value *FalseV = NULL;
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI) {
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(UI);
|
|
|
|
if (!PN)
|
|
|
|
continue;
|
|
|
|
PHIUses.push_back(PN);
|
|
|
|
Value *PHIV = PN->getIncomingValueForBlock(BIParent);
|
|
|
|
if (!FalseV)
|
|
|
|
FalseV = PHIV;
|
|
|
|
else if (FalseV != PHIV)
|
|
|
|
return false; // Don't know the value when condition is false.
|
|
|
|
}
|
|
|
|
if (!FalseV) // Can this happen?
|
|
|
|
return false;
|
|
|
|
|
2008-06-12 21:15:59 +00:00
|
|
|
// Do not hoist the instruction if any of its operands are defined but not
|
|
|
|
// used in this BB. The transformation will prevent the operand from
|
|
|
|
// being sunk into the use block.
|
|
|
|
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) {
|
|
|
|
Instruction *OpI = dyn_cast<Instruction>(*i);
|
|
|
|
if (OpI && OpI->getParent() == BIParent &&
|
|
|
|
!OpI->isUsedInBasicBlock(BIParent))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-09-17 18:21:49 +00:00
|
|
|
// If we get here, we can hoist the instruction.
|
|
|
|
BIParent->getInstList().splice(BI, BB1->getInstList(), I);
|
2008-06-07 08:52:29 +00:00
|
|
|
|
|
|
|
// Create a select whose true value is the speculatively executed value and
|
|
|
|
// false value is the previously determined FalseV.
|
|
|
|
SelectInst *SI;
|
|
|
|
if (Invert)
|
2008-06-11 19:18:20 +00:00
|
|
|
SI = SelectInst::Create(BrCond, FalseV, I,
|
2008-06-07 08:52:29 +00:00
|
|
|
FalseV->getName() + "." + I->getName(), BI);
|
|
|
|
else
|
2008-06-11 19:18:20 +00:00
|
|
|
SI = SelectInst::Create(BrCond, I, FalseV,
|
2008-06-07 08:52:29 +00:00
|
|
|
I->getName() + "." + FalseV->getName(), BI);
|
|
|
|
|
|
|
|
// Make the PHI node use the select for all incoming values for "then" and
|
|
|
|
// "if" blocks.
|
|
|
|
for (unsigned i = 0, e = PHIUses.size(); i != e; ++i) {
|
|
|
|
PHINode *PN = PHIUses[i];
|
|
|
|
for (unsigned j = 0, ee = PN->getNumIncomingValues(); j != ee; ++j)
|
|
|
|
if (PN->getIncomingBlock(j) == BB1 ||
|
|
|
|
PN->getIncomingBlock(j) == BIParent)
|
|
|
|
PN->setIncomingValue(j, SI);
|
|
|
|
}
|
|
|
|
|
2008-06-12 21:15:59 +00:00
|
|
|
++NumSpeculations;
|
2008-06-07 08:52:29 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-09-20 00:43:16 +00:00
|
|
|
/// BlockIsSimpleEnoughToThreadThrough - Return true if we can thread a branch
|
|
|
|
/// across this block.
|
|
|
|
static bool BlockIsSimpleEnoughToThreadThrough(BasicBlock *BB) {
|
|
|
|
BranchInst *BI = cast<BranchInst>(BB->getTerminator());
|
2005-09-20 01:48:40 +00:00
|
|
|
unsigned Size = 0;
|
|
|
|
|
2005-09-20 00:43:16 +00:00
|
|
|
// If this basic block contains anything other than a PHI (which controls the
|
|
|
|
// branch) and branch itself, bail out. FIXME: improve this in the future.
|
2005-09-20 01:48:40 +00:00
|
|
|
for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI, ++Size) {
|
|
|
|
if (Size > 10) return false; // Don't clone large BB's.
|
2005-09-20 00:43:16 +00:00
|
|
|
|
2005-09-20 01:48:40 +00:00
|
|
|
// We can only support instructions that are do not define values that are
|
|
|
|
// live outside of the current basic block.
|
|
|
|
for (Value::use_iterator UI = BBI->use_begin(), E = BBI->use_end();
|
|
|
|
UI != E; ++UI) {
|
|
|
|
Instruction *U = cast<Instruction>(*UI);
|
|
|
|
if (U->getParent() != BB || isa<PHINode>(U)) return false;
|
|
|
|
}
|
2005-09-20 00:43:16 +00:00
|
|
|
|
|
|
|
// Looks ok, continue checking.
|
|
|
|
}
|
2005-09-20 01:48:40 +00:00
|
|
|
|
2005-09-20 00:43:16 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-09-19 23:49:37 +00:00
|
|
|
/// FoldCondBranchOnPHI - If we have a conditional branch on a PHI node value
|
|
|
|
/// that is defined in the same block as the branch and if any PHI entries are
|
|
|
|
/// constants, thread edges corresponding to that entry to be branches to their
|
|
|
|
/// ultimate destination.
|
|
|
|
static bool FoldCondBranchOnPHI(BranchInst *BI) {
|
|
|
|
BasicBlock *BB = BI->getParent();
|
|
|
|
PHINode *PN = dyn_cast<PHINode>(BI->getCondition());
|
2005-09-19 23:57:04 +00:00
|
|
|
// NOTE: we currently cannot transform this case if the PHI node is used
|
|
|
|
// outside of the block.
|
2005-09-20 00:43:16 +00:00
|
|
|
if (!PN || PN->getParent() != BB || !PN->hasOneUse())
|
|
|
|
return false;
|
2005-09-19 23:49:37 +00:00
|
|
|
|
|
|
|
// Degenerate case of a single entry PHI.
|
|
|
|
if (PN->getNumIncomingValues() == 1) {
|
|
|
|
if (PN->getIncomingValue(0) != PN)
|
|
|
|
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
|
|
|
else
|
|
|
|
PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
|
|
|
|
PN->eraseFromParent();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we know that this block has multiple preds and two succs.
|
2005-09-20 00:43:16 +00:00
|
|
|
if (!BlockIsSimpleEnoughToThreadThrough(BB)) return false;
|
2005-09-19 23:49:37 +00:00
|
|
|
|
|
|
|
// Okay, this is a simple enough basic block. See if any phi values are
|
|
|
|
// constants.
|
2007-01-11 12:24:14 +00:00
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
ConstantInt *CB;
|
|
|
|
if ((CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i))) &&
|
2007-01-11 18:21:29 +00:00
|
|
|
CB->getType() == Type::Int1Ty) {
|
2005-09-19 23:49:37 +00:00
|
|
|
// Okay, we now know that all edges from PredBB should be revectored to
|
|
|
|
// branch to RealDest.
|
|
|
|
BasicBlock *PredBB = PN->getIncomingBlock(i);
|
2007-01-12 04:24:46 +00:00
|
|
|
BasicBlock *RealDest = BI->getSuccessor(!CB->getZExtValue());
|
2005-09-19 23:49:37 +00:00
|
|
|
|
2005-09-20 01:48:40 +00:00
|
|
|
if (RealDest == BB) continue; // Skip self loops.
|
2005-09-19 23:49:37 +00:00
|
|
|
|
2005-09-20 01:48:40 +00:00
|
|
|
// The dest block might have PHI nodes, other predecessors and other
|
|
|
|
// difficult cases. Instead of being smart about this, just insert a new
|
|
|
|
// block that jumps to the destination block, effectively splitting
|
|
|
|
// the edge we are about to create.
|
2008-04-06 20:25:17 +00:00
|
|
|
BasicBlock *EdgeBB = BasicBlock::Create(RealDest->getName()+".critedge",
|
|
|
|
RealDest->getParent(), RealDest);
|
|
|
|
BranchInst::Create(RealDest, EdgeBB);
|
2005-09-20 01:48:40 +00:00
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator BBI = RealDest->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(BBI)); ++BBI) {
|
|
|
|
Value *V = PN->getIncomingValueForBlock(BB);
|
|
|
|
PN->addIncoming(V, EdgeBB);
|
|
|
|
}
|
|
|
|
|
|
|
|
// BB may have instructions that are being threaded over. Clone these
|
|
|
|
// instructions into EdgeBB. We know that there will be no uses of the
|
|
|
|
// cloned instructions outside of EdgeBB.
|
|
|
|
BasicBlock::iterator InsertPt = EdgeBB->begin();
|
|
|
|
std::map<Value*, Value*> TranslateMap; // Track translated values.
|
|
|
|
for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) {
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(BBI)) {
|
|
|
|
TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB);
|
|
|
|
} else {
|
|
|
|
// Clone the instruction.
|
|
|
|
Instruction *N = BBI->clone();
|
|
|
|
if (BBI->hasName()) N->setName(BBI->getName()+".c");
|
|
|
|
|
|
|
|
// Update operands due to translation.
|
2008-06-10 22:03:26 +00:00
|
|
|
for (User::op_iterator i = N->op_begin(), e = N->op_end();
|
|
|
|
i != e; ++i) {
|
2005-09-20 01:48:40 +00:00
|
|
|
std::map<Value*, Value*>::iterator PI =
|
2008-06-10 22:03:26 +00:00
|
|
|
TranslateMap.find(*i);
|
2005-09-20 01:48:40 +00:00
|
|
|
if (PI != TranslateMap.end())
|
2008-06-10 22:03:26 +00:00
|
|
|
*i = PI->second;
|
2005-09-20 01:48:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check for trivial simplification.
|
|
|
|
if (Constant *C = ConstantFoldInstruction(N)) {
|
|
|
|
TranslateMap[BBI] = C;
|
|
|
|
delete N; // Constant folded away, don't need actual inst
|
|
|
|
} else {
|
|
|
|
// Insert the new instruction into its new home.
|
|
|
|
EdgeBB->getInstList().insert(InsertPt, N);
|
|
|
|
if (!BBI->use_empty())
|
|
|
|
TranslateMap[BBI] = N;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-19 23:49:37 +00:00
|
|
|
// Loop over all of the edges from PredBB to BB, changing them to branch
|
2005-09-20 01:48:40 +00:00
|
|
|
// to EdgeBB instead.
|
2005-09-19 23:49:37 +00:00
|
|
|
TerminatorInst *PredBBTI = PredBB->getTerminator();
|
|
|
|
for (unsigned i = 0, e = PredBBTI->getNumSuccessors(); i != e; ++i)
|
|
|
|
if (PredBBTI->getSuccessor(i) == BB) {
|
|
|
|
BB->removePredecessor(PredBB);
|
2005-09-20 01:48:40 +00:00
|
|
|
PredBBTI->setSuccessor(i, EdgeBB);
|
2005-09-19 23:49:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Recurse, simplifying any other constants.
|
|
|
|
return FoldCondBranchOnPHI(BI) | true;
|
|
|
|
}
|
2007-01-11 12:24:14 +00:00
|
|
|
}
|
2005-09-19 23:49:37 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-09-23 06:39:30 +00:00
|
|
|
/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry
|
|
|
|
/// PHI node, see if we can eliminate it.
|
|
|
|
static bool FoldTwoEntryPHINode(PHINode *PN) {
|
|
|
|
// Ok, this is a two entry PHI node. Check to see if this is a simple "if
|
|
|
|
// statement", which has a very simple dominance structure. Basically, we
|
|
|
|
// are trying to find the condition that is being branched on, which
|
|
|
|
// subsequently causes this merge to happen. We really want control
|
|
|
|
// dependence information for this check, but simplifycfg can't keep it up
|
|
|
|
// to date, and this catches most of the cases we care about anyway.
|
|
|
|
//
|
|
|
|
BasicBlock *BB = PN->getParent();
|
|
|
|
BasicBlock *IfTrue, *IfFalse;
|
|
|
|
Value *IfCond = GetIfCondition(BB, IfTrue, IfFalse);
|
|
|
|
if (!IfCond) return false;
|
|
|
|
|
2006-11-18 19:19:36 +00:00
|
|
|
// Okay, we found that we can merge this two-entry phi node into a select.
|
|
|
|
// Doing so would require us to fold *all* two entry phi nodes in this block.
|
|
|
|
// At some point this becomes non-profitable (particularly if the target
|
|
|
|
// doesn't support cmov's). Only do this transformation if there are two or
|
|
|
|
// fewer PHI nodes in this block.
|
|
|
|
unsigned NumPhis = 0;
|
|
|
|
for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(I); ++NumPhis, ++I)
|
|
|
|
if (NumPhis > 2)
|
|
|
|
return false;
|
|
|
|
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "FOUND IF CONDITION! " << *IfCond << " T: "
|
|
|
|
<< IfTrue->getName() << " F: " << IfFalse->getName() << "\n";
|
2005-09-23 06:39:30 +00:00
|
|
|
|
|
|
|
// Loop over the PHI's seeing if we can promote them all to select
|
|
|
|
// instructions. While we are at it, keep track of the instructions
|
|
|
|
// that need to be moved to the dominating block.
|
|
|
|
std::set<Instruction*> AggressiveInsts;
|
|
|
|
|
|
|
|
BasicBlock::iterator AfterPHIIt = BB->begin();
|
|
|
|
while (isa<PHINode>(AfterPHIIt)) {
|
|
|
|
PHINode *PN = cast<PHINode>(AfterPHIIt++);
|
|
|
|
if (PN->getIncomingValue(0) == PN->getIncomingValue(1)) {
|
|
|
|
if (PN->getIncomingValue(0) != PN)
|
|
|
|
PN->replaceAllUsesWith(PN->getIncomingValue(0));
|
|
|
|
else
|
|
|
|
PN->replaceAllUsesWith(UndefValue::get(PN->getType()));
|
|
|
|
} else if (!DominatesMergePoint(PN->getIncomingValue(0), BB,
|
|
|
|
&AggressiveInsts) ||
|
|
|
|
!DominatesMergePoint(PN->getIncomingValue(1), BB,
|
|
|
|
&AggressiveInsts)) {
|
2005-09-23 07:23:18 +00:00
|
|
|
return false;
|
2005-09-23 06:39:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we all PHI nodes are promotable, check to make sure that all
|
|
|
|
// instructions in the predecessor blocks can be promoted as well. If
|
|
|
|
// not, we won't be able to get rid of the control flow, so it's not
|
|
|
|
// worth promoting to select instructions.
|
|
|
|
BasicBlock *DomBlock = 0, *IfBlock1 = 0, *IfBlock2 = 0;
|
|
|
|
PN = cast<PHINode>(BB->begin());
|
|
|
|
BasicBlock *Pred = PN->getIncomingBlock(0);
|
|
|
|
if (cast<BranchInst>(Pred->getTerminator())->isUnconditional()) {
|
|
|
|
IfBlock1 = Pred;
|
|
|
|
DomBlock = *pred_begin(Pred);
|
|
|
|
for (BasicBlock::iterator I = Pred->begin();
|
|
|
|
!isa<TerminatorInst>(I); ++I)
|
|
|
|
if (!AggressiveInsts.count(I)) {
|
|
|
|
// This is not an aggressive instruction that we can promote.
|
|
|
|
// Because of this, we won't be able to get rid of the control
|
|
|
|
// flow, so the xform is not worth it.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Pred = PN->getIncomingBlock(1);
|
|
|
|
if (cast<BranchInst>(Pred->getTerminator())->isUnconditional()) {
|
|
|
|
IfBlock2 = Pred;
|
|
|
|
DomBlock = *pred_begin(Pred);
|
|
|
|
for (BasicBlock::iterator I = Pred->begin();
|
|
|
|
!isa<TerminatorInst>(I); ++I)
|
|
|
|
if (!AggressiveInsts.count(I)) {
|
|
|
|
// This is not an aggressive instruction that we can promote.
|
|
|
|
// Because of this, we won't be able to get rid of the control
|
|
|
|
// flow, so the xform is not worth it.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we can still promote the PHI nodes after this gauntlet of tests,
|
|
|
|
// do all of the PHI's now.
|
|
|
|
|
|
|
|
// Move all 'aggressive' instructions, which are defined in the
|
|
|
|
// conditional parts of the if's up to the dominating block.
|
|
|
|
if (IfBlock1) {
|
|
|
|
DomBlock->getInstList().splice(DomBlock->getTerminator(),
|
|
|
|
IfBlock1->getInstList(),
|
|
|
|
IfBlock1->begin(),
|
|
|
|
IfBlock1->getTerminator());
|
|
|
|
}
|
|
|
|
if (IfBlock2) {
|
|
|
|
DomBlock->getInstList().splice(DomBlock->getTerminator(),
|
|
|
|
IfBlock2->getInstList(),
|
|
|
|
IfBlock2->begin(),
|
|
|
|
IfBlock2->getTerminator());
|
|
|
|
}
|
|
|
|
|
|
|
|
while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) {
|
|
|
|
// Change the PHI node into a select instruction.
|
|
|
|
Value *TrueVal =
|
|
|
|
PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse);
|
|
|
|
Value *FalseVal =
|
|
|
|
PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue);
|
|
|
|
|
2008-04-06 20:25:17 +00:00
|
|
|
Value *NV = SelectInst::Create(IfCond, TrueVal, FalseVal, "", AfterPHIIt);
|
2007-02-11 01:37:51 +00:00
|
|
|
PN->replaceAllUsesWith(NV);
|
|
|
|
NV->takeName(PN);
|
|
|
|
|
2005-09-23 06:39:30 +00:00
|
|
|
BB->getInstList().erase(PN);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2005-09-19 23:49:37 +00:00
|
|
|
|
2008-04-24 00:01:19 +00:00
|
|
|
/// SimplifyCondBranchToTwoReturns - If we found a conditional branch that goes
|
|
|
|
/// to two returning blocks, try to merge them together into one return,
|
|
|
|
/// introducing a select if the return values disagree.
|
|
|
|
static bool SimplifyCondBranchToTwoReturns(BranchInst *BI) {
|
|
|
|
assert(BI->isConditional() && "Must be a conditional branch");
|
|
|
|
BasicBlock *TrueSucc = BI->getSuccessor(0);
|
|
|
|
BasicBlock *FalseSucc = BI->getSuccessor(1);
|
|
|
|
ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator());
|
|
|
|
ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator());
|
|
|
|
|
|
|
|
// Check to ensure both blocks are empty (just a return) or optionally empty
|
|
|
|
// with PHI nodes. If there are other instructions, merging would cause extra
|
|
|
|
// computation on one path or the other.
|
|
|
|
BasicBlock::iterator BBI = TrueRet;
|
|
|
|
if (BBI != TrueSucc->begin() && !isa<PHINode>(--BBI))
|
|
|
|
return false; // Not empty with optional phi nodes.
|
|
|
|
BBI = FalseRet;
|
|
|
|
if (BBI != FalseSucc->begin() && !isa<PHINode>(--BBI))
|
|
|
|
return false; // Not empty with optional phi nodes.
|
|
|
|
|
|
|
|
// Okay, we found a branch that is going to two return nodes. If
|
|
|
|
// there is no return value for this function, just change the
|
|
|
|
// branch into a return.
|
|
|
|
if (FalseRet->getNumOperands() == 0) {
|
|
|
|
TrueSucc->removePredecessor(BI->getParent());
|
|
|
|
FalseSucc->removePredecessor(BI->getParent());
|
|
|
|
ReturnInst::Create(0, BI);
|
|
|
|
BI->eraseFromParent();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
// Otherwise, figure out what the true and false return values are
|
|
|
|
// so we can insert a new select instruction.
|
|
|
|
Value *TrueValue = TrueRet->getReturnValue();
|
|
|
|
Value *FalseValue = FalseRet->getReturnValue();
|
|
|
|
|
|
|
|
// Unwrap any PHI nodes in the return blocks.
|
|
|
|
if (PHINode *TVPN = dyn_cast_or_null<PHINode>(TrueValue))
|
|
|
|
if (TVPN->getParent() == TrueSucc)
|
|
|
|
TrueValue = TVPN->getIncomingValueForBlock(BI->getParent());
|
|
|
|
if (PHINode *FVPN = dyn_cast_or_null<PHINode>(FalseValue))
|
|
|
|
if (FVPN->getParent() == FalseSucc)
|
|
|
|
FalseValue = FVPN->getIncomingValueForBlock(BI->getParent());
|
|
|
|
|
|
|
|
// In order for this transformation to be safe, we must be able to
|
|
|
|
// unconditionally execute both operands to the return. This is
|
|
|
|
// normally the case, but we could have a potentially-trapping
|
|
|
|
// constant expression that prevents this transformation from being
|
|
|
|
// safe.
|
|
|
|
if (ConstantExpr *TCV = dyn_cast_or_null<ConstantExpr>(TrueValue))
|
|
|
|
if (TCV->canTrap())
|
|
|
|
return false;
|
|
|
|
if (ConstantExpr *FCV = dyn_cast_or_null<ConstantExpr>(FalseValue))
|
|
|
|
if (FCV->canTrap())
|
|
|
|
return false;
|
2008-04-24 00:01:19 +00:00
|
|
|
|
|
|
|
// Okay, we collected all the mapped values and checked them for sanity, and
|
|
|
|
// defined to really do this transformation. First, update the CFG.
|
|
|
|
TrueSucc->removePredecessor(BI->getParent());
|
|
|
|
FalseSucc->removePredecessor(BI->getParent());
|
|
|
|
|
|
|
|
// Insert select instructions where needed.
|
|
|
|
Value *BrCond = BI->getCondition();
|
2008-07-23 00:34:11 +00:00
|
|
|
if (TrueValue) {
|
2008-04-24 00:01:19 +00:00
|
|
|
// Insert a select if the results differ.
|
2008-07-23 00:34:11 +00:00
|
|
|
if (TrueValue == FalseValue || isa<UndefValue>(FalseValue)) {
|
|
|
|
} else if (isa<UndefValue>(TrueValue)) {
|
|
|
|
TrueValue = FalseValue;
|
|
|
|
} else {
|
|
|
|
TrueValue = SelectInst::Create(BrCond, TrueValue,
|
|
|
|
FalseValue, "retval", BI);
|
2008-04-24 00:01:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
Value *RI = !TrueValue ?
|
|
|
|
ReturnInst::Create(BI) :
|
|
|
|
ReturnInst::Create(TrueValue, BI);
|
2008-04-24 00:01:19 +00:00
|
|
|
|
|
|
|
DOUT << "\nCHANGING BRANCH TO TWO RETURNS INTO SELECT:"
|
|
|
|
<< "\n " << *BI << "NewRet = " << *RI
|
|
|
|
<< "TRUEBLOCK: " << *TrueSucc << "FALSEBLOCK: "<< *FalseSucc;
|
|
|
|
|
|
|
|
BI->eraseFromParent();
|
|
|
|
|
|
|
|
if (Instruction *BrCondI = dyn_cast<Instruction>(BrCond))
|
|
|
|
ErasePossiblyDeadInstructionTree(BrCondI);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-07-13 21:12:01 +00:00
|
|
|
/// FoldBranchToCommonDest - If this basic block is ONLY a setcc and a branch,
|
|
|
|
/// and if a predecessor branches to us and one of our successors, fold the
|
|
|
|
/// setcc into the predecessor and use logical operations to pick the right
|
|
|
|
/// destination.
|
|
|
|
static bool FoldBranchToCommonDest(BranchInst *BI) {
|
2008-07-13 22:23:11 +00:00
|
|
|
BasicBlock *BB = BI->getParent();
|
2008-07-13 21:12:01 +00:00
|
|
|
Instruction *Cond = dyn_cast<Instruction>(BI->getCondition());
|
|
|
|
if (Cond == 0) return false;
|
|
|
|
|
2008-07-13 22:23:11 +00:00
|
|
|
|
2008-07-13 21:12:01 +00:00
|
|
|
// Only allow this if the condition is a simple instruction that can be
|
|
|
|
// executed unconditionally. It must be in the same block as the branch, and
|
|
|
|
// must be at the front of the block.
|
|
|
|
if ((!isa<CmpInst>(Cond) && !isa<BinaryOperator>(Cond)) ||
|
|
|
|
Cond->getParent() != BB || &BB->front() != Cond || !Cond->hasOneUse())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Make sure the instruction after the condition is the cond branch.
|
|
|
|
BasicBlock::iterator CondIt = Cond; ++CondIt;
|
|
|
|
if (&*CondIt != BI)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Finally, don't infinitely unroll conditional loops.
|
|
|
|
BasicBlock *TrueDest = BI->getSuccessor(0);
|
|
|
|
BasicBlock *FalseDest = BI->getSuccessor(1);
|
|
|
|
if (TrueDest == BB || FalseDest == BB)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
|
|
|
|
BasicBlock *PredBlock = *PI;
|
|
|
|
BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
|
2008-07-13 22:23:11 +00:00
|
|
|
// Check that we have two conditional branches. If there is a PHI node in
|
|
|
|
// the common successor, verify that the same value flows in from both
|
|
|
|
// blocks.
|
2008-07-13 21:12:01 +00:00
|
|
|
if (PBI == 0 || PBI->isUnconditional() ||
|
|
|
|
!SafeToMergeTerminators(BI, PBI))
|
|
|
|
continue;
|
|
|
|
|
2008-07-13 21:20:19 +00:00
|
|
|
Instruction::BinaryOps Opc;
|
|
|
|
bool InvertPredCond = false;
|
|
|
|
|
|
|
|
if (PBI->getSuccessor(0) == TrueDest)
|
|
|
|
Opc = Instruction::Or;
|
|
|
|
else if (PBI->getSuccessor(1) == FalseDest)
|
|
|
|
Opc = Instruction::And;
|
|
|
|
else if (PBI->getSuccessor(0) == FalseDest)
|
|
|
|
Opc = Instruction::And, InvertPredCond = true;
|
|
|
|
else if (PBI->getSuccessor(1) == TrueDest)
|
|
|
|
Opc = Instruction::Or, InvertPredCond = true;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If we need to invert the condition in the pred block to match, do so now.
|
|
|
|
if (InvertPredCond) {
|
2008-07-13 21:12:01 +00:00
|
|
|
Value *NewCond =
|
|
|
|
BinaryOperator::CreateNot(PBI->getCondition(),
|
2008-07-13 21:20:19 +00:00
|
|
|
PBI->getCondition()->getName()+".not", PBI);
|
2008-07-13 21:12:01 +00:00
|
|
|
PBI->setCondition(NewCond);
|
|
|
|
BasicBlock *OldTrue = PBI->getSuccessor(0);
|
|
|
|
BasicBlock *OldFalse = PBI->getSuccessor(1);
|
|
|
|
PBI->setSuccessor(0, OldFalse);
|
|
|
|
PBI->setSuccessor(1, OldTrue);
|
|
|
|
}
|
2008-07-13 21:15:11 +00:00
|
|
|
|
2008-07-13 21:20:19 +00:00
|
|
|
// Clone Cond into the predecessor basic block, and or/and the
|
|
|
|
// two conditions together.
|
|
|
|
Instruction *New = Cond->clone();
|
|
|
|
PredBlock->getInstList().insert(PBI, New);
|
|
|
|
New->takeName(Cond);
|
|
|
|
Cond->setName(New->getName()+".old");
|
2008-07-13 21:15:11 +00:00
|
|
|
|
2008-07-13 21:20:19 +00:00
|
|
|
Value *NewCond = BinaryOperator::Create(Opc, PBI->getCondition(),
|
|
|
|
New, "or.cond", PBI);
|
|
|
|
PBI->setCondition(NewCond);
|
|
|
|
if (PBI->getSuccessor(0) == BB) {
|
|
|
|
AddPredecessorToBlock(TrueDest, PredBlock, BB);
|
|
|
|
PBI->setSuccessor(0, TrueDest);
|
|
|
|
}
|
|
|
|
if (PBI->getSuccessor(1) == BB) {
|
|
|
|
AddPredecessorToBlock(FalseDest, PredBlock, BB);
|
|
|
|
PBI->setSuccessor(1, FalseDest);
|
2008-07-13 21:12:01 +00:00
|
|
|
}
|
2008-07-13 21:20:19 +00:00
|
|
|
return true;
|
2008-07-13 21:12:01 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-07-13 21:53:26 +00:00
|
|
|
/// SimplifyCondBranchToCondBranch - If we have a conditional branch as a
|
|
|
|
/// predecessor of another block, this function tries to simplify it. We know
|
|
|
|
/// that PBI and BI are both conditional branches, and BI is in one of the
|
|
|
|
/// successor blocks of PBI - PBI branches to BI.
|
|
|
|
static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI) {
|
|
|
|
assert(PBI->isConditional() && BI->isConditional());
|
|
|
|
BasicBlock *BB = BI->getParent();
|
|
|
|
|
|
|
|
// If this block ends with a branch instruction, and if there is a
|
|
|
|
// predecessor that ends on a branch of the same condition, make
|
|
|
|
// this conditional branch redundant.
|
|
|
|
if (PBI->getCondition() == BI->getCondition() &&
|
|
|
|
PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
|
|
|
|
// Okay, the outcome of this conditional branch is statically
|
|
|
|
// knowable. If this block had a single pred, handle specially.
|
|
|
|
if (BB->getSinglePredecessor()) {
|
|
|
|
// Turn this into a branch on constant.
|
|
|
|
bool CondIsTrue = PBI->getSuccessor(0) == BB;
|
|
|
|
BI->setCondition(ConstantInt::get(Type::Int1Ty, CondIsTrue));
|
|
|
|
return true; // Nuke the branch on constant.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, if there are multiple predecessors, insert a PHI that merges
|
|
|
|
// in the constant and simplify the block result. Subsequent passes of
|
|
|
|
// simplifycfg will thread the block.
|
|
|
|
if (BlockIsSimpleEnoughToThreadThrough(BB)) {
|
|
|
|
PHINode *NewPN = PHINode::Create(Type::Int1Ty,
|
|
|
|
BI->getCondition()->getName() + ".pr",
|
|
|
|
BB->begin());
|
2008-07-13 21:55:46 +00:00
|
|
|
// Okay, we're going to insert the PHI node. Since PBI is not the only
|
|
|
|
// predecessor, compute the PHI'd conditional value for all of the preds.
|
|
|
|
// Any predecessor where the condition is not computable we keep symbolic.
|
2008-07-13 21:53:26 +00:00
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
|
|
|
|
if ((PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) &&
|
|
|
|
PBI != BI && PBI->isConditional() &&
|
|
|
|
PBI->getCondition() == BI->getCondition() &&
|
|
|
|
PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
|
|
|
|
bool CondIsTrue = PBI->getSuccessor(0) == BB;
|
|
|
|
NewPN->addIncoming(ConstantInt::get(Type::Int1Ty,
|
|
|
|
CondIsTrue), *PI);
|
|
|
|
} else {
|
|
|
|
NewPN->addIncoming(BI->getCondition(), *PI);
|
|
|
|
}
|
|
|
|
|
|
|
|
BI->setCondition(NewPN);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is a conditional branch in an empty block, and if any
|
|
|
|
// predecessors is a conditional branch to one of our destinations,
|
|
|
|
// fold the conditions into logical ops and one cond br.
|
2008-07-13 22:04:41 +00:00
|
|
|
if (&BB->front() != BI)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
int PBIOp, BIOp;
|
|
|
|
if (PBI->getSuccessor(0) == BI->getSuccessor(0))
|
|
|
|
PBIOp = BIOp = 0;
|
|
|
|
else if (PBI->getSuccessor(0) == BI->getSuccessor(1))
|
|
|
|
PBIOp = 0, BIOp = 1;
|
|
|
|
else if (PBI->getSuccessor(1) == BI->getSuccessor(0))
|
|
|
|
PBIOp = 1, BIOp = 0;
|
|
|
|
else if (PBI->getSuccessor(1) == BI->getSuccessor(1))
|
|
|
|
PBIOp = BIOp = 1;
|
|
|
|
else
|
|
|
|
return false;
|
2008-07-13 21:53:26 +00:00
|
|
|
|
2008-07-13 22:04:41 +00:00
|
|
|
// Check to make sure that the other destination of this branch
|
|
|
|
// isn't BB itself. If so, this is an infinite loop that will
|
|
|
|
// keep getting unwound.
|
|
|
|
if (PBI->getSuccessor(PBIOp) == BB)
|
|
|
|
return false;
|
2008-07-13 21:53:26 +00:00
|
|
|
|
2008-07-13 22:04:41 +00:00
|
|
|
// Do not perform this transformation if it would require
|
|
|
|
// insertion of a large number of select instructions. For targets
|
|
|
|
// without predication/cmovs, this is a big pessimization.
|
|
|
|
BasicBlock *CommonDest = PBI->getSuccessor(PBIOp);
|
2008-07-13 21:53:26 +00:00
|
|
|
|
2008-07-13 22:04:41 +00:00
|
|
|
unsigned NumPhis = 0;
|
|
|
|
for (BasicBlock::iterator II = CommonDest->begin();
|
|
|
|
isa<PHINode>(II); ++II, ++NumPhis)
|
|
|
|
if (NumPhis > 2) // Disable this xform.
|
|
|
|
return false;
|
2008-07-13 21:53:26 +00:00
|
|
|
|
2008-07-13 22:04:41 +00:00
|
|
|
// Finally, if everything is ok, fold the branches to logical ops.
|
|
|
|
BasicBlock *OtherDest = BI->getSuccessor(BIOp ^ 1);
|
|
|
|
|
|
|
|
DOUT << "FOLDING BRs:" << *PBI->getParent()
|
|
|
|
<< "AND: " << *BI->getParent();
|
|
|
|
|
2008-07-13 22:23:11 +00:00
|
|
|
|
|
|
|
// If OtherDest *is* BB, then BB is a basic block with a single conditional
|
|
|
|
// branch in it, where one edge (OtherDest) goes back to itself but the other
|
|
|
|
// exits. We don't *know* that the program avoids the infinite loop
|
|
|
|
// (even though that seems likely). If we do this xform naively, we'll end up
|
|
|
|
// recursively unpeeling the loop. Since we know that (after the xform is
|
|
|
|
// done) that the block *is* infinite if reached, we just make it an obviously
|
|
|
|
// infinite loop with no cond branch.
|
|
|
|
if (OtherDest == BB) {
|
|
|
|
// Insert it at the end of the function, because it's either code,
|
|
|
|
// or it won't matter if it's hot. :)
|
|
|
|
BasicBlock *InfLoopBlock = BasicBlock::Create("infloop", BB->getParent());
|
|
|
|
BranchInst::Create(InfLoopBlock, InfLoopBlock);
|
|
|
|
OtherDest = InfLoopBlock;
|
|
|
|
}
|
|
|
|
|
2008-07-13 22:04:41 +00:00
|
|
|
DOUT << *PBI->getParent()->getParent();
|
|
|
|
|
|
|
|
// BI may have other predecessors. Because of this, we leave
|
|
|
|
// it alone, but modify PBI.
|
|
|
|
|
|
|
|
// Make sure we get to CommonDest on True&True directions.
|
|
|
|
Value *PBICond = PBI->getCondition();
|
|
|
|
if (PBIOp)
|
|
|
|
PBICond = BinaryOperator::CreateNot(PBICond,
|
|
|
|
PBICond->getName()+".not",
|
|
|
|
PBI);
|
|
|
|
Value *BICond = BI->getCondition();
|
|
|
|
if (BIOp)
|
|
|
|
BICond = BinaryOperator::CreateNot(BICond,
|
|
|
|
BICond->getName()+".not",
|
|
|
|
PBI);
|
|
|
|
// Merge the conditions.
|
|
|
|
Value *Cond = BinaryOperator::CreateOr(PBICond, BICond, "brmerge", PBI);
|
|
|
|
|
|
|
|
// Modify PBI to branch on the new condition to the new dests.
|
|
|
|
PBI->setCondition(Cond);
|
|
|
|
PBI->setSuccessor(0, CommonDest);
|
|
|
|
PBI->setSuccessor(1, OtherDest);
|
|
|
|
|
|
|
|
// OtherDest may have phi nodes. If so, add an entry from PBI's
|
|
|
|
// block that are identical to the entries for BI's block.
|
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator II = OtherDest->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(II)); ++II) {
|
|
|
|
Value *V = PN->getIncomingValueForBlock(BB);
|
|
|
|
PN->addIncoming(V, PBI->getParent());
|
|
|
|
}
|
|
|
|
|
|
|
|
// We know that the CommonDest already had an edge from PBI to
|
|
|
|
// it. If it has PHIs though, the PHIs may have different
|
|
|
|
// entries for BB and PBI's BB. If so, insert a select to make
|
|
|
|
// them agree.
|
|
|
|
for (BasicBlock::iterator II = CommonDest->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(II)); ++II) {
|
|
|
|
Value *BIV = PN->getIncomingValueForBlock(BB);
|
|
|
|
unsigned PBBIdx = PN->getBasicBlockIndex(PBI->getParent());
|
|
|
|
Value *PBIV = PN->getIncomingValue(PBBIdx);
|
|
|
|
if (BIV != PBIV) {
|
|
|
|
// Insert a select in PBI to pick the right value.
|
|
|
|
Value *NV = SelectInst::Create(PBICond, PBIV, BIV,
|
|
|
|
PBIV->getName()+".mux", PBI);
|
|
|
|
PN->setIncomingValue(PBBIdx, NV);
|
2008-07-13 21:53:26 +00:00
|
|
|
}
|
|
|
|
}
|
2008-07-13 22:04:41 +00:00
|
|
|
|
|
|
|
DOUT << "INTO: " << *PBI->getParent();
|
|
|
|
|
|
|
|
DOUT << *PBI->getParent()->getParent();
|
|
|
|
|
|
|
|
// This basic block is probably dead. We know it has at least
|
|
|
|
// one fewer predecessor.
|
|
|
|
return true;
|
2008-07-13 21:53:26 +00:00
|
|
|
}
|
|
|
|
|
2008-04-24 00:01:19 +00:00
|
|
|
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
namespace {
|
|
|
|
/// ConstantIntOrdering - This class implements a stable ordering of constant
|
|
|
|
/// integers that does not depend on their address. This is important for
|
|
|
|
/// applications that sort ConstantInt's to ensure uniqueness.
|
|
|
|
struct ConstantIntOrdering {
|
|
|
|
bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const {
|
2007-03-02 23:01:14 +00:00
|
|
|
return LHS->getValue().ult(RHS->getValue());
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2002-05-21 20:50:24 +00:00
|
|
|
// SimplifyCFG - This function is used to do simplification of a CFG. For
|
|
|
|
// example, it adjusts branches to branches to eliminate the extra hop, it
|
|
|
|
// eliminates unreachable basic blocks, and does other "peephole" optimization
|
2003-03-05 21:01:52 +00:00
|
|
|
// of the CFG. It returns true if a modification was made.
|
2002-05-21 20:50:24 +00:00
|
|
|
//
|
|
|
|
// WARNING: The entry node of a function may not be simplified.
|
|
|
|
//
|
2004-01-09 06:12:26 +00:00
|
|
|
bool llvm::SimplifyCFG(BasicBlock *BB) {
|
2003-08-24 18:36:16 +00:00
|
|
|
bool Changed = false;
|
2002-05-21 20:50:24 +00:00
|
|
|
Function *M = BB->getParent();
|
|
|
|
|
|
|
|
assert(BB && BB->getParent() && "Block not embedded in function!");
|
|
|
|
assert(BB->getTerminator() && "Degenerate basic block encountered!");
|
2007-03-22 16:38:57 +00:00
|
|
|
assert(&BB->getParent()->getEntryBlock() != BB &&
|
|
|
|
"Can't Simplify entry block!");
|
2002-05-21 20:50:24 +00:00
|
|
|
|
|
|
|
// Remove basic blocks that have no predecessors... which are unreachable.
|
2008-02-20 11:26:25 +00:00
|
|
|
if ((pred_begin(BB) == pred_end(BB)) ||
|
|
|
|
(*pred_begin(BB) == BB && ++pred_begin(BB) == pred_end(BB))) {
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "Removing BB: \n" << *BB;
|
2002-05-21 20:50:24 +00:00
|
|
|
|
|
|
|
// Loop through all of our successors and make sure they know that one
|
|
|
|
// of their predecessors is going away.
|
2005-04-12 18:51:33 +00:00
|
|
|
for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
|
|
|
|
SI->removePredecessor(BB);
|
2002-05-21 20:50:24 +00:00
|
|
|
|
|
|
|
while (!BB->empty()) {
|
2002-06-25 16:12:52 +00:00
|
|
|
Instruction &I = BB->back();
|
2002-05-21 20:50:24 +00:00
|
|
|
// If this instruction is used, replace uses with an arbitrary
|
2005-08-02 23:29:23 +00:00
|
|
|
// value. Because control flow can't get here, we don't care
|
2005-04-21 23:48:37 +00:00
|
|
|
// what we replace the value with. Note that since this block is
|
2002-05-21 20:50:24 +00:00
|
|
|
// unreachable, and all values contained within it must dominate their
|
|
|
|
// uses, that all uses will eventually be removed.
|
2005-04-21 23:48:37 +00:00
|
|
|
if (!I.use_empty())
|
2005-08-02 23:29:23 +00:00
|
|
|
// Make all users of this instruction use undef instead
|
|
|
|
I.replaceAllUsesWith(UndefValue::get(I.getType()));
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-05-21 20:50:24 +00:00
|
|
|
// Remove the instruction from the basic block
|
2002-06-25 16:12:52 +00:00
|
|
|
BB->getInstList().pop_back();
|
2002-05-21 20:50:24 +00:00
|
|
|
}
|
2002-06-25 16:12:52 +00:00
|
|
|
M->getBasicBlockList().erase(BB);
|
2002-05-21 20:50:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2003-08-17 19:41:53 +00:00
|
|
|
// Check to see if we can constant propagate this terminator instruction
|
|
|
|
// away...
|
2003-08-24 18:36:16 +00:00
|
|
|
Changed |= ConstantFoldTerminator(BB);
|
2003-08-17 19:41:53 +00:00
|
|
|
|
2008-03-11 21:53:06 +00:00
|
|
|
// If there is a trivial two-entry PHI node in this basic block, and we can
|
|
|
|
// eliminate it, do so now.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(BB->begin()))
|
|
|
|
if (PN->getNumIncomingValues() == 2)
|
|
|
|
Changed |= FoldTwoEntryPHINode(PN);
|
|
|
|
|
2004-02-16 06:35:48 +00:00
|
|
|
// If this is a returning block with only PHI nodes in it, fold the return
|
|
|
|
// instruction into any unconditional branch predecessors.
|
2004-04-02 18:13:43 +00:00
|
|
|
//
|
|
|
|
// If any predecessor is a conditional branch that just selects among
|
|
|
|
// different return values, fold the replace the branch/return with a select
|
|
|
|
// and return.
|
2004-02-16 06:35:48 +00:00
|
|
|
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
|
|
|
|
BasicBlock::iterator BBI = BB->getTerminator();
|
|
|
|
if (BBI == BB->begin() || isa<PHINode>(--BBI)) {
|
2004-04-02 18:13:43 +00:00
|
|
|
// Find predecessors that end with branches.
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 8> UncondBranchPreds;
|
|
|
|
SmallVector<BranchInst*, 8> CondBranchPreds;
|
2004-02-16 06:35:48 +00:00
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
|
|
|
|
TerminatorInst *PTI = (*PI)->getTerminator();
|
2008-02-20 11:26:25 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
|
2004-02-16 06:35:48 +00:00
|
|
|
if (BI->isUnconditional())
|
|
|
|
UncondBranchPreds.push_back(*PI);
|
2004-04-02 18:13:43 +00:00
|
|
|
else
|
|
|
|
CondBranchPreds.push_back(BI);
|
2008-02-20 11:26:25 +00:00
|
|
|
}
|
2004-02-16 06:35:48 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-16 06:35:48 +00:00
|
|
|
// If we found some, do the transformation!
|
|
|
|
if (!UncondBranchPreds.empty()) {
|
|
|
|
while (!UncondBranchPreds.empty()) {
|
|
|
|
BasicBlock *Pred = UncondBranchPreds.back();
|
2006-11-26 10:17:54 +00:00
|
|
|
DOUT << "FOLDING: " << *BB
|
|
|
|
<< "INTO UNCOND BRANCH PRED: " << *Pred;
|
2004-02-16 06:35:48 +00:00
|
|
|
UncondBranchPreds.pop_back();
|
|
|
|
Instruction *UncondBranch = Pred->getTerminator();
|
|
|
|
// Clone the return and add it to the end of the predecessor.
|
|
|
|
Instruction *NewRet = RI->clone();
|
|
|
|
Pred->getInstList().push_back(NewRet);
|
|
|
|
|
|
|
|
// If the return instruction returns a value, and if the value was a
|
|
|
|
// PHI node in "BB", propagate the right value into the return.
|
2008-06-10 22:03:26 +00:00
|
|
|
for (User::op_iterator i = NewRet->op_begin(), e = NewRet->op_end();
|
|
|
|
i != e; ++i)
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(*i))
|
2004-02-16 06:35:48 +00:00
|
|
|
if (PN->getParent() == BB)
|
2008-06-10 22:03:26 +00:00
|
|
|
*i = PN->getIncomingValueForBlock(Pred);
|
2008-04-28 00:19:07 +00:00
|
|
|
|
2004-02-16 06:35:48 +00:00
|
|
|
// Update any PHI nodes in the returning block to realize that we no
|
|
|
|
// longer branch to them.
|
|
|
|
BB->removePredecessor(Pred);
|
|
|
|
Pred->getInstList().erase(UncondBranch);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we eliminated all predecessors of the block, delete the block now.
|
|
|
|
if (pred_begin(BB) == pred_end(BB))
|
|
|
|
// We know there are no successors, so just nuke the block.
|
|
|
|
M->getBasicBlockList().erase(BB);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2004-04-02 18:13:43 +00:00
|
|
|
|
|
|
|
// Check out all of the conditional branches going to this return
|
|
|
|
// instruction. If any of them just select between returns, change the
|
|
|
|
// branch itself into a select/return pair.
|
|
|
|
while (!CondBranchPreds.empty()) {
|
|
|
|
BranchInst *BI = CondBranchPreds.back();
|
|
|
|
CondBranchPreds.pop_back();
|
|
|
|
|
|
|
|
// Check to see if the non-BB successor is also a return block.
|
2008-04-24 00:01:19 +00:00
|
|
|
if (isa<ReturnInst>(BI->getSuccessor(0)->getTerminator()) &&
|
|
|
|
isa<ReturnInst>(BI->getSuccessor(1)->getTerminator()) &&
|
|
|
|
SimplifyCondBranchToTwoReturns(BI))
|
|
|
|
return true;
|
2004-04-02 18:13:43 +00:00
|
|
|
}
|
2004-02-16 06:35:48 +00:00
|
|
|
}
|
2006-11-02 20:25:50 +00:00
|
|
|
} else if (isa<UnwindInst>(BB->begin())) {
|
2004-02-24 05:54:22 +00:00
|
|
|
// Check to see if the first instruction in this block is just an unwind.
|
|
|
|
// If so, replace any invoke instructions which use this as an exception
|
2004-07-20 01:17:38 +00:00
|
|
|
// destination with call instructions, and any unconditional branch
|
|
|
|
// predecessor with an unwind.
|
2004-02-24 05:54:22 +00:00
|
|
|
//
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB));
|
2004-02-24 05:54:22 +00:00
|
|
|
while (!Preds.empty()) {
|
|
|
|
BasicBlock *Pred = Preds.back();
|
2004-07-20 01:17:38 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(Pred->getTerminator())) {
|
2008-04-25 16:53:59 +00:00
|
|
|
if (BI->isUnconditional()) {
|
2004-07-20 01:17:38 +00:00
|
|
|
Pred->getInstList().pop_back(); // nuke uncond branch
|
|
|
|
new UnwindInst(Pred); // Use unwind.
|
|
|
|
Changed = true;
|
|
|
|
}
|
2008-03-09 07:50:37 +00:00
|
|
|
} else if (InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator()))
|
2004-02-24 05:54:22 +00:00
|
|
|
if (II->getUnwindDest() == BB) {
|
|
|
|
// Insert a new branch instruction before the invoke, because this
|
|
|
|
// is now a fall through...
|
2008-04-06 20:25:17 +00:00
|
|
|
BranchInst *BI = BranchInst::Create(II->getNormalDest(), II);
|
2004-02-24 05:54:22 +00:00
|
|
|
Pred->getInstList().remove(II); // Take out of symbol table
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:54:22 +00:00
|
|
|
// Insert the call now...
|
2007-02-13 02:10:56 +00:00
|
|
|
SmallVector<Value*,8> Args(II->op_begin()+3, II->op_end());
|
2008-04-06 20:25:17 +00:00
|
|
|
CallInst *CI = CallInst::Create(II->getCalledValue(),
|
2008-06-10 22:03:26 +00:00
|
|
|
Args.begin(), Args.end(),
|
|
|
|
II->getName(), BI);
|
2005-05-14 12:21:56 +00:00
|
|
|
CI->setCallingConv(II->getCallingConv());
|
2007-11-27 13:23:08 +00:00
|
|
|
CI->setParamAttrs(II->getParamAttrs());
|
2004-02-24 05:54:22 +00:00
|
|
|
// If the invoke produced a value, the Call now does instead
|
|
|
|
II->replaceAllUsesWith(CI);
|
|
|
|
delete II;
|
|
|
|
Changed = true;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:54:22 +00:00
|
|
|
Preds.pop_back();
|
|
|
|
}
|
2004-02-24 16:09:21 +00:00
|
|
|
|
|
|
|
// If this block is now dead, remove it.
|
|
|
|
if (pred_begin(BB) == pred_end(BB)) {
|
|
|
|
// We know there are no successors, so just nuke the block.
|
|
|
|
M->getBasicBlockList().erase(BB);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-02-24 06:17:52 +00:00
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {
|
|
|
|
if (isValueEqualityComparison(SI)) {
|
|
|
|
// If we only have one predecessor, and if it is a branch on this value,
|
|
|
|
// see if that predecessor totally determines the outcome of this switch.
|
|
|
|
if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
|
|
|
|
if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred))
|
|
|
|
return SimplifyCFG(BB) || 1;
|
|
|
|
|
|
|
|
// If the block only contains the switch, see if we can fold the block
|
|
|
|
// away into any preds.
|
|
|
|
if (SI == &BB->front())
|
|
|
|
if (FoldValueComparisonIntoPredecessors(SI))
|
|
|
|
return SimplifyCFG(BB) || 1;
|
|
|
|
}
|
Implement switch->br and br->switch folding by ripping out the switch->switch
and br->br code and generalizing it. This allows us to compile code like this:
int test(Instruction *I) {
if (isa<CastInst>(I))
return foo(7);
else if (isa<BranchInst>(I))
return foo(123);
else if (isa<UnwindInst>(I))
return foo(1241);
else if (isa<SetCondInst>(I))
return foo(1);
else if (isa<VAArgInst>(I))
return foo(42);
return foo(-1);
}
into:
int %_Z4testPN4llvm11InstructionE("struct.llvm::Instruction"* %I) {
entry:
%tmp.1.i.i.i.i.i.i.i = getelementptr "struct.llvm::Instruction"* %I, long 0, ubyte 4 ; <uint*> [#uses=1]
%tmp.2.i.i.i.i.i.i.i = load uint* %tmp.1.i.i.i.i.i.i.i ; <uint> [#uses=2]
%tmp.2.i.i.i.i.i.i = seteq uint %tmp.2.i.i.i.i.i.i.i, 27 ; <bool> [#uses=0]
switch uint %tmp.2.i.i.i.i.i.i.i, label %endif.0 [
uint 27, label %then.0
uint 2, label %then.1
uint 5, label %then.2
uint 14, label %then.3
uint 15, label %then.3
uint 16, label %then.3
uint 17, label %then.3
uint 18, label %then.3
uint 19, label %then.3
uint 32, label %then.4
]
...
As well as handling the cases in 176.gcc and many other programs more effectively.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@11964 91177308-0d34-0410-b5e6-96231b3b80d8
2004-02-28 21:28:10 +00:00
|
|
|
} else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
|
2005-08-03 00:11:16 +00:00
|
|
|
if (BI->isUnconditional()) {
|
2008-05-23 21:05:58 +00:00
|
|
|
BasicBlock::iterator BBI = BB->getFirstNonPHI();
|
2005-08-03 00:11:16 +00:00
|
|
|
|
|
|
|
BasicBlock *Succ = BI->getSuccessor(0);
|
|
|
|
if (BBI->isTerminator() && // Terminator is the only non-phi instruction!
|
|
|
|
Succ != BB) // Don't hurt infinite loops!
|
|
|
|
if (TryToSimplifyUncondBranchFromEmptyBlock(BB, Succ))
|
2008-07-13 21:12:01 +00:00
|
|
|
return true;
|
2005-08-03 00:11:16 +00:00
|
|
|
|
|
|
|
} else { // Conditional branch
|
2006-11-02 20:25:50 +00:00
|
|
|
if (isValueEqualityComparison(BI)) {
|
2005-02-24 06:17:52 +00:00
|
|
|
// If we only have one predecessor, and if it is a branch on this value,
|
|
|
|
// see if that predecessor totally determines the outcome of this
|
|
|
|
// switch.
|
|
|
|
if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
|
|
|
|
if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred))
|
|
|
|
return SimplifyCFG(BB) || 1;
|
|
|
|
|
2004-05-01 23:35:43 +00:00
|
|
|
// This block must be empty, except for the setcond inst, if it exists.
|
|
|
|
BasicBlock::iterator I = BB->begin();
|
|
|
|
if (&*I == BI ||
|
|
|
|
(&*I == cast<Instruction>(BI->getCondition()) &&
|
|
|
|
&*++I == BI))
|
|
|
|
if (FoldValueComparisonIntoPredecessors(BI))
|
|
|
|
return SimplifyCFG(BB) | true;
|
|
|
|
}
|
2005-09-19 23:49:37 +00:00
|
|
|
|
|
|
|
// If this is a branch on a phi node in the current block, thread control
|
|
|
|
// through this block if any PHI node entries are constants.
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition()))
|
|
|
|
if (PN->getParent() == BI->getParent())
|
|
|
|
if (FoldCondBranchOnPHI(BI))
|
|
|
|
return SimplifyCFG(BB) | true;
|
2004-05-01 23:35:43 +00:00
|
|
|
|
|
|
|
// If this basic block is ONLY a setcc and a branch, and if a predecessor
|
|
|
|
// branches to us and one of our successors, fold the setcc into the
|
|
|
|
// predecessor and use logical operations to pick the right destination.
|
2008-07-13 21:12:01 +00:00
|
|
|
if (FoldBranchToCommonDest(BI))
|
|
|
|
return SimplifyCFG(BB) | 1;
|
2004-05-01 23:35:43 +00:00
|
|
|
|
2008-07-13 21:53:26 +00:00
|
|
|
|
|
|
|
// Scan predecessor blocks for conditional branches.
|
2005-09-20 00:43:16 +00:00
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
|
|
|
|
if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
|
2008-07-13 21:53:26 +00:00
|
|
|
if (PBI != BI && PBI->isConditional())
|
|
|
|
if (SimplifyCondBranchToCondBranch(PBI, BI))
|
|
|
|
return SimplifyCFG(BB) | true;
|
2004-02-24 07:23:58 +00:00
|
|
|
}
|
2004-10-18 04:07:22 +00:00
|
|
|
} else if (isa<UnreachableInst>(BB->getTerminator())) {
|
|
|
|
// If there are any instructions immediately before the unreachable that can
|
|
|
|
// be removed, do so.
|
|
|
|
Instruction *Unreachable = BB->getTerminator();
|
|
|
|
while (Unreachable != BB->begin()) {
|
|
|
|
BasicBlock::iterator BBI = Unreachable;
|
|
|
|
--BBI;
|
|
|
|
if (isa<CallInst>(BBI)) break;
|
|
|
|
// Delete this instruction
|
|
|
|
BB->getInstList().erase(BBI);
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the unreachable instruction is the first in the block, take a gander
|
|
|
|
// at all of the predecessors of this instruction, and simplify them.
|
|
|
|
if (&BB->front() == Unreachable) {
|
2008-02-18 07:42:56 +00:00
|
|
|
SmallVector<BasicBlock*, 8> Preds(pred_begin(BB), pred_end(BB));
|
2004-10-18 04:07:22 +00:00
|
|
|
for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
|
|
|
|
TerminatorInst *TI = Preds[i]->getTerminator();
|
|
|
|
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
|
|
|
if (BI->isUnconditional()) {
|
|
|
|
if (BI->getSuccessor(0) == BB) {
|
|
|
|
new UnreachableInst(TI);
|
|
|
|
TI->eraseFromParent();
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (BI->getSuccessor(0) == BB) {
|
2008-04-06 20:25:17 +00:00
|
|
|
BranchInst::Create(BI->getSuccessor(1), BI);
|
2004-10-18 04:07:22 +00:00
|
|
|
BI->eraseFromParent();
|
|
|
|
} else if (BI->getSuccessor(1) == BB) {
|
2008-04-06 20:25:17 +00:00
|
|
|
BranchInst::Create(BI->getSuccessor(0), BI);
|
2004-10-18 04:07:22 +00:00
|
|
|
BI->eraseFromParent();
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
|
|
|
for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i)
|
|
|
|
if (SI->getSuccessor(i) == BB) {
|
2005-05-20 22:19:54 +00:00
|
|
|
BB->removePredecessor(SI->getParent());
|
2004-10-18 04:07:22 +00:00
|
|
|
SI->removeCase(i);
|
|
|
|
--i; --e;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
// If the default value is unreachable, figure out the most popular
|
|
|
|
// destination and make it the default.
|
|
|
|
if (SI->getSuccessor(0) == BB) {
|
|
|
|
std::map<BasicBlock*, unsigned> Popularity;
|
|
|
|
for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i)
|
|
|
|
Popularity[SI->getSuccessor(i)]++;
|
|
|
|
|
|
|
|
// Find the most popular block.
|
|
|
|
unsigned MaxPop = 0;
|
|
|
|
BasicBlock *MaxBlock = 0;
|
|
|
|
for (std::map<BasicBlock*, unsigned>::iterator
|
|
|
|
I = Popularity.begin(), E = Popularity.end(); I != E; ++I) {
|
|
|
|
if (I->second > MaxPop) {
|
|
|
|
MaxPop = I->second;
|
|
|
|
MaxBlock = I->first;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (MaxBlock) {
|
|
|
|
// Make this the new default, allowing us to delete any explicit
|
|
|
|
// edges to it.
|
|
|
|
SI->setSuccessor(0, MaxBlock);
|
|
|
|
Changed = true;
|
|
|
|
|
2005-05-20 22:19:54 +00:00
|
|
|
// If MaxBlock has phinodes in it, remove MaxPop-1 entries from
|
|
|
|
// it.
|
|
|
|
if (isa<PHINode>(MaxBlock->begin()))
|
|
|
|
for (unsigned i = 0; i != MaxPop-1; ++i)
|
|
|
|
MaxBlock->removePredecessor(SI->getParent());
|
|
|
|
|
2004-10-18 04:07:22 +00:00
|
|
|
for (unsigned i = 1, e = SI->getNumCases(); i != e; ++i)
|
|
|
|
if (SI->getSuccessor(i) == MaxBlock) {
|
|
|
|
SI->removeCase(i);
|
|
|
|
--i; --e;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (InvokeInst *II = dyn_cast<InvokeInst>(TI)) {
|
|
|
|
if (II->getUnwindDest() == BB) {
|
|
|
|
// Convert the invoke to a call instruction. This would be a good
|
|
|
|
// place to note that the call does not throw though.
|
2008-04-06 20:25:17 +00:00
|
|
|
BranchInst *BI = BranchInst::Create(II->getNormalDest(), II);
|
2004-10-18 04:07:22 +00:00
|
|
|
II->removeFromParent(); // Take out of symbol table
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-10-18 04:07:22 +00:00
|
|
|
// Insert the call now...
|
2007-02-13 02:10:56 +00:00
|
|
|
SmallVector<Value*, 8> Args(II->op_begin()+3, II->op_end());
|
2008-04-06 20:25:17 +00:00
|
|
|
CallInst *CI = CallInst::Create(II->getCalledValue(),
|
|
|
|
Args.begin(), Args.end(),
|
|
|
|
II->getName(), BI);
|
2005-05-14 12:21:56 +00:00
|
|
|
CI->setCallingConv(II->getCallingConv());
|
2007-11-27 13:23:08 +00:00
|
|
|
CI->setParamAttrs(II->getParamAttrs());
|
2004-10-18 04:07:22 +00:00
|
|
|
// If the invoke produced a value, the Call does now instead.
|
|
|
|
II->replaceAllUsesWith(CI);
|
|
|
|
delete II;
|
|
|
|
Changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this block is now dead, remove it.
|
|
|
|
if (pred_begin(BB) == pred_end(BB)) {
|
|
|
|
// We know there are no successors, so just nuke the block.
|
|
|
|
M->getBasicBlockList().erase(BB);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2004-02-16 06:35:48 +00:00
|
|
|
}
|
|
|
|
|
2002-05-21 20:50:24 +00:00
|
|
|
// Merge basic blocks into their predecessor if there is only one distinct
|
|
|
|
// pred, and if there is only one distinct successor of the predecessor, and
|
|
|
|
// if there are no PHI nodes.
|
|
|
|
//
|
2008-07-18 17:49:43 +00:00
|
|
|
if (MergeBlockIntoPredecessor(BB))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Otherwise, if this block only has a single predecessor, and if that block
|
|
|
|
// is a conditional branch, see if we can hoist any code from this block up
|
|
|
|
// into our predecessor.
|
2004-02-11 01:17:07 +00:00
|
|
|
pred_iterator PI(pred_begin(BB)), PE(pred_end(BB));
|
|
|
|
BasicBlock *OnlyPred = *PI++;
|
|
|
|
for (; PI != PE; ++PI) // Search all predecessors, see if they are all same
|
|
|
|
if (*PI != OnlyPred) {
|
|
|
|
OnlyPred = 0; // There are multiple different predecessors...
|
|
|
|
break;
|
|
|
|
}
|
2008-07-18 17:49:43 +00:00
|
|
|
|
2004-11-30 00:29:14 +00:00
|
|
|
if (OnlyPred)
|
2004-12-10 17:42:31 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(OnlyPred->getTerminator()))
|
|
|
|
if (BI->isConditional()) {
|
|
|
|
// Get the other block.
|
|
|
|
BasicBlock *OtherBB = BI->getSuccessor(BI->getSuccessor(0) == BB);
|
|
|
|
PI = pred_begin(OtherBB);
|
|
|
|
++PI;
|
2008-07-18 17:49:43 +00:00
|
|
|
|
2004-12-10 17:42:31 +00:00
|
|
|
if (PI == pred_end(OtherBB)) {
|
|
|
|
// We have a conditional branch to two blocks that are only reachable
|
|
|
|
// from the condbr. We know that the condbr dominates the two blocks,
|
|
|
|
// so see if there is any identical code in the "then" and "else"
|
|
|
|
// blocks. If so, we can hoist it up to the branching block.
|
|
|
|
Changed |= HoistThenElseCodeToIf(BI);
|
2008-06-07 08:52:29 +00:00
|
|
|
} else {
|
2008-07-18 17:49:43 +00:00
|
|
|
BasicBlock* OnlySucc = NULL;
|
2008-06-07 08:52:29 +00:00
|
|
|
for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB);
|
|
|
|
SI != SE; ++SI) {
|
|
|
|
if (!OnlySucc)
|
|
|
|
OnlySucc = *SI;
|
|
|
|
else if (*SI != OnlySucc) {
|
|
|
|
OnlySucc = 0; // There are multiple distinct successors!
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (OnlySucc == OtherBB) {
|
|
|
|
// If BB's only successor is the other successor of the predecessor,
|
|
|
|
// i.e. a triangle, see if we can hoist any code from this block up
|
|
|
|
// to the "if" block.
|
|
|
|
Changed |= SpeculativelyExecuteBB(BI, BB);
|
|
|
|
}
|
2004-12-10 17:42:31 +00:00
|
|
|
}
|
2004-11-30 00:29:14 +00:00
|
|
|
}
|
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>((*PI)->getTerminator()))
|
|
|
|
// Change br (X == 0 | X == 1), T, F into a switch instruction.
|
|
|
|
if (BI->isConditional() && isa<Instruction>(BI->getCondition())) {
|
|
|
|
Instruction *Cond = cast<Instruction>(BI->getCondition());
|
|
|
|
// If this is a bunch of seteq's or'd together, or if it's a bunch of
|
|
|
|
// 'setne's and'ed together, collect them.
|
|
|
|
Value *CompVal = 0;
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
std::vector<ConstantInt*> Values;
|
2004-02-24 05:38:11 +00:00
|
|
|
bool TrueWhenEqual = GatherValueComparisons(Cond, CompVal, Values);
|
2007-01-15 02:27:26 +00:00
|
|
|
if (CompVal && CompVal->getType()->isInteger()) {
|
2004-02-24 05:38:11 +00:00
|
|
|
// There might be duplicate constants in the list, which the switch
|
|
|
|
// instruction can't handle, remove them now.
|
Do not sort by the address of LLVM ConstantInt* objects. This produces
nondeterministic results that depend on where these objects land in memory.
Instead, sort by the value of the constant, which is stable.
Before this patch, the -simplifycfg pass run from two different compilers
could cause different code to be generated, though it was semantically the
same:
@@ -12258,8 +12258,8 @@
%s_addr.1 = phi sbyte* [ %s, %entry ], [ %inc.0, %no_exit ] ; <sbyte*> [#uses=5]
%tmp.1 = load sbyte* %s_addr.1 ; <sbyte> [#uses=1]
switch sbyte %tmp.1, label %no_exit [
- sbyte 0, label %loopexit
sbyte 46, label %loopexit
+ sbyte 0, label %loopexit
]
We need to stomp all of this stuff out.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14243 91177308-0d34-0410-b5e6-96231b3b80d8
2004-06-19 07:02:14 +00:00
|
|
|
std::sort(Values.begin(), Values.end(), ConstantIntOrdering());
|
2004-02-24 05:38:11 +00:00
|
|
|
Values.erase(std::unique(Values.begin(), Values.end()), Values.end());
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
// Figure out which block is which destination.
|
|
|
|
BasicBlock *DefaultBB = BI->getSuccessor(1);
|
|
|
|
BasicBlock *EdgeBB = BI->getSuccessor(0);
|
|
|
|
if (!TrueWhenEqual) std::swap(DefaultBB, EdgeBB);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
// Create the new switch instruction now.
|
2008-05-15 10:04:30 +00:00
|
|
|
SwitchInst *New = SwitchInst::Create(CompVal, DefaultBB,
|
|
|
|
Values.size(), BI);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
// Add all of the 'cases' to the switch instruction.
|
|
|
|
for (unsigned i = 0, e = Values.size(); i != e; ++i)
|
|
|
|
New->addCase(Values[i], EdgeBB);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-24 05:38:11 +00:00
|
|
|
// We added edges from PI to the EdgeBB. As such, if there were any
|
|
|
|
// PHI nodes in EdgeBB, they need entries to be added corresponding to
|
|
|
|
// the number of edges added.
|
|
|
|
for (BasicBlock::iterator BBI = EdgeBB->begin();
|
2004-09-15 17:06:42 +00:00
|
|
|
isa<PHINode>(BBI); ++BBI) {
|
|
|
|
PHINode *PN = cast<PHINode>(BBI);
|
2004-02-24 05:38:11 +00:00
|
|
|
Value *InVal = PN->getIncomingValueForBlock(*PI);
|
|
|
|
for (unsigned i = 0, e = Values.size()-1; i != e; ++i)
|
|
|
|
PN->addIncoming(InVal, *PI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Erase the old branch instruction.
|
|
|
|
(*PI)->getInstList().erase(BI);
|
|
|
|
|
|
|
|
// Erase the potentially condition tree that was used to computed the
|
|
|
|
// branch condition.
|
|
|
|
ErasePossiblyDeadInstructionTree(Cond);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-08-17 19:41:53 +00:00
|
|
|
return Changed;
|
2002-05-21 20:50:24 +00:00
|
|
|
}
|