2003-05-20 21:01:22 +00:00
|
|
|
//===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===//
|
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
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-27 23:38:11 +00:00
|
|
|
//
|
2003-05-20 21:01:22 +00:00
|
|
|
// This file implements sparse conditional constant propagation and merging:
|
2001-06-27 23:38:11 +00:00
|
|
|
//
|
|
|
|
// Specifically, this:
|
|
|
|
// * Assumes values are constant unless proven otherwise
|
|
|
|
// * Assumes BasicBlocks are dead unless proven otherwise
|
|
|
|
// * Proves values to be constant, and replaces them with constants
|
2002-08-30 23:39:00 +00:00
|
|
|
// * Proves conditional branches to be unconditional
|
2001-06-27 23:38:11 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
#define DEBUG_TYPE "sccp"
|
2002-05-07 20:03:00 +00:00
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2004-12-10 08:02:06 +00:00
|
|
|
#include "llvm/Transforms/IPO.h"
|
2004-01-12 17:43:40 +00:00
|
|
|
#include "llvm/Constants.h"
|
2004-12-11 05:15:59 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2003-04-25 02:50:03 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2002-02-26 21:46:54 +00:00
|
|
|
#include "llvm/Pass.h"
|
2007-01-30 23:46:24 +00:00
|
|
|
#include "llvm/Analysis/ConstantFolding.h"
|
2008-06-20 01:15:44 +00:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2004-04-13 19:43:54 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2009-11-02 06:06:14 +00:00
|
|
|
#include "llvm/Target/TargetData.h"
|
2004-12-10 08:02:06 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-11 13:10:19 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2007-01-30 23:46:24 +00:00
|
|
|
#include "llvm/Support/InstVisitor.h"
|
2009-07-25 00:23:56 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2007-02-02 20:38:30 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2008-08-23 23:36:38 +00:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2009-11-02 02:20:32 +00:00
|
|
|
#include "llvm/ADT/PointerIntPair.h"
|
2009-11-02 06:11:23 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2007-01-30 23:15:19 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2001-06-27 23:38:11 +00:00
|
|
|
#include <algorithm>
|
2008-03-21 23:51:57 +00:00
|
|
|
#include <map>
|
2004-01-09 06:02:20 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2006-12-19 21:40:18 +00:00
|
|
|
STATISTIC(NumInstRemoved, "Number of instructions removed");
|
|
|
|
STATISTIC(NumDeadBlocks , "Number of basic blocks unreachable");
|
|
|
|
|
2008-03-08 07:48:41 +00:00
|
|
|
STATISTIC(IPNumInstRemoved, "Number of instructions removed by IPSCCP");
|
2006-12-19 21:40:18 +00:00
|
|
|
STATISTIC(IPNumArgsElimed ,"Number of arguments constant propagated by IPSCCP");
|
|
|
|
STATISTIC(IPNumGlobalConst, "Number of globals found to be constant by IPSCCP");
|
|
|
|
|
2002-04-29 21:26:08 +00:00
|
|
|
namespace {
|
2006-12-20 06:21:33 +00:00
|
|
|
/// LatticeVal class - This class represents the different lattice values that
|
|
|
|
/// an LLVM value may occupy. It is a simple class with value semantics.
|
|
|
|
///
|
2009-09-02 06:11:42 +00:00
|
|
|
class LatticeVal {
|
2009-11-02 02:20:32 +00:00
|
|
|
enum LatticeValueTy {
|
2006-12-20 06:21:33 +00:00
|
|
|
/// undefined - This LLVM Value has no known value yet.
|
|
|
|
undefined,
|
|
|
|
|
|
|
|
/// constant - This LLVM Value has a specific constant value.
|
|
|
|
constant,
|
|
|
|
|
|
|
|
/// forcedconstant - This LLVM Value was thought to be undef until
|
|
|
|
/// ResolvedUndefsIn. This is treated just like 'constant', but if merged
|
|
|
|
/// with another (different) constant, it goes to overdefined, instead of
|
|
|
|
/// asserting.
|
|
|
|
forcedconstant,
|
|
|
|
|
|
|
|
/// overdefined - This instruction is not known to be constant, and we know
|
|
|
|
/// it has a value.
|
|
|
|
overdefined
|
2009-11-02 02:20:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Val: This stores the current lattice value along with the Constant* for
|
|
|
|
/// the constant if this is a 'constant' or 'forcedconstant' value.
|
|
|
|
PointerIntPair<Constant *, 2, LatticeValueTy> Val;
|
|
|
|
|
|
|
|
LatticeValueTy getLatticeValue() const {
|
|
|
|
return Val.getInt();
|
|
|
|
}
|
2006-12-20 06:21:33 +00:00
|
|
|
|
2001-06-27 23:38:11 +00:00
|
|
|
public:
|
2009-11-02 03:03:42 +00:00
|
|
|
LatticeVal() : Val(0, undefined) {}
|
2009-11-02 02:20:32 +00:00
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
bool isUndefined() const { return getLatticeValue() == undefined; }
|
|
|
|
bool isConstant() const {
|
2009-11-02 02:20:32 +00:00
|
|
|
return getLatticeValue() == constant || getLatticeValue() == forcedconstant;
|
|
|
|
}
|
2009-11-02 03:03:42 +00:00
|
|
|
bool isOverdefined() const { return getLatticeValue() == overdefined; }
|
2009-11-02 02:20:32 +00:00
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
Constant *getConstant() const {
|
2009-11-02 02:20:32 +00:00
|
|
|
assert(isConstant() && "Cannot get the constant of a non-constant!");
|
|
|
|
return Val.getPointer();
|
|
|
|
}
|
2006-12-20 06:21:33 +00:00
|
|
|
|
2009-11-02 02:20:32 +00:00
|
|
|
/// markOverdefined - Return true if this is a change in status.
|
2009-11-02 03:03:42 +00:00
|
|
|
bool markOverdefined() {
|
2009-11-02 02:20:32 +00:00
|
|
|
if (isOverdefined())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Val.setInt(overdefined);
|
|
|
|
return true;
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 02:20:32 +00:00
|
|
|
/// markConstant - Return true if this is a change in status.
|
2009-11-02 03:03:42 +00:00
|
|
|
bool markConstant(Constant *V) {
|
2009-11-03 16:50:11 +00:00
|
|
|
if (getLatticeValue() == constant) { // Constant but not forcedconstant.
|
2009-11-02 02:20:32 +00:00
|
|
|
assert(getConstant() == V && "Marking constant with different value");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isUndefined()) {
|
|
|
|
Val.setInt(constant);
|
|
|
|
assert(V && "Marking constant with NULL");
|
|
|
|
Val.setPointer(V);
|
2001-06-27 23:38:11 +00:00
|
|
|
} else {
|
2009-11-02 02:20:32 +00:00
|
|
|
assert(getLatticeValue() == forcedconstant &&
|
|
|
|
"Cannot move from overdefined to constant!");
|
|
|
|
// Stay at forcedconstant if the constant is the same.
|
|
|
|
if (V == getConstant()) return false;
|
|
|
|
|
|
|
|
// Otherwise, we go to overdefined. Assumptions made based on the
|
|
|
|
// forced value are possibly wrong. Assuming this is another constant
|
|
|
|
// could expose a contradiction.
|
|
|
|
Val.setInt(overdefined);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
2009-11-02 02:20:32 +00:00
|
|
|
return true;
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 03:21:36 +00:00
|
|
|
/// getConstantInt - If this is a constant with a ConstantInt value, return it
|
|
|
|
/// otherwise return null.
|
|
|
|
ConstantInt *getConstantInt() const {
|
|
|
|
if (isConstant())
|
|
|
|
return dyn_cast<ConstantInt>(getConstant());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
void markForcedConstant(Constant *V) {
|
2009-11-02 02:20:32 +00:00
|
|
|
assert(isUndefined() && "Can't force a defined value!");
|
|
|
|
Val.setInt(forcedconstant);
|
|
|
|
Val.setPointer(V);
|
2004-01-12 03:57:30 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
};
|
2009-11-02 02:47:51 +00:00
|
|
|
} // end anonymous namespace.
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
2001-06-27 23:38:11 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
/// SCCPSolver - This class is a general purpose solver for Sparse Conditional
|
|
|
|
/// Constant Propagation.
|
|
|
|
///
|
|
|
|
class SCCPSolver : public InstVisitor<SCCPSolver> {
|
2009-11-02 06:06:14 +00:00
|
|
|
const TargetData *TD;
|
2009-11-02 06:11:23 +00:00
|
|
|
SmallPtrSet<BasicBlock*, 8> BBExecutable;// The BBs that are executable.
|
2009-11-02 05:55:40 +00:00
|
|
|
DenseMap<Value*, LatticeVal> ValueState; // The state each value is in.
|
2004-07-15 23:36:43 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
/// StructValueState - This maintains ValueState for values that have
|
|
|
|
/// StructType, for example for formal arguments, calls, insertelement, etc.
|
|
|
|
///
|
|
|
|
DenseMap<std::pair<Value*, unsigned>, LatticeVal> StructValueState;
|
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
/// GlobalValue - If we are tracking any values for the contents of a global
|
|
|
|
/// variable, we keep a mapping from the constant accessor to the element of
|
|
|
|
/// the global, to the currently known value. If the value becomes
|
|
|
|
/// overdefined, it's entry is simply removed from this map.
|
2007-02-02 20:38:30 +00:00
|
|
|
DenseMap<GlobalVariable*, LatticeVal> TrackedGlobals;
|
2004-12-11 05:15:59 +00:00
|
|
|
|
2008-03-11 05:46:42 +00:00
|
|
|
/// TrackedRetVals - If we are tracking arguments into and the return
|
2004-12-10 08:02:06 +00:00
|
|
|
/// value out of a function, it will have an entry in this map, indicating
|
|
|
|
/// what the known return value for the function is.
|
2008-03-11 05:46:42 +00:00
|
|
|
DenseMap<Function*, LatticeVal> TrackedRetVals;
|
|
|
|
|
|
|
|
/// TrackedMultipleRetVals - Same as TrackedRetVals, but used for functions
|
|
|
|
/// that return multiple values.
|
2008-08-23 23:36:38 +00:00
|
|
|
DenseMap<std::pair<Function*, unsigned>, LatticeVal> TrackedMultipleRetVals;
|
2009-11-03 23:40:48 +00:00
|
|
|
|
|
|
|
/// MRVFunctionsTracked - Each function in TrackedMultipleRetVals is
|
|
|
|
/// represented here for efficient lookup.
|
|
|
|
SmallPtrSet<Function*, 16> MRVFunctionsTracked;
|
2004-12-10 08:02:06 +00:00
|
|
|
|
2009-11-03 20:52:57 +00:00
|
|
|
/// TrackingIncomingArguments - This is the set of functions for whose
|
|
|
|
/// arguments we make optimistic assumptions about and try to prove as
|
|
|
|
/// constants.
|
2009-11-03 19:24:51 +00:00
|
|
|
SmallPtrSet<Function*, 16> TrackingIncomingArguments;
|
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
/// The reason for two worklists is that overdefined is the lowest state
|
|
|
|
/// on the lattice, and moving things to overdefined as fast as possible
|
|
|
|
/// makes SCCP converge much faster.
|
|
|
|
///
|
|
|
|
/// By having a separate worklist, we accomplish this because everything
|
|
|
|
/// possibly overdefined will become overdefined at the soonest possible
|
|
|
|
/// point.
|
2008-08-23 23:36:38 +00:00
|
|
|
SmallVector<Value*, 64> OverdefinedInstWorkList;
|
|
|
|
SmallVector<Value*, 64> InstWorkList;
|
2004-07-15 23:36:43 +00:00
|
|
|
|
|
|
|
|
2008-08-23 23:36:38 +00:00
|
|
|
SmallVector<BasicBlock*, 64> BBWorkList; // The BasicBlock work list
|
2003-10-08 16:55:34 +00:00
|
|
|
|
2004-01-12 03:57:30 +00:00
|
|
|
/// UsersOfOverdefinedPHIs - Keep track of any users of PHI nodes that are not
|
|
|
|
/// overdefined, despite the fact that the PHI node is overdefined.
|
|
|
|
std::multimap<PHINode*, Instruction*> UsersOfOverdefinedPHIs;
|
|
|
|
|
2003-10-08 16:55:34 +00:00
|
|
|
/// KnownFeasibleEdges - Entries in this set are edges which have already had
|
|
|
|
/// PHI nodes retriggered.
|
2008-08-23 23:36:38 +00:00
|
|
|
typedef std::pair<BasicBlock*, BasicBlock*> Edge;
|
|
|
|
DenseSet<Edge> KnownFeasibleEdges;
|
2002-04-29 21:26:08 +00:00
|
|
|
public:
|
2009-11-02 06:06:14 +00:00
|
|
|
SCCPSolver(const TargetData *td) : TD(td) {}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
/// MarkBlockExecutable - This method can be used by clients to mark all of
|
|
|
|
/// the blocks that are known to be intrinsically live in the processed unit.
|
2009-11-02 06:11:23 +00:00
|
|
|
///
|
|
|
|
/// This returns true if the block was not considered live before.
|
|
|
|
bool MarkBlockExecutable(BasicBlock *BB) {
|
|
|
|
if (!BBExecutable.insert(BB)) return false;
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "Marking Block Executable: " << BB->getName() << "\n");
|
2004-11-15 04:44:20 +00:00
|
|
|
BBWorkList.push_back(BB); // Add the block to the work list!
|
2009-11-02 06:11:23 +00:00
|
|
|
return true;
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
/// TrackValueOfGlobalVariable - Clients can use this method to
|
2004-12-10 08:02:06 +00:00
|
|
|
/// inform the SCCPSolver that it should track loads and stores to the
|
|
|
|
/// specified global variable if it can. This is only legal to call if
|
|
|
|
/// performing Interprocedural SCCP.
|
2004-12-11 05:15:59 +00:00
|
|
|
void TrackValueOfGlobalVariable(GlobalVariable *GV) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// We only track the contents of scalar globals.
|
|
|
|
if (GV->getType()->getElementType()->isSingleValueType()) {
|
2004-12-11 05:15:59 +00:00
|
|
|
LatticeVal &IV = TrackedGlobals[GV];
|
|
|
|
if (!isa<UndefValue>(GV->getInitializer()))
|
|
|
|
IV.markConstant(GV->getInitializer());
|
|
|
|
}
|
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
/// AddTrackedFunction - If the SCCP solver is supposed to track calls into
|
|
|
|
/// and out of the specified function (which cannot have its address taken),
|
|
|
|
/// this method must be called.
|
|
|
|
void AddTrackedFunction(Function *F) {
|
|
|
|
// Add an entry, F -> undef.
|
2008-03-11 05:46:42 +00:00
|
|
|
if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
|
2009-11-03 23:40:48 +00:00
|
|
|
MRVFunctionsTracked.insert(F);
|
2008-03-11 05:46:42 +00:00
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
|
2008-04-23 05:38:20 +00:00
|
|
|
TrackedMultipleRetVals.insert(std::make_pair(std::make_pair(F, i),
|
|
|
|
LatticeVal()));
|
|
|
|
} else
|
|
|
|
TrackedRetVals.insert(std::make_pair(F, LatticeVal()));
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 19:24:51 +00:00
|
|
|
void AddArgumentTrackedFunction(Function *F) {
|
|
|
|
TrackingIncomingArguments.insert(F);
|
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
/// Solve - Solve for constants and executable blocks.
|
|
|
|
///
|
|
|
|
void Solve();
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
/// ResolvedUndefsIn - While solving the dataflow for a function, we assume
|
2004-12-10 20:41:50 +00:00
|
|
|
/// that branches on undef values cannot reach any of their successors.
|
|
|
|
/// However, this is not a safe assumption. After we solve dataflow, this
|
|
|
|
/// method should be use to handle this. If this returns true, the solver
|
|
|
|
/// should be rerun.
|
2006-12-20 06:21:33 +00:00
|
|
|
bool ResolvedUndefsIn(Function &F);
|
2004-12-10 20:41:50 +00:00
|
|
|
|
2008-08-23 23:39:31 +00:00
|
|
|
bool isBlockExecutable(BasicBlock *BB) const {
|
|
|
|
return BBExecutable.count(BB);
|
2002-04-29 21:26:08 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2009-11-02 02:54:24 +00:00
|
|
|
LatticeVal getLatticeValueFor(Value *V) const {
|
2009-11-02 05:55:40 +00:00
|
|
|
DenseMap<Value*, LatticeVal>::const_iterator I = ValueState.find(V);
|
2009-11-02 02:54:24 +00:00
|
|
|
assert(I != ValueState.end() && "V is not in valuemap!");
|
|
|
|
return I->second;
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
2009-11-03 23:40:48 +00:00
|
|
|
|
|
|
|
LatticeVal getStructLatticeValueFor(Value *V, unsigned i) const {
|
|
|
|
DenseMap<std::pair<Value*, unsigned>, LatticeVal>::const_iterator I =
|
|
|
|
StructValueState.find(std::make_pair(V, i));
|
|
|
|
assert(I != StructValueState.end() && "V is not in valuemap!");
|
|
|
|
return I->second;
|
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2008-03-11 05:46:42 +00:00
|
|
|
/// getTrackedRetVals - Get the inferred return value map.
|
2004-12-11 02:53:57 +00:00
|
|
|
///
|
2008-03-11 05:46:42 +00:00
|
|
|
const DenseMap<Function*, LatticeVal> &getTrackedRetVals() {
|
|
|
|
return TrackedRetVals;
|
2004-12-11 02:53:57 +00:00
|
|
|
}
|
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
/// getTrackedGlobals - Get and return the set of inferred initializers for
|
|
|
|
/// global variables.
|
2007-02-02 20:38:30 +00:00
|
|
|
const DenseMap<GlobalVariable*, LatticeVal> &getTrackedGlobals() {
|
2004-12-11 05:15:59 +00:00
|
|
|
return TrackedGlobals;
|
|
|
|
}
|
|
|
|
|
2009-11-02 03:21:36 +00:00
|
|
|
void markOverdefined(Value *V) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(!V->getType()->isStructTy() && "Should use other method");
|
2007-03-04 04:50:21 +00:00
|
|
|
markOverdefined(ValueState[V], V);
|
|
|
|
}
|
2004-12-11 02:53:57 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
/// markAnythingOverdefined - Mark the specified value overdefined. This
|
|
|
|
/// works with both scalars and structs.
|
|
|
|
void markAnythingOverdefined(Value *V) {
|
|
|
|
if (const StructType *STy = dyn_cast<StructType>(V->getType()))
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
|
|
|
|
markOverdefined(getStructValueState(V, i), V);
|
|
|
|
else
|
|
|
|
markOverdefined(V);
|
|
|
|
}
|
|
|
|
|
2001-06-27 23:38:11 +00:00
|
|
|
private:
|
2004-07-15 23:36:43 +00:00
|
|
|
// markConstant - Make a value be marked as "constant". If the value
|
2005-04-21 23:48:37 +00:00
|
|
|
// is not already a constant, add it to the instruction work list so that
|
2001-06-27 23:38:11 +00:00
|
|
|
// the users of the instruction are updated later.
|
|
|
|
//
|
2009-11-02 03:03:42 +00:00
|
|
|
void markConstant(LatticeVal &IV, Value *V, Constant *C) {
|
|
|
|
if (!IV.markConstant(C)) return;
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "markConstant: " << *C << ": " << *V << '\n');
|
2009-11-02 03:03:42 +00:00
|
|
|
InstWorkList.push_back(V);
|
2003-10-08 16:21:03 +00:00
|
|
|
}
|
2006-12-20 06:21:33 +00:00
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
void markConstant(Value *V, Constant *C) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(!V->getType()->isStructTy() && "Should use other method");
|
2004-12-10 08:02:06 +00:00
|
|
|
markConstant(ValueState[V], V, C);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
void markForcedConstant(Value *V, Constant *C) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(!V->getType()->isStructTy() && "Should use other method");
|
2009-11-02 05:55:40 +00:00
|
|
|
ValueState[V].markForcedConstant(C);
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "markForcedConstant: " << *C << ": " << *V << '\n');
|
2009-11-02 05:55:40 +00:00
|
|
|
InstWorkList.push_back(V);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-07-15 23:36:43 +00:00
|
|
|
// markOverdefined - Make a value be marked as "overdefined". If the
|
2005-04-21 23:48:37 +00:00
|
|
|
// value is not already overdefined, add it to the overdefined instruction
|
2004-07-15 23:36:43 +00:00
|
|
|
// work list so that the users of the instruction are updated later.
|
2009-11-02 03:03:42 +00:00
|
|
|
void markOverdefined(LatticeVal &IV, Value *V) {
|
|
|
|
if (!IV.markOverdefined()) return;
|
|
|
|
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "markOverdefined: ";
|
2009-11-02 03:03:42 +00:00
|
|
|
if (Function *F = dyn_cast<Function>(V))
|
2010-01-05 01:27:15 +00:00
|
|
|
dbgs() << "Function '" << F->getName() << "'\n";
|
2009-11-02 03:03:42 +00:00
|
|
|
else
|
2010-01-05 01:27:15 +00:00
|
|
|
dbgs() << *V << '\n');
|
2009-11-02 03:03:42 +00:00
|
|
|
// Only instructions go on the work list
|
|
|
|
OverdefinedInstWorkList.push_back(V);
|
2003-10-08 16:21:03 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
void mergeInValue(LatticeVal &IV, Value *V, LatticeVal MergeWithV) {
|
2004-12-10 08:02:06 +00:00
|
|
|
if (IV.isOverdefined() || MergeWithV.isUndefined())
|
|
|
|
return; // Noop.
|
|
|
|
if (MergeWithV.isOverdefined())
|
|
|
|
markOverdefined(IV, V);
|
|
|
|
else if (IV.isUndefined())
|
|
|
|
markConstant(IV, V, MergeWithV.getConstant());
|
|
|
|
else if (IV.getConstant() != MergeWithV.getConstant())
|
|
|
|
markOverdefined(IV, V);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
2006-02-08 02:38:11 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
void mergeInValue(Value *V, LatticeVal MergeWithV) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(!V->getType()->isStructTy() && "Should use other method");
|
2009-11-02 03:21:36 +00:00
|
|
|
mergeInValue(ValueState[V], V, MergeWithV);
|
2006-02-08 02:38:11 +00:00
|
|
|
}
|
|
|
|
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
/// getValueState - Return the LatticeVal object that corresponds to the
|
|
|
|
/// value. This function handles the case when the value hasn't been seen yet
|
|
|
|
/// by properly seeding constants etc.
|
2009-11-02 03:03:42 +00:00
|
|
|
LatticeVal &getValueState(Value *V) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(!V->getType()->isStructTy() && "Should use getStructValueState");
|
2004-10-16 18:09:41 +00:00
|
|
|
|
2009-11-05 14:33:27 +00:00
|
|
|
std::pair<DenseMap<Value*, LatticeVal>::iterator, bool> I =
|
|
|
|
ValueState.insert(std::make_pair(V, LatticeVal()));
|
|
|
|
LatticeVal &LV = I.first->second;
|
|
|
|
|
|
|
|
if (!I.second)
|
|
|
|
return LV; // Common case, already in the map.
|
2009-11-02 03:21:36 +00:00
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
2009-11-02 03:21:36 +00:00
|
|
|
// Undef values remain undefined.
|
|
|
|
if (!isa<UndefValue>(V))
|
2007-02-02 20:38:30 +00:00
|
|
|
LV.markConstant(C); // Constants are constant
|
2002-08-30 23:39:00 +00:00
|
|
|
}
|
2009-11-02 03:21:36 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// All others are underdefined by default.
|
2009-11-02 03:21:36 +00:00
|
|
|
return LV;
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
/// getStructValueState - Return the LatticeVal object that corresponds to the
|
|
|
|
/// value/field pair. This function handles the case when the value hasn't
|
|
|
|
/// been seen yet by properly seeding constants etc.
|
|
|
|
LatticeVal &getStructValueState(Value *V, unsigned i) {
|
2010-02-16 11:11:14 +00:00
|
|
|
assert(V->getType()->isStructTy() && "Should use getValueState");
|
2009-11-03 23:40:48 +00:00
|
|
|
assert(i < cast<StructType>(V->getType())->getNumElements() &&
|
|
|
|
"Invalid element #");
|
2009-11-05 14:33:27 +00:00
|
|
|
|
|
|
|
std::pair<DenseMap<std::pair<Value*, unsigned>, LatticeVal>::iterator,
|
|
|
|
bool> I = StructValueState.insert(
|
|
|
|
std::make_pair(std::make_pair(V, i), LatticeVal()));
|
|
|
|
LatticeVal &LV = I.first->second;
|
|
|
|
|
|
|
|
if (!I.second)
|
|
|
|
return LV; // Common case, already in the map.
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
|
|
|
if (isa<UndefValue>(C))
|
|
|
|
; // Undef values remain undefined.
|
|
|
|
else if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C))
|
|
|
|
LV.markConstant(CS->getOperand(i)); // Constants are constant.
|
|
|
|
else if (isa<ConstantAggregateZero>(C)) {
|
|
|
|
const Type *FieldTy = cast<StructType>(V->getType())->getElementType(i);
|
|
|
|
LV.markConstant(Constant::getNullValue(FieldTy));
|
|
|
|
} else
|
|
|
|
LV.markOverdefined(); // Unknown sort of constant.
|
|
|
|
}
|
|
|
|
|
|
|
|
// All others are underdefined by default.
|
|
|
|
return LV;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
/// markEdgeExecutable - Mark a basic block as executable, adding it to the BB
|
|
|
|
/// work list if it is not already executable.
|
2003-10-08 16:55:34 +00:00
|
|
|
void markEdgeExecutable(BasicBlock *Source, BasicBlock *Dest) {
|
|
|
|
if (!KnownFeasibleEdges.insert(Edge(Source, Dest)).second)
|
|
|
|
return; // This edge is already known to be executable!
|
|
|
|
|
2009-11-02 06:11:23 +00:00
|
|
|
if (!MarkBlockExecutable(Dest)) {
|
|
|
|
// If the destination is already executable, we just made an *edge*
|
2003-10-08 16:56:11 +00:00
|
|
|
// feasible that wasn't before. Revisit the PHI nodes in the block
|
|
|
|
// because they have potentially new operands.
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "Marking Edge Executable: " << Source->getName()
|
2009-11-02 06:11:23 +00:00
|
|
|
<< " -> " << Dest->getName() << "\n");
|
2003-04-25 02:50:03 +00:00
|
|
|
|
2009-11-02 06:11:23 +00:00
|
|
|
PHINode *PN;
|
|
|
|
for (BasicBlock::iterator I = Dest->begin();
|
|
|
|
(PN = dyn_cast<PHINode>(I)); ++I)
|
|
|
|
visitPHINode(*PN);
|
2003-04-25 02:50:03 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
// getFeasibleSuccessors - Return a vector of booleans to indicate which
|
|
|
|
// successors are reachable from a given terminator instruction.
|
|
|
|
//
|
2007-02-02 21:15:06 +00:00
|
|
|
void getFeasibleSuccessors(TerminatorInst &TI, SmallVector<bool, 16> &Succs);
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
// isEdgeFeasible - Return true if the control flow edge from the 'From' basic
|
2009-11-02 02:33:50 +00:00
|
|
|
// block to the 'To' basic block is currently feasible.
|
2004-11-15 04:44:20 +00:00
|
|
|
//
|
|
|
|
bool isEdgeFeasible(BasicBlock *From, BasicBlock *To);
|
|
|
|
|
|
|
|
// OperandChangedState - This method is invoked on all of the users of an
|
2009-11-02 02:33:50 +00:00
|
|
|
// instruction that was just changed state somehow. Based on this
|
2004-11-15 04:44:20 +00:00
|
|
|
// information, we need to update the specified user of this instruction.
|
|
|
|
//
|
2009-11-03 03:42:51 +00:00
|
|
|
void OperandChangedState(Instruction *I) {
|
|
|
|
if (BBExecutable.count(I->getParent())) // Inst is executable?
|
|
|
|
visit(*I);
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
2009-11-02 06:28:16 +00:00
|
|
|
|
|
|
|
/// RemoveFromOverdefinedPHIs - If I has any entries in the
|
|
|
|
/// UsersOfOverdefinedPHIs map for PN, remove them now.
|
|
|
|
void RemoveFromOverdefinedPHIs(Instruction *I, PHINode *PN) {
|
|
|
|
if (UsersOfOverdefinedPHIs.empty()) return;
|
|
|
|
std::multimap<PHINode*, Instruction*>::iterator It, E;
|
|
|
|
tie(It, E) = UsersOfOverdefinedPHIs.equal_range(PN);
|
|
|
|
while (It != E) {
|
|
|
|
if (It->second == I)
|
|
|
|
UsersOfOverdefinedPHIs.erase(It++);
|
|
|
|
else
|
|
|
|
++It;
|
|
|
|
}
|
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
friend class InstVisitor<SCCPSolver>;
|
2001-06-29 23:56:23 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// visit implementations - Something changed in this instruction. Either an
|
2001-06-29 23:56:23 +00:00
|
|
|
// operand made a transition, or the instruction is newly executable. Change
|
|
|
|
// the value type of I to reflect these changes if appropriate.
|
2002-06-25 16:13:24 +00:00
|
|
|
void visitPHINode(PHINode &I);
|
2002-04-18 15:13:15 +00:00
|
|
|
|
|
|
|
// Terminators
|
2004-12-10 08:02:06 +00:00
|
|
|
void visitReturnInst(ReturnInst &I);
|
2002-06-25 16:13:24 +00:00
|
|
|
void visitTerminatorInst(TerminatorInst &TI);
|
2002-04-18 15:13:15 +00:00
|
|
|
|
2002-08-14 17:53:45 +00:00
|
|
|
void visitCastInst(CastInst &I);
|
2004-03-12 05:52:44 +00:00
|
|
|
void visitSelectInst(SelectInst &I);
|
2002-06-25 16:13:24 +00:00
|
|
|
void visitBinaryOperator(Instruction &I);
|
2006-12-23 06:05:41 +00:00
|
|
|
void visitCmpInst(CmpInst &I);
|
2006-01-10 19:05:05 +00:00
|
|
|
void visitExtractElementInst(ExtractElementInst &I);
|
2006-01-17 20:06:55 +00:00
|
|
|
void visitInsertElementInst(InsertElementInst &I);
|
2006-04-08 01:19:12 +00:00
|
|
|
void visitShuffleVectorInst(ShuffleVectorInst &I);
|
2008-06-20 01:15:44 +00:00
|
|
|
void visitExtractValueInst(ExtractValueInst &EVI);
|
|
|
|
void visitInsertValueInst(InsertValueInst &IVI);
|
2002-04-18 15:13:15 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Instructions that cannot be folded away.
|
2009-11-02 05:55:40 +00:00
|
|
|
void visitStoreInst (StoreInst &I);
|
2004-01-12 04:29:41 +00:00
|
|
|
void visitLoadInst (LoadInst &I);
|
2002-08-30 23:39:00 +00:00
|
|
|
void visitGetElementPtrInst(GetElementPtrInst &I);
|
2009-10-24 04:23:03 +00:00
|
|
|
void visitCallInst (CallInst &I) {
|
2009-09-27 21:35:11 +00:00
|
|
|
visitCallSite(CallSite::get(&I));
|
2009-09-18 22:35:49 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
void visitInvokeInst (InvokeInst &II) {
|
|
|
|
visitCallSite(CallSite::get(&II));
|
|
|
|
visitTerminatorInst(II);
|
2003-08-27 01:08:35 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
void visitCallSite (CallSite CS);
|
2003-09-08 18:54:55 +00:00
|
|
|
void visitUnwindInst (TerminatorInst &I) { /*returns void*/ }
|
2004-10-16 18:09:41 +00:00
|
|
|
void visitUnreachableInst(TerminatorInst &I) { /*returns void*/ }
|
2009-10-23 21:09:37 +00:00
|
|
|
void visitAllocaInst (Instruction &I) { markOverdefined(&I); }
|
2003-10-18 05:56:52 +00:00
|
|
|
void visitVANextInst (Instruction &I) { markOverdefined(&I); }
|
2009-11-03 23:40:48 +00:00
|
|
|
void visitVAArgInst (Instruction &I) { markAnythingOverdefined(&I); }
|
2002-06-25 16:13:24 +00:00
|
|
|
|
|
|
|
void visitInstruction(Instruction &I) {
|
2009-11-02 02:33:50 +00:00
|
|
|
// If a new instruction is added to LLVM that we don't handle.
|
2010-01-05 01:27:15 +00:00
|
|
|
dbgs() << "SCCP: Don't know how to handle: " << I;
|
2009-11-03 23:40:48 +00:00
|
|
|
markAnythingOverdefined(&I); // Just in case
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2001-06-29 23:56:23 +00:00
|
|
|
};
|
2002-07-23 18:06:35 +00:00
|
|
|
|
2007-07-20 08:56:21 +00:00
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
2002-05-02 21:44:00 +00:00
|
|
|
// getFeasibleSuccessors - Return a vector of booleans to indicate which
|
|
|
|
// successors are reachable from a given terminator instruction.
|
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::getFeasibleSuccessors(TerminatorInst &TI,
|
2007-02-02 21:15:06 +00:00
|
|
|
SmallVector<bool, 16> &Succs) {
|
2003-04-25 02:50:03 +00:00
|
|
|
Succs.resize(TI.getNumSuccessors());
|
2002-06-25 16:13:24 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(&TI)) {
|
2002-05-02 21:44:00 +00:00
|
|
|
if (BI->isUnconditional()) {
|
|
|
|
Succs[0] = true;
|
2009-11-02 02:30:06 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal BCValue = getValueState(BI->getCondition());
|
2009-11-02 03:21:36 +00:00
|
|
|
ConstantInt *CI = BCValue.getConstantInt();
|
|
|
|
if (CI == 0) {
|
2009-11-02 02:30:06 +00:00
|
|
|
// Overdefined condition variables, and branches on unfoldable constant
|
|
|
|
// conditions, mean the branch could go either way.
|
2009-11-02 03:21:36 +00:00
|
|
|
if (!BCValue.isUndefined())
|
|
|
|
Succs[0] = Succs[1] = true;
|
2009-11-02 02:30:06 +00:00
|
|
|
return;
|
2002-05-02 21:44:00 +00:00
|
|
|
}
|
2009-11-02 02:30:06 +00:00
|
|
|
|
|
|
|
// Constant condition variables mean the branch can only go a single way.
|
2009-11-02 03:21:36 +00:00
|
|
|
Succs[CI->isZero()] = true;
|
2009-10-29 01:21:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-02 03:21:36 +00:00
|
|
|
if (isa<InvokeInst>(TI)) {
|
2002-05-02 21:44:00 +00:00
|
|
|
// Invoke instructions successors are always executable.
|
|
|
|
Succs[0] = Succs[1] = true;
|
2009-10-29 01:21:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SwitchInst *SI = dyn_cast<SwitchInst>(&TI)) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal SCValue = getValueState(SI->getCondition());
|
2009-11-02 03:21:36 +00:00
|
|
|
ConstantInt *CI = SCValue.getConstantInt();
|
|
|
|
|
|
|
|
if (CI == 0) { // Overdefined or undefined condition?
|
2002-05-02 21:44:00 +00:00
|
|
|
// All destinations are executable!
|
2009-11-02 03:21:36 +00:00
|
|
|
if (!SCValue.isUndefined())
|
|
|
|
Succs.assign(TI.getNumSuccessors(), true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Succs[SI->findCaseValue(CI)] = true;
|
2009-10-29 01:21:20 +00:00
|
|
|
return;
|
2002-05-02 21:44:00 +00:00
|
|
|
}
|
2009-10-29 01:21:20 +00:00
|
|
|
|
|
|
|
// TODO: This could be improved if the operand is a [cast of a] BlockAddress.
|
|
|
|
if (isa<IndirectBrInst>(&TI)) {
|
|
|
|
// Just mark all destinations executable!
|
|
|
|
Succs.assign(TI.getNumSuccessors(), true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
2010-01-05 01:27:15 +00:00
|
|
|
dbgs() << "Unknown terminator instruction: " << TI << '\n';
|
2009-10-29 01:21:20 +00:00
|
|
|
#endif
|
|
|
|
llvm_unreachable("SCCP: Don't know how to handle this terminator!");
|
2002-05-02 21:44:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-05-02 21:18:01 +00:00
|
|
|
// isEdgeFeasible - Return true if the control flow edge from the 'From' basic
|
2009-11-02 02:33:50 +00:00
|
|
|
// block to the 'To' basic block is currently feasible.
|
2002-05-02 21:18:01 +00:00
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
|
2002-05-02 21:18:01 +00:00
|
|
|
assert(BBExecutable.count(To) && "Dest should always be alive!");
|
|
|
|
|
|
|
|
// Make sure the source basic block is executable!!
|
|
|
|
if (!BBExecutable.count(From)) return false;
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Check to make sure this edge itself is actually feasible now.
|
2003-10-08 15:47:41 +00:00
|
|
|
TerminatorInst *TI = From->getTerminator();
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
|
|
|
if (BI->isUnconditional())
|
2002-05-02 21:44:00 +00:00
|
|
|
return true;
|
2009-10-29 01:21:20 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal BCValue = getValueState(BI->getCondition());
|
2004-01-12 17:40:36 +00:00
|
|
|
|
2009-11-02 02:30:06 +00:00
|
|
|
// Overdefined condition variables mean the branch could go either way,
|
|
|
|
// undef conditions mean that neither edge is feasible yet.
|
2009-11-02 03:21:36 +00:00
|
|
|
ConstantInt *CI = BCValue.getConstantInt();
|
|
|
|
if (CI == 0)
|
|
|
|
return !BCValue.isUndefined();
|
2009-11-02 02:30:06 +00:00
|
|
|
|
|
|
|
// Constant condition variables mean the branch can only go a single way.
|
2009-11-02 03:21:36 +00:00
|
|
|
return BI->getSuccessor(CI->isZero()) == To;
|
2009-10-29 01:21:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Invoke instructions successors are always executable.
|
|
|
|
if (isa<InvokeInst>(TI))
|
2003-10-08 15:47:41 +00:00
|
|
|
return true;
|
2009-10-29 01:21:20 +00:00
|
|
|
|
|
|
|
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal SCValue = getValueState(SI->getCondition());
|
2009-11-02 03:21:36 +00:00
|
|
|
ConstantInt *CI = SCValue.getConstantInt();
|
|
|
|
|
|
|
|
if (CI == 0)
|
|
|
|
return !SCValue.isUndefined();
|
|
|
|
|
|
|
|
// Make sure to skip the "default value" which isn't a value
|
|
|
|
for (unsigned i = 1, E = SI->getNumSuccessors(); i != E; ++i)
|
|
|
|
if (SI->getSuccessorValue(i) == CI) // Found the taken branch.
|
|
|
|
return SI->getSuccessor(i) == To;
|
|
|
|
|
|
|
|
// If the constant value is not equal to any of the branches, we must
|
|
|
|
// execute default branch.
|
|
|
|
return SI->getDefaultDest() == To;
|
2009-10-29 01:21:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Just mark all destinations executable!
|
|
|
|
// TODO: This could be improved if the operand is a [cast of a] BlockAddress.
|
|
|
|
if (isa<IndirectBrInst>(&TI))
|
|
|
|
return true;
|
|
|
|
|
2009-07-11 13:10:19 +00:00
|
|
|
#ifndef NDEBUG
|
2010-01-05 01:27:15 +00:00
|
|
|
dbgs() << "Unknown terminator instruction: " << *TI << '\n';
|
2009-07-11 13:10:19 +00:00
|
|
|
#endif
|
2009-10-29 01:21:20 +00:00
|
|
|
llvm_unreachable(0);
|
2002-05-02 21:18:01 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// visit Implementations - Something changed in this instruction, either an
|
2001-06-27 23:38:11 +00:00
|
|
|
// operand made a transition, or the instruction is newly executable. Change
|
|
|
|
// the value type of I to reflect these changes if appropriate. This method
|
|
|
|
// makes sure to do the following actions:
|
|
|
|
//
|
|
|
|
// 1. If a phi node merges two constants in, and has conflicting value coming
|
|
|
|
// from different branches, or if the PHI node merges in an overdefined
|
|
|
|
// value, then the PHI node becomes overdefined.
|
|
|
|
// 2. If a phi node merges only constants in, and they all agree on value, the
|
|
|
|
// PHI node becomes a constant value equal to that.
|
|
|
|
// 3. If V <- x (op) y && isConstant(x) && isConstant(y) V = Constant
|
|
|
|
// 4. If V <- x (op) y && (isOverdefined(x) || isOverdefined(y)) V = Overdefined
|
|
|
|
// 5. If V <- MEM or V <- CALL or V <- (unknown) then V = Overdefined
|
|
|
|
// 6. If a conditional branch has a value that is constant, make the selected
|
|
|
|
// destination executable
|
|
|
|
// 7. If a conditional branch has a value that is overdefined, make all
|
|
|
|
// successors executable.
|
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitPHINode(PHINode &PN) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// If this PN returns a struct, just mark the result overdefined.
|
|
|
|
// TODO: We could do a lot better than this if code actually uses this.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (PN.getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
return markAnythingOverdefined(&PN);
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
if (getValueState(&PN).isOverdefined()) {
|
2004-01-12 03:57:30 +00:00
|
|
|
// There may be instructions using this PHI node that are not overdefined
|
|
|
|
// themselves. If so, make sure that they know that the PHI node operand
|
|
|
|
// changed.
|
|
|
|
std::multimap<PHINode*, Instruction*>::iterator I, E;
|
|
|
|
tie(I, E) = UsersOfOverdefinedPHIs.equal_range(&PN);
|
2009-11-02 05:55:40 +00:00
|
|
|
if (I == E)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallVector<Instruction*, 16> Users;
|
|
|
|
for (; I != E; ++I)
|
|
|
|
Users.push_back(I->second);
|
|
|
|
while (!Users.empty())
|
|
|
|
visit(Users.pop_back_val());
|
2004-01-12 03:57:30 +00:00
|
|
|
return; // Quick exit
|
|
|
|
}
|
2002-04-18 15:13:15 +00:00
|
|
|
|
2004-03-16 19:49:59 +00:00
|
|
|
// Super-extra-high-degree PHI nodes are unlikely to ever be marked constant,
|
|
|
|
// and slow us down a lot. Just mark them overdefined.
|
2009-11-02 03:03:42 +00:00
|
|
|
if (PN.getNumIncomingValues() > 64)
|
2009-11-02 05:55:40 +00:00
|
|
|
return markOverdefined(&PN);
|
2009-11-03 23:40:48 +00:00
|
|
|
|
2002-04-18 15:13:15 +00:00
|
|
|
// Look at all of the executable operands of the PHI node. If any of them
|
|
|
|
// are overdefined, the PHI becomes overdefined as well. If they are all
|
|
|
|
// constant, and they agree with each other, the PHI becomes the identical
|
|
|
|
// constant. If they are constant and don't agree, the PHI is overdefined.
|
|
|
|
// If there are no executable operands, the PHI remains undefined.
|
|
|
|
//
|
2003-04-25 02:50:03 +00:00
|
|
|
Constant *OperandVal = 0;
|
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal IV = getValueState(PN.getIncomingValue(i));
|
2003-04-25 02:50:03 +00:00
|
|
|
if (IV.isUndefined()) continue; // Doesn't influence PHI node.
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent()))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (IV.isOverdefined()) // PHI node becomes overdefined!
|
|
|
|
return markOverdefined(&PN);
|
2003-06-24 20:29:52 +00:00
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
if (OperandVal == 0) { // Grab the first value.
|
|
|
|
OperandVal = IV.getConstant();
|
|
|
|
continue;
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
2009-11-02 03:03:42 +00:00
|
|
|
|
|
|
|
// There is already a reachable operand. If we conflict with it,
|
|
|
|
// then the PHI node becomes overdefined. If we agree with it, we
|
|
|
|
// can continue on.
|
|
|
|
|
|
|
|
// Check to see if there are two different constants merging, if so, the PHI
|
|
|
|
// node is overdefined.
|
|
|
|
if (IV.getConstant() != OperandVal)
|
|
|
|
return markOverdefined(&PN);
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2002-04-18 15:13:15 +00:00
|
|
|
// If we exited the loop, this means that the PHI node only has constant
|
2003-04-25 02:50:03 +00:00
|
|
|
// arguments that agree with each other(and OperandVal is the constant) or
|
|
|
|
// OperandVal is null because there are no defined incoming arguments. If
|
|
|
|
// this is the case, the PHI remains undefined.
|
2002-04-18 15:13:15 +00:00
|
|
|
//
|
2003-04-25 02:50:03 +00:00
|
|
|
if (OperandVal)
|
2008-08-23 23:36:38 +00:00
|
|
|
markConstant(&PN, OperandVal); // Acquire operand value
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2009-11-03 03:42:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
void SCCPSolver::visitReturnInst(ReturnInst &I) {
|
2009-11-02 05:55:40 +00:00
|
|
|
if (I.getNumOperands() == 0) return; // ret void
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
Function *F = I.getParent()->getParent();
|
2009-11-03 23:40:48 +00:00
|
|
|
Value *ResultOp = I.getOperand(0);
|
2009-11-03 03:42:51 +00:00
|
|
|
|
2008-03-11 05:46:42 +00:00
|
|
|
// If we are tracking the return value of this function, merge it in.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!TrackedRetVals.empty() && !ResultOp->getType()->isStructTy()) {
|
2007-02-02 20:38:30 +00:00
|
|
|
DenseMap<Function*, LatticeVal>::iterator TFRVI =
|
2008-03-11 05:46:42 +00:00
|
|
|
TrackedRetVals.find(F);
|
2009-11-03 03:42:51 +00:00
|
|
|
if (TFRVI != TrackedRetVals.end()) {
|
2009-11-03 23:40:48 +00:00
|
|
|
mergeInValue(TFRVI->second, F, getValueState(ResultOp));
|
2008-03-11 05:46:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// Handle functions that return multiple values.
|
2009-11-03 23:40:48 +00:00
|
|
|
if (!TrackedMultipleRetVals.empty()) {
|
|
|
|
if (const StructType *STy = dyn_cast<StructType>(ResultOp->getType()))
|
|
|
|
if (MRVFunctionsTracked.count(F))
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
|
|
|
|
mergeInValue(TrackedMultipleRetVals[std::make_pair(F, i)], F,
|
|
|
|
getStructValueState(ResultOp, i));
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitTerminatorInst(TerminatorInst &TI) {
|
2007-02-02 21:15:06 +00:00
|
|
|
SmallVector<bool, 16> SuccFeasible;
|
2002-05-02 21:44:00 +00:00
|
|
|
getFeasibleSuccessors(TI, SuccFeasible);
|
2002-05-02 21:18:01 +00:00
|
|
|
|
2003-10-08 16:55:34 +00:00
|
|
|
BasicBlock *BB = TI.getParent();
|
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Mark all feasible successors executable.
|
2002-05-02 21:44:00 +00:00
|
|
|
for (unsigned i = 0, e = SuccFeasible.size(); i != e; ++i)
|
2003-10-08 16:55:34 +00:00
|
|
|
if (SuccFeasible[i])
|
|
|
|
markEdgeExecutable(BB, TI.getSuccessor(i));
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitCastInst(CastInst &I) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal OpSt = getValueState(I.getOperand(0));
|
|
|
|
if (OpSt.isOverdefined()) // Inherit overdefinedness of operand
|
2002-06-25 16:13:24 +00:00
|
|
|
markOverdefined(&I);
|
2009-11-02 05:55:40 +00:00
|
|
|
else if (OpSt.isConstant()) // Propagate constant value
|
2009-07-29 18:55:55 +00:00
|
|
|
markConstant(&I, ConstantExpr::getCast(I.getOpcode(),
|
2009-11-02 05:55:40 +00:00
|
|
|
OpSt.getConstant(), I.getType()));
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2008-06-20 01:15:44 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
void SCCPSolver::visitExtractValueInst(ExtractValueInst &EVI) {
|
|
|
|
// If this returns a struct, mark all elements over defined, we don't track
|
|
|
|
// structs in structs.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (EVI.getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
return markAnythingOverdefined(&EVI);
|
|
|
|
|
|
|
|
// If this is extracting from more than one level of struct, we don't know.
|
2009-11-02 03:03:42 +00:00
|
|
|
if (EVI.getNumIndices() != 1)
|
|
|
|
return markOverdefined(&EVI);
|
2009-11-03 23:40:48 +00:00
|
|
|
|
|
|
|
Value *AggVal = EVI.getAggregateOperand();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (AggVal->getType()->isStructTy()) {
|
2009-11-10 22:02:09 +00:00
|
|
|
unsigned i = *EVI.idx_begin();
|
|
|
|
LatticeVal EltVal = getStructValueState(AggVal, i);
|
|
|
|
mergeInValue(getValueState(&EVI), &EVI, EltVal);
|
|
|
|
} else {
|
|
|
|
// Otherwise, must be extracting from an array.
|
|
|
|
return markOverdefined(&EVI);
|
|
|
|
}
|
2008-06-20 01:15:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SCCPSolver::visitInsertValueInst(InsertValueInst &IVI) {
|
2009-11-03 23:40:48 +00:00
|
|
|
const StructType *STy = dyn_cast<StructType>(IVI.getType());
|
|
|
|
if (STy == 0)
|
2009-11-02 03:03:42 +00:00
|
|
|
return markOverdefined(&IVI);
|
2008-06-20 01:15:44 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// If this has more than one index, we can't handle it, drive all results to
|
|
|
|
// undef.
|
|
|
|
if (IVI.getNumIndices() != 1)
|
|
|
|
return markAnythingOverdefined(&IVI);
|
|
|
|
|
|
|
|
Value *Aggr = IVI.getAggregateOperand();
|
|
|
|
unsigned Idx = *IVI.idx_begin();
|
|
|
|
|
|
|
|
// Compute the result based on what we're inserting.
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
|
|
|
|
// This passes through all values that aren't the inserted element.
|
|
|
|
if (i != Idx) {
|
|
|
|
LatticeVal EltVal = getStructValueState(Aggr, i);
|
|
|
|
mergeInValue(getStructValueState(&IVI, i), &IVI, EltVal);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *Val = IVI.getInsertedValueOperand();
|
2010-02-16 11:11:14 +00:00
|
|
|
if (Val->getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
// We don't track structs in structs.
|
|
|
|
markOverdefined(getStructValueState(&IVI, i), &IVI);
|
|
|
|
else {
|
|
|
|
LatticeVal InVal = getValueState(Val);
|
|
|
|
mergeInValue(getStructValueState(&IVI, i), &IVI, InVal);
|
|
|
|
}
|
|
|
|
}
|
2008-06-20 01:15:44 +00:00
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitSelectInst(SelectInst &I) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// If this select returns a struct, just mark the result overdefined.
|
|
|
|
// TODO: We could do a lot better than this if code actually uses this.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (I.getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
return markAnythingOverdefined(&I);
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal CondValue = getValueState(I.getCondition());
|
2006-02-08 02:38:11 +00:00
|
|
|
if (CondValue.isUndefined())
|
|
|
|
return;
|
2009-11-02 03:21:36 +00:00
|
|
|
|
|
|
|
if (ConstantInt *CondCB = CondValue.getConstantInt()) {
|
2009-11-02 05:55:40 +00:00
|
|
|
Value *OpVal = CondCB->isZero() ? I.getFalseValue() : I.getTrueValue();
|
|
|
|
mergeInValue(&I, getValueState(OpVal));
|
2009-11-02 03:21:36 +00:00
|
|
|
return;
|
2006-02-08 02:38:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, the condition is overdefined or a constant we can't evaluate.
|
|
|
|
// See if we can produce something better than overdefined based on the T/F
|
|
|
|
// value.
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal TVal = getValueState(I.getTrueValue());
|
|
|
|
LatticeVal FVal = getValueState(I.getFalseValue());
|
2006-02-08 02:38:11 +00:00
|
|
|
|
|
|
|
// select ?, C, C -> C.
|
|
|
|
if (TVal.isConstant() && FVal.isConstant() &&
|
2009-11-02 03:03:42 +00:00
|
|
|
TVal.getConstant() == FVal.getConstant())
|
|
|
|
return markConstant(&I, FVal.getConstant());
|
2006-02-08 02:38:11 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
if (TVal.isUndefined()) // select ?, undef, X -> X.
|
|
|
|
return mergeInValue(&I, FVal);
|
|
|
|
if (FVal.isUndefined()) // select ?, X, undef -> X.
|
|
|
|
return mergeInValue(&I, TVal);
|
|
|
|
markOverdefined(&I);
|
2004-03-12 05:52:44 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// Handle Binary Operators.
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitBinaryOperator(Instruction &I) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal V1State = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal V2State = getValueState(I.getOperand(1));
|
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
2004-01-12 03:57:30 +00:00
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
if (V1State.isConstant() && V2State.isConstant())
|
|
|
|
return markConstant(IV, &I,
|
|
|
|
ConstantExpr::get(I.getOpcode(), V1State.getConstant(),
|
|
|
|
V2State.getConstant()));
|
|
|
|
|
|
|
|
// If something is undef, wait for it to resolve.
|
|
|
|
if (!V1State.isOverdefined() && !V2State.isOverdefined())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Otherwise, one of our operands is overdefined. Try to produce something
|
|
|
|
// better than overdefined with some tricks.
|
|
|
|
|
|
|
|
// If this is an AND or OR with 0 or -1, it doesn't matter that the other
|
|
|
|
// operand is overdefined.
|
|
|
|
if (I.getOpcode() == Instruction::And || I.getOpcode() == Instruction::Or) {
|
|
|
|
LatticeVal *NonOverdefVal = 0;
|
|
|
|
if (!V1State.isOverdefined())
|
|
|
|
NonOverdefVal = &V1State;
|
|
|
|
else if (!V2State.isOverdefined())
|
|
|
|
NonOverdefVal = &V2State;
|
|
|
|
|
|
|
|
if (NonOverdefVal) {
|
|
|
|
if (NonOverdefVal->isUndefined()) {
|
|
|
|
// Could annihilate value.
|
|
|
|
if (I.getOpcode() == Instruction::And)
|
|
|
|
markConstant(IV, &I, Constant::getNullValue(I.getType()));
|
|
|
|
else if (const VectorType *PT = dyn_cast<VectorType>(I.getType()))
|
|
|
|
markConstant(IV, &I, Constant::getAllOnesValue(PT));
|
|
|
|
else
|
|
|
|
markConstant(IV, &I,
|
|
|
|
Constant::getAllOnesValue(I.getType()));
|
|
|
|
return;
|
2004-12-11 23:15:19 +00:00
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
|
|
|
|
if (I.getOpcode() == Instruction::And) {
|
|
|
|
// X and 0 = 0
|
|
|
|
if (NonOverdefVal->getConstant()->isNullValue())
|
|
|
|
return markConstant(IV, &I, NonOverdefVal->getConstant());
|
|
|
|
} else {
|
|
|
|
if (ConstantInt *CI = NonOverdefVal->getConstantInt())
|
|
|
|
if (CI->isAllOnesValue()) // X or -1 = -1
|
|
|
|
return markConstant(IV, &I, NonOverdefVal->getConstant());
|
2004-12-11 23:15:19 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
}
|
2004-12-11 23:15:19 +00:00
|
|
|
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// If both operands are PHI nodes, it is possible that this instruction has
|
|
|
|
// a constant value, despite the fact that the PHI node doesn't. Check for
|
|
|
|
// this condition now.
|
|
|
|
if (PHINode *PN1 = dyn_cast<PHINode>(I.getOperand(0)))
|
|
|
|
if (PHINode *PN2 = dyn_cast<PHINode>(I.getOperand(1)))
|
|
|
|
if (PN1->getParent() == PN2->getParent()) {
|
|
|
|
// Since the two PHI nodes are in the same basic block, they must have
|
|
|
|
// entries for the same predecessors. Walk the predecessor list, and
|
|
|
|
// if all of the incoming values are constants, and the result of
|
|
|
|
// evaluating this expression with all incoming value pairs is the
|
|
|
|
// same, then this expression is a constant even though the PHI node
|
|
|
|
// is not a constant!
|
|
|
|
LatticeVal Result;
|
|
|
|
for (unsigned i = 0, e = PN1->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
LatticeVal In1 = getValueState(PN1->getIncomingValue(i));
|
|
|
|
BasicBlock *InBlock = PN1->getIncomingBlock(i);
|
|
|
|
LatticeVal In2 =getValueState(PN2->getIncomingValueForBlock(InBlock));
|
|
|
|
|
|
|
|
if (In1.isOverdefined() || In2.isOverdefined()) {
|
|
|
|
Result.markOverdefined();
|
|
|
|
break; // Cannot fold this operation over the PHI nodes!
|
|
|
|
}
|
|
|
|
|
|
|
|
if (In1.isConstant() && In2.isConstant()) {
|
|
|
|
Constant *V = ConstantExpr::get(I.getOpcode(), In1.getConstant(),
|
|
|
|
In2.getConstant());
|
|
|
|
if (Result.isUndefined())
|
|
|
|
Result.markConstant(V);
|
|
|
|
else if (Result.isConstant() && Result.getConstant() != V) {
|
2004-01-12 03:57:30 +00:00
|
|
|
Result.markOverdefined();
|
2009-11-02 05:55:40 +00:00
|
|
|
break;
|
2004-01-12 03:57:30 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
}
|
2004-01-12 03:57:30 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// If we found a constant value here, then we know the instruction is
|
|
|
|
// constant despite the fact that the PHI nodes are overdefined.
|
|
|
|
if (Result.isConstant()) {
|
|
|
|
markConstant(IV, &I, Result.getConstant());
|
|
|
|
// Remember that this instruction is virtually using the PHI node
|
|
|
|
// operands.
|
|
|
|
UsersOfOverdefinedPHIs.insert(std::make_pair(PN1, &I));
|
|
|
|
UsersOfOverdefinedPHIs.insert(std::make_pair(PN2, &I));
|
|
|
|
return;
|
2004-01-12 03:57:30 +00:00
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
|
|
|
|
if (Result.isUndefined())
|
|
|
|
return;
|
2004-01-12 03:57:30 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// Okay, this really is overdefined now. Since we might have
|
|
|
|
// speculatively thought that this was not overdefined before, and
|
|
|
|
// added ourselves to the UsersOfOverdefinedPHIs list for the PHIs,
|
|
|
|
// make sure to clean out any entries that we put there, for
|
|
|
|
// efficiency.
|
2009-11-02 06:28:16 +00:00
|
|
|
RemoveFromOverdefinedPHIs(&I, PN1);
|
|
|
|
RemoveFromOverdefinedPHIs(&I, PN2);
|
2009-11-02 05:55:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
markOverdefined(&I);
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2002-08-30 23:39:00 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Handle ICmpInst instruction.
|
2006-12-23 06:05:41 +00:00
|
|
|
void SCCPSolver::visitCmpInst(CmpInst &I) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal V1State = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal V2State = getValueState(I.getOperand(1));
|
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
if (V1State.isConstant() && V2State.isConstant())
|
|
|
|
return markConstant(IV, &I, ConstantExpr::getCompare(I.getPredicate(),
|
|
|
|
V1State.getConstant(),
|
|
|
|
V2State.getConstant()));
|
|
|
|
|
|
|
|
// If operands are still undefined, wait for it to resolve.
|
|
|
|
if (!V1State.isOverdefined() && !V2State.isOverdefined())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// If something is overdefined, use some tricks to avoid ending up and over
|
|
|
|
// defined if we can.
|
|
|
|
|
|
|
|
// If both operands are PHI nodes, it is possible that this instruction has
|
|
|
|
// a constant value, despite the fact that the PHI node doesn't. Check for
|
|
|
|
// this condition now.
|
|
|
|
if (PHINode *PN1 = dyn_cast<PHINode>(I.getOperand(0)))
|
|
|
|
if (PHINode *PN2 = dyn_cast<PHINode>(I.getOperand(1)))
|
|
|
|
if (PN1->getParent() == PN2->getParent()) {
|
|
|
|
// Since the two PHI nodes are in the same basic block, they must have
|
|
|
|
// entries for the same predecessors. Walk the predecessor list, and
|
|
|
|
// if all of the incoming values are constants, and the result of
|
|
|
|
// evaluating this expression with all incoming value pairs is the
|
|
|
|
// same, then this expression is a constant even though the PHI node
|
|
|
|
// is not a constant!
|
|
|
|
LatticeVal Result;
|
|
|
|
for (unsigned i = 0, e = PN1->getNumIncomingValues(); i != e; ++i) {
|
|
|
|
LatticeVal In1 = getValueState(PN1->getIncomingValue(i));
|
|
|
|
BasicBlock *InBlock = PN1->getIncomingBlock(i);
|
|
|
|
LatticeVal In2 =getValueState(PN2->getIncomingValueForBlock(InBlock));
|
|
|
|
|
|
|
|
if (In1.isOverdefined() || In2.isOverdefined()) {
|
|
|
|
Result.markOverdefined();
|
|
|
|
break; // Cannot fold this operation over the PHI nodes!
|
|
|
|
}
|
|
|
|
|
|
|
|
if (In1.isConstant() && In2.isConstant()) {
|
|
|
|
Constant *V = ConstantExpr::getCompare(I.getPredicate(),
|
|
|
|
In1.getConstant(),
|
|
|
|
In2.getConstant());
|
|
|
|
if (Result.isUndefined())
|
|
|
|
Result.markConstant(V);
|
|
|
|
else if (Result.isConstant() && Result.getConstant() != V) {
|
2006-12-23 06:05:41 +00:00
|
|
|
Result.markOverdefined();
|
2009-11-02 05:55:40 +00:00
|
|
|
break;
|
2006-12-23 06:05:41 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
}
|
2006-12-23 06:05:41 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// If we found a constant value here, then we know the instruction is
|
|
|
|
// constant despite the fact that the PHI nodes are overdefined.
|
|
|
|
if (Result.isConstant()) {
|
|
|
|
markConstant(&I, Result.getConstant());
|
|
|
|
// Remember that this instruction is virtually using the PHI node
|
|
|
|
// operands.
|
|
|
|
UsersOfOverdefinedPHIs.insert(std::make_pair(PN1, &I));
|
|
|
|
UsersOfOverdefinedPHIs.insert(std::make_pair(PN2, &I));
|
|
|
|
return;
|
2006-12-23 06:05:41 +00:00
|
|
|
}
|
2009-11-02 05:55:40 +00:00
|
|
|
|
|
|
|
if (Result.isUndefined())
|
|
|
|
return;
|
2006-12-23 06:05:41 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// Okay, this really is overdefined now. Since we might have
|
|
|
|
// speculatively thought that this was not overdefined before, and
|
|
|
|
// added ourselves to the UsersOfOverdefinedPHIs list for the PHIs,
|
|
|
|
// make sure to clean out any entries that we put there, for
|
|
|
|
// efficiency.
|
2009-11-02 06:28:16 +00:00
|
|
|
RemoveFromOverdefinedPHIs(&I, PN1);
|
|
|
|
RemoveFromOverdefinedPHIs(&I, PN2);
|
2009-11-02 05:55:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
markOverdefined(&I);
|
2006-12-23 06:05:41 +00:00
|
|
|
}
|
|
|
|
|
2006-01-10 19:05:05 +00:00
|
|
|
void SCCPSolver::visitExtractElementInst(ExtractElementInst &I) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO : SCCP does not handle vectors properly.
|
2009-11-02 03:03:42 +00:00
|
|
|
return markOverdefined(&I);
|
2006-12-04 23:54:59 +00:00
|
|
|
|
|
|
|
#if 0
|
2006-01-10 19:05:05 +00:00
|
|
|
LatticeVal &ValState = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal &IdxState = getValueState(I.getOperand(1));
|
|
|
|
|
|
|
|
if (ValState.isOverdefined() || IdxState.isOverdefined())
|
|
|
|
markOverdefined(&I);
|
|
|
|
else if(ValState.isConstant() && IdxState.isConstant())
|
|
|
|
markConstant(&I, ConstantExpr::getExtractElement(ValState.getConstant(),
|
|
|
|
IdxState.getConstant()));
|
2006-12-04 23:54:59 +00:00
|
|
|
#endif
|
2006-01-10 19:05:05 +00:00
|
|
|
}
|
|
|
|
|
2006-01-17 20:06:55 +00:00
|
|
|
void SCCPSolver::visitInsertElementInst(InsertElementInst &I) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO : SCCP does not handle vectors properly.
|
2009-11-02 03:03:42 +00:00
|
|
|
return markOverdefined(&I);
|
2006-12-04 23:54:59 +00:00
|
|
|
#if 0
|
2006-01-17 20:06:55 +00:00
|
|
|
LatticeVal &ValState = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal &EltState = getValueState(I.getOperand(1));
|
|
|
|
LatticeVal &IdxState = getValueState(I.getOperand(2));
|
|
|
|
|
|
|
|
if (ValState.isOverdefined() || EltState.isOverdefined() ||
|
|
|
|
IdxState.isOverdefined())
|
|
|
|
markOverdefined(&I);
|
|
|
|
else if(ValState.isConstant() && EltState.isConstant() &&
|
|
|
|
IdxState.isConstant())
|
|
|
|
markConstant(&I, ConstantExpr::getInsertElement(ValState.getConstant(),
|
|
|
|
EltState.getConstant(),
|
|
|
|
IdxState.getConstant()));
|
|
|
|
else if (ValState.isUndefined() && EltState.isConstant() &&
|
2006-12-04 23:54:59 +00:00
|
|
|
IdxState.isConstant())
|
2007-04-14 23:32:02 +00:00
|
|
|
markConstant(&I,ConstantExpr::getInsertElement(UndefValue::get(I.getType()),
|
|
|
|
EltState.getConstant(),
|
|
|
|
IdxState.getConstant()));
|
2006-12-04 23:54:59 +00:00
|
|
|
#endif
|
2006-01-17 20:06:55 +00:00
|
|
|
}
|
|
|
|
|
2006-04-08 01:19:12 +00:00
|
|
|
void SCCPSolver::visitShuffleVectorInst(ShuffleVectorInst &I) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO : SCCP does not handle vectors properly.
|
2009-11-02 03:03:42 +00:00
|
|
|
return markOverdefined(&I);
|
2006-12-04 23:54:59 +00:00
|
|
|
#if 0
|
2006-04-08 01:19:12 +00:00
|
|
|
LatticeVal &V1State = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal &V2State = getValueState(I.getOperand(1));
|
|
|
|
LatticeVal &MaskState = getValueState(I.getOperand(2));
|
|
|
|
|
|
|
|
if (MaskState.isUndefined() ||
|
|
|
|
(V1State.isUndefined() && V2State.isUndefined()))
|
|
|
|
return; // Undefined output if mask or both inputs undefined.
|
|
|
|
|
|
|
|
if (V1State.isOverdefined() || V2State.isOverdefined() ||
|
|
|
|
MaskState.isOverdefined()) {
|
|
|
|
markOverdefined(&I);
|
|
|
|
} else {
|
|
|
|
// A mix of constant/undef inputs.
|
|
|
|
Constant *V1 = V1State.isConstant() ?
|
|
|
|
V1State.getConstant() : UndefValue::get(I.getType());
|
|
|
|
Constant *V2 = V2State.isConstant() ?
|
|
|
|
V2State.getConstant() : UndefValue::get(I.getType());
|
|
|
|
Constant *Mask = MaskState.isConstant() ?
|
|
|
|
MaskState.getConstant() : UndefValue::get(I.getOperand(2)->getType());
|
|
|
|
markConstant(&I, ConstantExpr::getShuffleVector(V1, V2, Mask));
|
|
|
|
}
|
2006-12-04 23:54:59 +00:00
|
|
|
#endif
|
2006-04-08 01:19:12 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Handle getelementptr instructions. If all operands are constants then we
|
2002-08-30 23:39:00 +00:00
|
|
|
// can turn this into a getelementptr ConstantExpr.
|
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitGetElementPtrInst(GetElementPtrInst &I) {
|
2009-11-02 23:25:39 +00:00
|
|
|
if (ValueState[&I].isOverdefined()) return;
|
2004-01-12 04:29:41 +00:00
|
|
|
|
2007-02-02 20:51:48 +00:00
|
|
|
SmallVector<Constant*, 8> Operands;
|
2002-08-30 23:39:00 +00:00
|
|
|
Operands.reserve(I.getNumOperands());
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal State = getValueState(I.getOperand(i));
|
2002-08-30 23:39:00 +00:00
|
|
|
if (State.isUndefined())
|
2009-11-02 02:33:50 +00:00
|
|
|
return; // Operands are not resolved yet.
|
|
|
|
|
2009-11-02 03:03:42 +00:00
|
|
|
if (State.isOverdefined())
|
2009-11-02 23:25:39 +00:00
|
|
|
return markOverdefined(&I);
|
2009-11-02 03:03:42 +00:00
|
|
|
|
2002-08-30 23:39:00 +00:00
|
|
|
assert(State.isConstant() && "Unknown state!");
|
|
|
|
Operands.push_back(State.getConstant());
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *Ptr = Operands[0];
|
2009-11-02 05:55:40 +00:00
|
|
|
markConstant(&I, ConstantExpr::getGetElementPtr(Ptr, &Operands[0]+1,
|
|
|
|
Operands.size()-1));
|
2004-01-12 04:29:41 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
void SCCPSolver::visitStoreInst(StoreInst &SI) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// If this store is of a struct, ignore it.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (SI.getOperand(0)->getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
return;
|
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
if (TrackedGlobals.empty() || !isa<GlobalVariable>(SI.getOperand(1)))
|
|
|
|
return;
|
2009-11-02 05:55:40 +00:00
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
GlobalVariable *GV = cast<GlobalVariable>(SI.getOperand(1));
|
2007-02-02 20:38:30 +00:00
|
|
|
DenseMap<GlobalVariable*, LatticeVal>::iterator I = TrackedGlobals.find(GV);
|
2004-12-11 05:15:59 +00:00
|
|
|
if (I == TrackedGlobals.end() || I->second.isOverdefined()) return;
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// Get the value we are storing into the global, then merge it.
|
|
|
|
mergeInValue(I->second, GV, getValueState(SI.getOperand(0)));
|
2004-12-11 05:15:59 +00:00
|
|
|
if (I->second.isOverdefined())
|
|
|
|
TrackedGlobals.erase(I); // No need to keep tracking this!
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-01-12 04:29:41 +00:00
|
|
|
// Handle load instructions. If the operand is a constant pointer to a constant
|
|
|
|
// global, we can replace the load with the loaded constant value!
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitLoadInst(LoadInst &I) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// If this load is of a struct, just mark the result overdefined.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (I.getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
return markAnythingOverdefined(&I);
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal PtrVal = getValueState(I.getOperand(0));
|
2009-11-02 06:06:14 +00:00
|
|
|
if (PtrVal.isUndefined()) return; // The pointer is not resolved yet!
|
2009-11-02 05:55:40 +00:00
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
2004-01-12 04:29:41 +00:00
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
if (!PtrVal.isConstant() || I.isVolatile())
|
|
|
|
return markOverdefined(IV, &I);
|
|
|
|
|
2009-11-02 06:06:14 +00:00
|
|
|
Constant *Ptr = PtrVal.getConstant();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// load null -> null
|
|
|
|
if (isa<ConstantPointerNull>(Ptr) && I.getPointerAddressSpace() == 0)
|
|
|
|
return markConstant(IV, &I, Constant::getNullValue(I.getType()));
|
|
|
|
|
|
|
|
// Transform load (constant global) into the value loaded.
|
|
|
|
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
|
2009-11-02 06:06:14 +00:00
|
|
|
if (!TrackedGlobals.empty()) {
|
2009-11-02 05:55:40 +00:00
|
|
|
// If we are tracking this global, merge in the known value for it.
|
|
|
|
DenseMap<GlobalVariable*, LatticeVal>::iterator It =
|
|
|
|
TrackedGlobals.find(GV);
|
|
|
|
if (It != TrackedGlobals.end()) {
|
|
|
|
mergeInValue(IV, &I, It->second);
|
|
|
|
return;
|
2004-01-12 04:29:41 +00:00
|
|
|
}
|
2004-12-11 05:15:59 +00:00
|
|
|
}
|
2004-01-12 04:29:41 +00:00
|
|
|
}
|
|
|
|
|
2009-11-02 06:06:14 +00:00
|
|
|
// Transform load from a constant into a constant if possible.
|
|
|
|
if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, TD))
|
|
|
|
return markConstant(IV, &I, C);
|
2009-11-02 05:55:40 +00:00
|
|
|
|
2004-01-12 04:29:41 +00:00
|
|
|
// Otherwise we cannot say for certain what value this load will produce.
|
|
|
|
// Bail out.
|
|
|
|
markOverdefined(IV, &I);
|
|
|
|
}
|
2004-04-13 19:43:54 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
void SCCPSolver::visitCallSite(CallSite CS) {
|
|
|
|
Function *F = CS.getCalledFunction();
|
2008-04-23 05:38:20 +00:00
|
|
|
Instruction *I = CS.getInstruction();
|
|
|
|
|
|
|
|
// The common case is that we aren't tracking the callee, either because we
|
|
|
|
// are not doing interprocedural analysis or the callee is indirect, or is
|
|
|
|
// external. Handle these cases first.
|
2009-11-03 03:42:51 +00:00
|
|
|
if (F == 0 || F->isDeclaration()) {
|
2008-04-23 05:38:20 +00:00
|
|
|
CallOverdefined:
|
|
|
|
// Void return and not tracking callee, just bail.
|
2009-10-05 05:54:46 +00:00
|
|
|
if (I->getType()->isVoidTy()) return;
|
2008-03-11 05:46:42 +00:00
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// Otherwise, if we have a single return value case, and if the function is
|
|
|
|
// a declaration, maybe we can constant fold it.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (F && F->isDeclaration() && !I->getType()->isStructTy() &&
|
2008-04-23 05:38:20 +00:00
|
|
|
canConstantFoldCallTo(F)) {
|
|
|
|
|
|
|
|
SmallVector<Constant*, 8> Operands;
|
|
|
|
for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end();
|
|
|
|
AI != E; ++AI) {
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal State = getValueState(*AI);
|
2009-11-02 03:03:42 +00:00
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
if (State.isUndefined())
|
|
|
|
return; // Operands are not resolved yet.
|
2009-11-02 03:03:42 +00:00
|
|
|
if (State.isOverdefined())
|
|
|
|
return markOverdefined(I);
|
2008-04-23 05:38:20 +00:00
|
|
|
assert(State.isConstant() && "Unknown state!");
|
|
|
|
Operands.push_back(State.getConstant());
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we can constant fold this, mark the result of the call as a
|
|
|
|
// constant.
|
2009-11-02 03:03:42 +00:00
|
|
|
if (Constant *C = ConstantFoldCall(F, Operands.data(), Operands.size()))
|
|
|
|
return markConstant(I, C);
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2004-04-13 19:43:54 +00:00
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// Otherwise, we don't know anything about this call, mark it overdefined.
|
2009-11-03 23:40:48 +00:00
|
|
|
return markAnythingOverdefined(I);
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-03 19:24:51 +00:00
|
|
|
// If this is a local function that doesn't have its address taken, mark its
|
|
|
|
// entry block executable and merge in the actual arguments to the call into
|
|
|
|
// the formal arguments of the function.
|
|
|
|
if (!TrackingIncomingArguments.empty() && TrackingIncomingArguments.count(F)){
|
|
|
|
MarkBlockExecutable(F->begin());
|
|
|
|
|
|
|
|
// Propagate information from this call site into the callee.
|
|
|
|
CallSite::arg_iterator CAI = CS.arg_begin();
|
|
|
|
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
|
|
|
|
AI != E; ++AI, ++CAI) {
|
|
|
|
// If this argument is byval, and if the function is not readonly, there
|
|
|
|
// will be an implicit copy formed of the input aggregate.
|
|
|
|
if (AI->hasByValAttr() && !F->onlyReadsMemory()) {
|
|
|
|
markOverdefined(AI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
if (const StructType *STy = dyn_cast<StructType>(AI->getType())) {
|
2009-11-04 18:57:42 +00:00
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
|
|
|
|
LatticeVal CallArg = getStructValueState(*CAI, i);
|
|
|
|
mergeInValue(getStructValueState(AI, i), AI, CallArg);
|
|
|
|
}
|
2009-11-03 23:40:48 +00:00
|
|
|
} else {
|
|
|
|
mergeInValue(AI, getValueState(*CAI));
|
|
|
|
}
|
2009-11-03 19:24:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// If this is a single/zero retval case, see if we're tracking the function.
|
2009-11-03 23:40:48 +00:00
|
|
|
if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
|
|
|
|
if (!MRVFunctionsTracked.count(F))
|
|
|
|
goto CallOverdefined; // Not tracking this callee.
|
2009-11-02 03:03:42 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// If we are tracking this callee, propagate the result of the function
|
|
|
|
// into this call site.
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
|
|
|
|
mergeInValue(getStructValueState(I, i), I,
|
|
|
|
TrackedMultipleRetVals[std::make_pair(F, i)]);
|
2008-06-20 01:15:44 +00:00
|
|
|
} else {
|
2009-11-03 23:40:48 +00:00
|
|
|
DenseMap<Function*, LatticeVal>::iterator TFRVI = TrackedRetVals.find(F);
|
|
|
|
if (TFRVI == TrackedRetVals.end())
|
|
|
|
goto CallOverdefined; // Not tracking this callee.
|
|
|
|
|
|
|
|
// If so, propagate the return value of the callee into this call result.
|
|
|
|
mergeInValue(I, TFRVI->second);
|
2004-04-13 19:43:54 +00:00
|
|
|
}
|
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
void SCCPSolver::Solve() {
|
|
|
|
// Process the work lists until they are empty!
|
2005-04-21 23:48:37 +00:00
|
|
|
while (!BBWorkList.empty() || !InstWorkList.empty() ||
|
2005-04-23 21:38:35 +00:00
|
|
|
!OverdefinedInstWorkList.empty()) {
|
2009-11-02 05:55:40 +00:00
|
|
|
// Process the overdefined instruction's work list first, which drives other
|
|
|
|
// things to overdefined more quickly.
|
2004-11-15 04:44:20 +00:00
|
|
|
while (!OverdefinedInstWorkList.empty()) {
|
2009-11-02 05:55:40 +00:00
|
|
|
Value *I = OverdefinedInstWorkList.pop_back_val();
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "\nPopped off OI-WL: " << *I << '\n');
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
// "I" got into the work list because it either made the transition from
|
|
|
|
// bottom to constant
|
|
|
|
//
|
|
|
|
// Anything on this worklist that is overdefined need not be visited
|
|
|
|
// since all of its users will have already been marked as overdefined
|
2009-11-02 02:33:50 +00:00
|
|
|
// Update all of the users of this instruction's value.
|
2004-11-15 04:44:20 +00:00
|
|
|
//
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI)
|
2009-11-03 03:42:51 +00:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(*UI))
|
|
|
|
OperandChangedState(I);
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
2009-11-02 02:33:50 +00:00
|
|
|
|
|
|
|
// Process the instruction work list.
|
2004-11-15 04:44:20 +00:00
|
|
|
while (!InstWorkList.empty()) {
|
2009-11-02 05:55:40 +00:00
|
|
|
Value *I = InstWorkList.pop_back_val();
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "\nPopped off I-WL: " << *I << '\n');
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-02 05:55:40 +00:00
|
|
|
// "I" got into the work list because it made the transition from undef to
|
|
|
|
// constant.
|
2004-11-15 04:44:20 +00:00
|
|
|
//
|
|
|
|
// Anything on this worklist that is overdefined need not be visited
|
|
|
|
// since all of its users will have already been marked as overdefined.
|
2009-11-02 02:33:50 +00:00
|
|
|
// Update all of the users of this instruction's value.
|
2004-11-15 04:44:20 +00:00
|
|
|
//
|
2010-02-16 11:11:14 +00:00
|
|
|
if (I->getType()->isStructTy() || !getValueState(I).isOverdefined())
|
2004-11-15 04:44:20 +00:00
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI)
|
2009-11-03 03:42:51 +00:00
|
|
|
if (Instruction *I = dyn_cast<Instruction>(*UI))
|
|
|
|
OperandChangedState(I);
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// Process the basic block work list.
|
2004-11-15 04:44:20 +00:00
|
|
|
while (!BBWorkList.empty()) {
|
|
|
|
BasicBlock *BB = BBWorkList.back();
|
|
|
|
BBWorkList.pop_back();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "\nPopped off BBWL: " << *BB << '\n');
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
// Notify all instructions in this basic block that they are newly
|
|
|
|
// executable.
|
|
|
|
visit(BB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
/// ResolvedUndefsIn - While solving the dataflow for a function, we assume
|
2004-12-10 20:41:50 +00:00
|
|
|
/// that branches on undef values cannot reach any of their successors.
|
|
|
|
/// However, this is not a safe assumption. After we solve dataflow, this
|
|
|
|
/// method should be use to handle this. If this returns true, the solver
|
|
|
|
/// should be rerun.
|
2006-10-22 05:59:17 +00:00
|
|
|
///
|
|
|
|
/// This method handles this by finding an unresolved branch and marking it one
|
|
|
|
/// of the edges from the block as being feasible, even though the condition
|
|
|
|
/// doesn't say it would otherwise be. This allows SCCP to find the rest of the
|
|
|
|
/// CFG and only slightly pessimizes the analysis results (by marking one,
|
2006-12-20 06:21:33 +00:00
|
|
|
/// potentially infeasible, edge feasible). This cannot usefully modify the
|
2006-10-22 05:59:17 +00:00
|
|
|
/// constraints on the condition of the branch, as that would impact other users
|
|
|
|
/// of the value.
|
2006-12-20 06:21:33 +00:00
|
|
|
///
|
|
|
|
/// This scan also checks for values that use undefs, whose results are actually
|
|
|
|
/// defined. For example, 'zext i8 undef to i32' should produce all zeros
|
|
|
|
/// conservatively, as "(zext i8 X -> i32) & 0xFF00" must always return zero,
|
|
|
|
/// even if X isn't defined.
|
|
|
|
bool SCCPSolver::ResolvedUndefsIn(Function &F) {
|
2006-10-22 05:59:17 +00:00
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
|
|
|
if (!BBExecutable.count(BB))
|
|
|
|
continue;
|
2006-12-20 06:21:33 +00:00
|
|
|
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
|
|
|
// Look for instructions which produce undef values.
|
2009-10-05 05:54:46 +00:00
|
|
|
if (I->getType()->isVoidTy()) continue;
|
2006-12-20 06:21:33 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
if (const StructType *STy = dyn_cast<StructType>(I->getType())) {
|
|
|
|
// Only a few things that can be structs matter for undef. Just send
|
|
|
|
// all their results to overdefined. We could be more precise than this
|
|
|
|
// but it isn't worth bothering.
|
|
|
|
if (isa<CallInst>(I) || isa<SelectInst>(I)) {
|
|
|
|
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
|
|
|
|
LatticeVal &LV = getStructValueState(I, i);
|
|
|
|
if (LV.isUndefined())
|
|
|
|
markOverdefined(LV, I);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
LatticeVal &LV = getValueState(I);
|
|
|
|
if (!LV.isUndefined()) continue;
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// No instructions using structs need disambiguation.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (I->getOperand(0)->getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
continue;
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
// Get the lattice values of the first two operands for use below.
|
2009-11-02 05:55:40 +00:00
|
|
|
LatticeVal Op0LV = getValueState(I->getOperand(0));
|
2006-12-20 06:21:33 +00:00
|
|
|
LatticeVal Op1LV;
|
|
|
|
if (I->getNumOperands() == 2) {
|
2009-11-03 23:40:48 +00:00
|
|
|
// No instructions using structs need disambiguation.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (I->getOperand(1)->getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
continue;
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
// If this is a two-operand instruction, and if both operands are
|
|
|
|
// undefs, the result stays undef.
|
|
|
|
Op1LV = getValueState(I->getOperand(1));
|
|
|
|
if (Op0LV.isUndefined() && Op1LV.isUndefined())
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is an instructions whose result is defined even if the input is
|
|
|
|
// not fully defined, propagate the information.
|
|
|
|
const Type *ITy = I->getType();
|
|
|
|
switch (I->getOpcode()) {
|
|
|
|
default: break; // Leave the instruction as an undef.
|
|
|
|
case Instruction::ZExt:
|
|
|
|
// After a zero extend, we know the top part is zero. SExt doesn't have
|
|
|
|
// to be handled here, because we don't know whether the top part is 1's
|
|
|
|
// or 0's.
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Constant::getNullValue(ITy));
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::And:
|
|
|
|
// undef * X -> 0. X could be zero.
|
|
|
|
// undef & X -> 0. X could be zero.
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Constant::getNullValue(ITy));
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
case Instruction::Or:
|
|
|
|
// undef | X -> -1. X could be -1.
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Constant::getAllOnesValue(ITy));
|
2007-01-04 02:12:40 +00:00
|
|
|
return true;
|
2006-12-20 06:21:33 +00:00
|
|
|
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::URem:
|
|
|
|
// X / undef -> undef. No change.
|
|
|
|
// X % undef -> undef. No change.
|
|
|
|
if (Op1LV.isUndefined()) break;
|
|
|
|
|
|
|
|
// undef / X -> 0. X could be maxint.
|
|
|
|
// undef % X -> 0. X could be 1.
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Constant::getNullValue(ITy));
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
case Instruction::AShr:
|
|
|
|
// undef >>s X -> undef. No change.
|
|
|
|
if (Op0LV.isUndefined()) break;
|
|
|
|
|
|
|
|
// X >>s undef -> X. X could be 0, X could have the high-bit known set.
|
|
|
|
if (Op0LV.isConstant())
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Op0LV.getConstant());
|
2006-12-20 06:21:33 +00:00
|
|
|
else
|
2009-11-02 05:55:40 +00:00
|
|
|
markOverdefined(I);
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::Shl:
|
|
|
|
// undef >> X -> undef. No change.
|
|
|
|
// undef << X -> undef. No change.
|
|
|
|
if (Op0LV.isUndefined()) break;
|
|
|
|
|
|
|
|
// X >> undef -> 0. X could be 0.
|
|
|
|
// X << undef -> 0. X could be 0.
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Constant::getNullValue(ITy));
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
case Instruction::Select:
|
|
|
|
// undef ? X : Y -> X or Y. There could be commonality between X/Y.
|
|
|
|
if (Op0LV.isUndefined()) {
|
|
|
|
if (!Op1LV.isConstant()) // Pick the constant one if there is any.
|
|
|
|
Op1LV = getValueState(I->getOperand(2));
|
|
|
|
} else if (Op1LV.isUndefined()) {
|
|
|
|
// c ? undef : undef -> undef. No change.
|
|
|
|
Op1LV = getValueState(I->getOperand(2));
|
|
|
|
if (Op1LV.isUndefined())
|
|
|
|
break;
|
|
|
|
// Otherwise, c ? undef : x -> x.
|
|
|
|
} else {
|
|
|
|
// Leave Op1LV as Operand(1)'s LatticeValue.
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Op1LV.isConstant())
|
2009-11-02 05:55:40 +00:00
|
|
|
markForcedConstant(I, Op1LV.getConstant());
|
2006-12-20 06:21:33 +00:00
|
|
|
else
|
2009-11-02 05:55:40 +00:00
|
|
|
markOverdefined(I);
|
2008-05-24 03:59:33 +00:00
|
|
|
return true;
|
|
|
|
case Instruction::Call:
|
|
|
|
// If a call has an undef result, it is because it is constant foldable
|
|
|
|
// but one of the inputs was undef. Just force the result to
|
|
|
|
// overdefined.
|
2009-11-02 05:55:40 +00:00
|
|
|
markOverdefined(I);
|
2006-12-20 06:21:33 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2006-10-22 05:59:17 +00:00
|
|
|
|
|
|
|
TerminatorInst *TI = BB->getTerminator();
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
|
|
|
if (!BI->isConditional()) continue;
|
|
|
|
if (!getValueState(BI->getCondition()).isUndefined())
|
|
|
|
continue;
|
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
2009-11-02 02:30:06 +00:00
|
|
|
if (SI->getNumSuccessors() < 2) // no cases
|
2008-05-23 01:01:31 +00:00
|
|
|
continue;
|
2006-10-22 05:59:17 +00:00
|
|
|
if (!getValueState(SI->getCondition()).isUndefined())
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
continue;
|
2004-12-10 20:41:50 +00:00
|
|
|
}
|
2006-10-22 05:59:17 +00:00
|
|
|
|
2008-01-28 00:32:30 +00:00
|
|
|
// If the edge to the second successor isn't thought to be feasible yet,
|
|
|
|
// mark it so now. We pick the second one so that this goes to some
|
|
|
|
// enumerated value in a switch instead of going to the default destination.
|
|
|
|
if (KnownFeasibleEdges.count(Edge(BB, TI->getSuccessor(1))))
|
2006-10-22 05:59:17 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// Otherwise, it isn't already thought to be feasible. Mark it as such now
|
|
|
|
// and return. This will make other blocks reachable, which will allow new
|
|
|
|
// values to be discovered and existing ones to be moved in the lattice.
|
2008-01-28 00:32:30 +00:00
|
|
|
markEdgeExecutable(BB, TI->getSuccessor(1));
|
|
|
|
|
|
|
|
// This must be a conditional branch of switch on undef. At this point,
|
|
|
|
// force the old terminator to branch to the first successor. This is
|
|
|
|
// required because we are now influencing the dataflow of the function with
|
|
|
|
// the assumption that this edge is taken. If we leave the branch condition
|
|
|
|
// as undef, then further analysis could think the undef went another way
|
|
|
|
// leading to an inconsistent set of conclusions.
|
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
2009-11-02 02:30:06 +00:00
|
|
|
BI->setCondition(ConstantInt::getFalse(BI->getContext()));
|
2008-01-28 00:32:30 +00:00
|
|
|
} else {
|
|
|
|
SwitchInst *SI = cast<SwitchInst>(TI);
|
|
|
|
SI->setCondition(SI->getCaseValue(1));
|
|
|
|
}
|
|
|
|
|
2006-10-22 05:59:17 +00:00
|
|
|
return true;
|
|
|
|
}
|
2004-12-11 06:05:53 +00:00
|
|
|
|
2006-10-22 05:59:17 +00:00
|
|
|
return false;
|
2004-12-10 20:41:50 +00:00
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
namespace {
|
2004-11-15 07:15:04 +00:00
|
|
|
//===--------------------------------------------------------------------===//
|
2004-11-15 04:44:20 +00:00
|
|
|
//
|
2004-11-15 07:15:04 +00:00
|
|
|
/// SCCP Class - This class uses the SCCPSolver to implement a per-function
|
2006-12-31 22:26:06 +00:00
|
|
|
/// Sparse Conditional Constant Propagator.
|
2004-11-15 07:15:04 +00:00
|
|
|
///
|
2009-09-02 06:11:42 +00:00
|
|
|
struct SCCP : public FunctionPass {
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2008-09-04 17:05:41 +00:00
|
|
|
SCCP() : FunctionPass(&ID) {}
|
2007-05-01 21:15:47 +00:00
|
|
|
|
2004-11-15 07:15:04 +00:00
|
|
|
// runOnFunction - Run the Sparse Conditional Constant Propagation
|
|
|
|
// algorithm, and return true if the function was modified.
|
|
|
|
//
|
|
|
|
bool runOnFunction(Function &F);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-15 07:15:04 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
}
|
|
|
|
};
|
2004-11-15 04:44:20 +00:00
|
|
|
} // end anonymous namespace
|
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char SCCP::ID = 0;
|
|
|
|
static RegisterPass<SCCP>
|
|
|
|
X("sccp", "Sparse Conditional Constant Propagation");
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// createSCCPPass - This is the public interface to this file.
|
2004-11-15 04:44:20 +00:00
|
|
|
FunctionPass *llvm::createSCCPPass() {
|
|
|
|
return new SCCP();
|
|
|
|
}
|
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
static void DeleteInstructionInBlock(BasicBlock *BB) {
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << " BasicBlock Dead:" << *BB);
|
2009-11-02 02:47:51 +00:00
|
|
|
++NumDeadBlocks;
|
|
|
|
|
|
|
|
// Delete the instructions backwards, as it has a reduced likelihood of
|
|
|
|
// having to update as many def-use and use-def chains.
|
|
|
|
while (!isa<TerminatorInst>(BB->begin())) {
|
|
|
|
Instruction *I = --BasicBlock::iterator(BB->getTerminator());
|
|
|
|
|
|
|
|
if (!I->use_empty())
|
|
|
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
|
|
|
BB->getInstList().erase(I);
|
|
|
|
++NumInstRemoved;
|
|
|
|
}
|
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
// runOnFunction() - Run the Sparse Conditional Constant Propagation algorithm,
|
|
|
|
// and return true if the function was modified.
|
|
|
|
//
|
|
|
|
bool SCCP::runOnFunction(Function &F) {
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "SCCP on function '" << F.getName() << "'\n");
|
2009-11-02 06:06:14 +00:00
|
|
|
SCCPSolver Solver(getAnalysisIfAvailable<TargetData>());
|
2004-11-15 04:44:20 +00:00
|
|
|
|
|
|
|
// Mark the first block of the function as being executable.
|
|
|
|
Solver.MarkBlockExecutable(F.begin());
|
|
|
|
|
2004-11-15 05:45:33 +00:00
|
|
|
// Mark all arguments to the function as being overdefined.
|
2007-04-14 23:32:02 +00:00
|
|
|
for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); AI != E;++AI)
|
2009-11-03 23:40:48 +00:00
|
|
|
Solver.markAnythingOverdefined(AI);
|
2004-11-15 05:45:33 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
// Solve for constants.
|
2006-12-20 06:21:33 +00:00
|
|
|
bool ResolvedUndefs = true;
|
|
|
|
while (ResolvedUndefs) {
|
2004-12-10 20:41:50 +00:00
|
|
|
Solver.Solve();
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "RESOLVING UNDEFs\n");
|
2006-12-20 06:21:33 +00:00
|
|
|
ResolvedUndefs = Solver.ResolvedUndefsIn(F);
|
2004-12-10 20:41:50 +00:00
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2004-11-15 05:45:33 +00:00
|
|
|
bool MadeChanges = false;
|
|
|
|
|
|
|
|
// If we decided that there are basic blocks that are dead in this function,
|
|
|
|
// delete their contents now. Note that we cannot actually delete the blocks,
|
|
|
|
// as we cannot modify the CFG of the function.
|
2007-03-04 04:50:21 +00:00
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
2008-08-23 23:39:31 +00:00
|
|
|
if (!Solver.isBlockExecutable(BB)) {
|
2009-11-02 02:47:51 +00:00
|
|
|
DeleteInstructionInBlock(BB);
|
|
|
|
MadeChanges = true;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iterate over all of the instructions in a function, replacing them with
|
|
|
|
// constants if we have found them to be of constant values.
|
|
|
|
//
|
|
|
|
for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) {
|
|
|
|
Instruction *Inst = BI++;
|
|
|
|
if (Inst->getType()->isVoidTy() || isa<TerminatorInst>(Inst))
|
|
|
|
continue;
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO: Reconstruct structs from their elements.
|
2010-02-16 11:11:14 +00:00
|
|
|
if (Inst->getType()->isStructTy())
|
2009-11-03 23:40:48 +00:00
|
|
|
continue;
|
|
|
|
|
2009-11-02 02:54:24 +00:00
|
|
|
LatticeVal IV = Solver.getLatticeValueFor(Inst);
|
|
|
|
if (IV.isOverdefined())
|
2009-11-02 02:47:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
Constant *Const = IV.isConstant()
|
|
|
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << " Constant: " << *Const << " = " << *Inst);
|
2008-04-24 00:16:28 +00:00
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
// Replaces all of the uses of a variable with uses of the constant.
|
|
|
|
Inst->replaceAllUsesWith(Const);
|
|
|
|
|
|
|
|
// Delete the instruction.
|
|
|
|
Inst->eraseFromParent();
|
|
|
|
|
|
|
|
// Hey, we just changed something!
|
|
|
|
MadeChanges = true;
|
|
|
|
++NumInstRemoved;
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2009-11-02 02:47:51 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
return MadeChanges;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
/// IPSCCP Class - This class implements interprocedural Sparse Conditional
|
|
|
|
/// Constant Propagation.
|
|
|
|
///
|
2009-09-02 06:11:42 +00:00
|
|
|
struct IPSCCP : public ModulePass {
|
2007-05-03 01:11:54 +00:00
|
|
|
static char ID;
|
2008-09-04 17:05:41 +00:00
|
|
|
IPSCCP() : ModulePass(&ID) {}
|
2004-12-10 08:02:06 +00:00
|
|
|
bool runOnModule(Module &M);
|
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char IPSCCP::ID = 0;
|
|
|
|
static RegisterPass<IPSCCP>
|
|
|
|
Y("ipsccp", "Interprocedural Sparse Conditional Constant Propagation");
|
|
|
|
|
2009-11-02 02:33:50 +00:00
|
|
|
// createIPSCCPPass - This is the public interface to this file.
|
2004-12-10 08:02:06 +00:00
|
|
|
ModulePass *llvm::createIPSCCPPass() {
|
|
|
|
return new IPSCCP();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-24 10:29:52 +00:00
|
|
|
static bool AddressIsTaken(const GlobalValue *GV) {
|
2005-04-19 19:16:19 +00:00
|
|
|
// Delete any dead constantexpr klingons.
|
|
|
|
GV->removeDeadConstantUsers();
|
|
|
|
|
2010-03-25 23:06:16 +00:00
|
|
|
for (Value::const_use_iterator UI = GV->use_begin(), E = GV->use_end();
|
2010-03-24 10:29:52 +00:00
|
|
|
UI != E; ++UI) {
|
|
|
|
const User *U = *UI;
|
|
|
|
if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
|
2004-12-11 05:15:59 +00:00
|
|
|
if (SI->getOperand(0) == GV || SI->isVolatile())
|
|
|
|
return true; // Storing addr of GV.
|
2010-03-24 10:29:52 +00:00
|
|
|
} else if (isa<InvokeInst>(U) || isa<CallInst>(U)) {
|
2004-12-10 08:02:06 +00:00
|
|
|
// Make sure we are calling the function, not passing the address.
|
2010-04-01 08:21:08 +00:00
|
|
|
ImmutableCallSite CS(cast<Instruction>(U));
|
2010-03-24 13:21:49 +00:00
|
|
|
if (!CS.isCallee(UI))
|
2008-11-03 03:49:14 +00:00
|
|
|
return true;
|
2010-03-24 10:29:52 +00:00
|
|
|
} else if (const LoadInst *LI = dyn_cast<LoadInst>(U)) {
|
2004-12-11 05:15:59 +00:00
|
|
|
if (LI->isVolatile())
|
|
|
|
return true;
|
2010-03-24 10:29:52 +00:00
|
|
|
} else if (isa<BlockAddress>(U)) {
|
2009-11-01 06:11:53 +00:00
|
|
|
// blockaddress doesn't take the address of the function, it takes addr
|
|
|
|
// of label.
|
2004-12-11 05:15:59 +00:00
|
|
|
} else {
|
2004-12-10 08:02:06 +00:00
|
|
|
return true;
|
|
|
|
}
|
2010-03-24 10:29:52 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IPSCCP::runOnModule(Module &M) {
|
2009-11-02 06:06:14 +00:00
|
|
|
SCCPSolver Solver(getAnalysisIfAvailable<TargetData>());
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
// Loop over all functions, marking arguments to those with their addresses
|
|
|
|
// taken or that are external as overdefined.
|
|
|
|
//
|
2009-11-02 06:34:04 +00:00
|
|
|
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
|
|
|
|
if (F->isDeclaration())
|
|
|
|
continue;
|
|
|
|
|
2009-11-03 03:42:51 +00:00
|
|
|
// If this is a strong or ODR definition of this function, then we can
|
|
|
|
// propagate information about its result into callsites of it.
|
2009-11-03 23:40:48 +00:00
|
|
|
if (!F->mayBeOverridden())
|
2004-12-10 08:02:06 +00:00
|
|
|
Solver.AddTrackedFunction(F);
|
2009-11-03 03:42:51 +00:00
|
|
|
|
|
|
|
// If this function only has direct calls that we can see, we can track its
|
|
|
|
// arguments and return value aggressively, and can assume it is not called
|
|
|
|
// unless we see evidence to the contrary.
|
2009-11-03 19:24:51 +00:00
|
|
|
if (F->hasLocalLinkage() && !AddressIsTaken(F)) {
|
|
|
|
Solver.AddArgumentTrackedFunction(F);
|
2009-11-03 03:42:51 +00:00
|
|
|
continue;
|
2009-11-03 19:24:51 +00:00
|
|
|
}
|
2009-11-03 03:42:51 +00:00
|
|
|
|
|
|
|
// Assume the function is called.
|
|
|
|
Solver.MarkBlockExecutable(F->begin());
|
|
|
|
|
|
|
|
// Assume nothing about the incoming arguments.
|
|
|
|
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
|
|
|
|
AI != E; ++AI)
|
2009-11-03 23:40:48 +00:00
|
|
|
Solver.markAnythingOverdefined(AI);
|
2009-11-02 06:34:04 +00:00
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
// Loop over global variables. We inform the solver about any internal global
|
|
|
|
// variables that do not have their 'addresses taken'. If they don't have
|
|
|
|
// their addresses taken, we can propagate constants through them.
|
2005-04-19 19:16:19 +00:00
|
|
|
for (Module::global_iterator G = M.global_begin(), E = M.global_end();
|
|
|
|
G != E; ++G)
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!G->isConstant() && G->hasLocalLinkage() && !AddressIsTaken(G))
|
2004-12-11 05:15:59 +00:00
|
|
|
Solver.TrackValueOfGlobalVariable(G);
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
// Solve for constants.
|
2006-12-20 06:21:33 +00:00
|
|
|
bool ResolvedUndefs = true;
|
|
|
|
while (ResolvedUndefs) {
|
2004-12-10 20:41:50 +00:00
|
|
|
Solver.Solve();
|
|
|
|
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "RESOLVING UNDEFS\n");
|
2006-12-20 06:21:33 +00:00
|
|
|
ResolvedUndefs = false;
|
2004-12-10 20:41:50 +00:00
|
|
|
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
|
2006-12-20 06:21:33 +00:00
|
|
|
ResolvedUndefs |= Solver.ResolvedUndefsIn(*F);
|
2004-12-10 20:41:50 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
bool MadeChanges = false;
|
|
|
|
|
|
|
|
// Iterate over all of the instructions in the module, replacing them with
|
2004-11-15 04:44:20 +00:00
|
|
|
// constants if we have found them to be of constant values.
|
|
|
|
//
|
2008-08-23 23:36:38 +00:00
|
|
|
SmallVector<BasicBlock*, 512> BlocksToErase;
|
2007-02-02 21:15:06 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
|
2009-11-02 03:25:55 +00:00
|
|
|
if (Solver.isBlockExecutable(F->begin())) {
|
|
|
|
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
|
|
|
|
AI != E; ++AI) {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (AI->use_empty() || AI->getType()->isStructTy()) continue;
|
2009-11-02 03:25:55 +00:00
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO: Could use getStructLatticeValueFor to find out if the entire
|
|
|
|
// result is a constant and replace it entirely if so.
|
|
|
|
|
2009-11-02 03:25:55 +00:00
|
|
|
LatticeVal IV = Solver.getLatticeValueFor(AI);
|
|
|
|
if (IV.isOverdefined()) continue;
|
|
|
|
|
|
|
|
Constant *CST = IV.isConstant() ?
|
|
|
|
IV.getConstant() : UndefValue::get(AI->getType());
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "*** Arg " << *AI << " = " << *CST <<"\n");
|
2009-11-02 03:25:55 +00:00
|
|
|
|
|
|
|
// Replaces all of the uses of a variable with uses of the
|
|
|
|
// constant.
|
|
|
|
AI->replaceAllUsesWith(CST);
|
|
|
|
++IPNumArgsElimed;
|
|
|
|
}
|
2009-11-02 02:54:24 +00:00
|
|
|
}
|
2004-11-15 04:44:20 +00:00
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
|
2008-08-23 23:39:31 +00:00
|
|
|
if (!Solver.isBlockExecutable(BB)) {
|
2009-11-02 02:47:51 +00:00
|
|
|
DeleteInstructionInBlock(BB);
|
|
|
|
MadeChanges = true;
|
2004-12-10 20:41:50 +00:00
|
|
|
|
2004-12-10 22:29:08 +00:00
|
|
|
TerminatorInst *TI = BB->getTerminator();
|
|
|
|
for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i) {
|
|
|
|
BasicBlock *Succ = TI->getSuccessor(i);
|
2007-10-03 19:26:29 +00:00
|
|
|
if (!Succ->empty() && isa<PHINode>(Succ->begin()))
|
2004-12-10 22:29:08 +00:00
|
|
|
TI->getSuccessor(i)->removePredecessor(BB);
|
|
|
|
}
|
2004-12-11 02:53:57 +00:00
|
|
|
if (!TI->use_empty())
|
2009-07-30 23:03:37 +00:00
|
|
|
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
|
2009-11-02 02:47:51 +00:00
|
|
|
TI->eraseFromParent();
|
2004-12-10 22:29:08 +00:00
|
|
|
|
2004-12-11 05:32:19 +00:00
|
|
|
if (&*BB != &F->front())
|
|
|
|
BlocksToErase.push_back(BB);
|
|
|
|
else
|
2009-08-13 21:58:54 +00:00
|
|
|
new UnreachableInst(M.getContext(), BB);
|
2009-11-02 02:47:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) {
|
|
|
|
Instruction *Inst = BI++;
|
2010-02-16 11:11:14 +00:00
|
|
|
if (Inst->getType()->isVoidTy() || Inst->getType()->isStructTy())
|
2009-11-02 02:47:51 +00:00
|
|
|
continue;
|
|
|
|
|
2009-11-03 23:40:48 +00:00
|
|
|
// TODO: Could use getStructLatticeValueFor to find out if the entire
|
|
|
|
// result is a constant and replace it entirely if so.
|
|
|
|
|
2009-11-02 02:54:24 +00:00
|
|
|
LatticeVal IV = Solver.getLatticeValueFor(Inst);
|
|
|
|
if (IV.isOverdefined())
|
2009-11-02 02:47:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
Constant *Const = IV.isConstant()
|
|
|
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << " Constant: " << *Const << " = " << *Inst);
|
2004-12-11 05:32:19 +00:00
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
// Replaces all of the uses of a variable with uses of the
|
|
|
|
// constant.
|
|
|
|
Inst->replaceAllUsesWith(Const);
|
|
|
|
|
|
|
|
// Delete the instruction.
|
|
|
|
if (!isa<CallInst>(Inst) && !isa<TerminatorInst>(Inst))
|
|
|
|
Inst->eraseFromParent();
|
2008-04-24 00:21:50 +00:00
|
|
|
|
2009-11-02 02:47:51 +00:00
|
|
|
// Hey, we just changed something!
|
|
|
|
MadeChanges = true;
|
|
|
|
++IPNumInstRemoved;
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2009-11-02 02:47:51 +00:00
|
|
|
}
|
2004-12-10 22:29:08 +00:00
|
|
|
|
|
|
|
// Now that all instructions in the function are constant folded, erase dead
|
|
|
|
// blocks, because we can now use ConstantFoldTerminator to get rid of
|
|
|
|
// in-edges.
|
|
|
|
for (unsigned i = 0, e = BlocksToErase.size(); i != e; ++i) {
|
|
|
|
// If there are any PHI nodes in this successor, drop entries for BB now.
|
|
|
|
BasicBlock *DeadBB = BlocksToErase[i];
|
2009-11-20 20:19:14 +00:00
|
|
|
for (Value::use_iterator UI = DeadBB->use_begin(), UE = DeadBB->use_end();
|
|
|
|
UI != UE; ) {
|
2009-11-23 16:13:39 +00:00
|
|
|
// Grab the user and then increment the iterator early, as the user
|
|
|
|
// will be deleted. Step past all adjacent uses from the same user.
|
|
|
|
Instruction *I = dyn_cast<Instruction>(*UI);
|
|
|
|
do { ++UI; } while (UI != UE && *UI == I);
|
|
|
|
|
2009-11-20 20:19:14 +00:00
|
|
|
// Ignore blockaddress users; BasicBlock's dtor will handle them.
|
|
|
|
if (!I) continue;
|
|
|
|
|
2004-12-10 22:29:08 +00:00
|
|
|
bool Folded = ConstantFoldTerminator(I->getParent());
|
2006-10-23 18:57:02 +00:00
|
|
|
if (!Folded) {
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
// The constant folder may not have been able to fold the terminator
|
2006-10-23 18:57:02 +00:00
|
|
|
// if this is a branch or switch on undef. Fold it manually as a
|
|
|
|
// branch to the first successor.
|
2008-11-21 01:52:59 +00:00
|
|
|
#ifndef NDEBUG
|
2006-10-23 18:57:02 +00:00
|
|
|
if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
|
|
|
|
assert(BI->isConditional() && isa<UndefValue>(BI->getCondition()) &&
|
|
|
|
"Branch should be foldable!");
|
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(I)) {
|
|
|
|
assert(isa<UndefValue>(SI->getCondition()) && "Switch should fold");
|
|
|
|
} else {
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Didn't fold away reference to block!");
|
2006-10-23 18:57:02 +00:00
|
|
|
}
|
2008-11-21 01:52:59 +00:00
|
|
|
#endif
|
2006-10-23 18:57:02 +00:00
|
|
|
|
|
|
|
// Make this an uncond branch to the first successor.
|
|
|
|
TerminatorInst *TI = I->getParent()->getTerminator();
|
2008-04-06 20:25:17 +00:00
|
|
|
BranchInst::Create(TI->getSuccessor(0), TI);
|
2006-10-23 18:57:02 +00:00
|
|
|
|
|
|
|
// Remove entries in successor phi nodes to remove edges.
|
|
|
|
for (unsigned i = 1, e = TI->getNumSuccessors(); i != e; ++i)
|
|
|
|
TI->getSuccessor(i)->removePredecessor(TI->getParent());
|
|
|
|
|
|
|
|
// Remove the old terminator.
|
|
|
|
TI->eraseFromParent();
|
|
|
|
}
|
2004-12-10 22:29:08 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-12-10 22:29:08 +00:00
|
|
|
// Finally, delete the basic block.
|
|
|
|
F->getBasicBlockList().erase(DeadBB);
|
|
|
|
}
|
2007-02-02 21:15:06 +00:00
|
|
|
BlocksToErase.clear();
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2004-12-11 02:53:57 +00:00
|
|
|
|
|
|
|
// If we inferred constant or undef return values for a function, we replaced
|
|
|
|
// all call uses with the inferred value. This means we don't need to bother
|
|
|
|
// actually returning anything from the function. Replace all return
|
|
|
|
// instructions with return undef.
|
2010-02-27 00:07:42 +00:00
|
|
|
//
|
|
|
|
// Do this in two stages: first identify the functions we should process, then
|
|
|
|
// actually zap their returns. This is important because we can only do this
|
2010-02-27 07:50:40 +00:00
|
|
|
// if the address of the function isn't taken. In cases where a return is the
|
2010-02-27 00:07:42 +00:00
|
|
|
// last use of a function, the order of processing functions would affect
|
2010-02-27 07:50:40 +00:00
|
|
|
// whether other functions are optimizable.
|
2010-02-27 00:07:42 +00:00
|
|
|
SmallVector<ReturnInst*, 8> ReturnsToZap;
|
|
|
|
|
2008-03-11 17:32:05 +00:00
|
|
|
// TODO: Process multiple value ret instructions also.
|
2008-03-11 05:46:42 +00:00
|
|
|
const DenseMap<Function*, LatticeVal> &RV = Solver.getTrackedRetVals();
|
2007-02-02 20:38:30 +00:00
|
|
|
for (DenseMap<Function*, LatticeVal>::const_iterator I = RV.begin(),
|
2009-11-03 03:42:51 +00:00
|
|
|
E = RV.end(); I != E; ++I) {
|
|
|
|
Function *F = I->first;
|
|
|
|
if (I->second.isOverdefined() || F->getReturnType()->isVoidTy())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// We can only do this if we know that nothing else can call the function.
|
|
|
|
if (!F->hasLocalLinkage() || AddressIsTaken(F))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
|
|
|
if (ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator()))
|
|
|
|
if (!isa<UndefValue>(RI->getOperand(0)))
|
2010-02-27 00:07:42 +00:00
|
|
|
ReturnsToZap.push_back(RI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Zap all returns which we've identified as zap to change.
|
|
|
|
for (unsigned i = 0, e = ReturnsToZap.size(); i != e; ++i) {
|
|
|
|
Function *F = ReturnsToZap[i]->getParent()->getParent();
|
|
|
|
ReturnsToZap[i]->setOperand(0, UndefValue::get(F->getReturnType()));
|
2009-11-03 03:42:51 +00:00
|
|
|
}
|
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
// If we infered constant or undef values for globals variables, we can delete
|
|
|
|
// the global and any stores that remain to it.
|
2007-02-02 20:38:30 +00:00
|
|
|
const DenseMap<GlobalVariable*, LatticeVal> &TG = Solver.getTrackedGlobals();
|
|
|
|
for (DenseMap<GlobalVariable*, LatticeVal>::const_iterator I = TG.begin(),
|
2004-12-11 05:15:59 +00:00
|
|
|
E = TG.end(); I != E; ++I) {
|
|
|
|
GlobalVariable *GV = I->first;
|
|
|
|
assert(!I->second.isOverdefined() &&
|
|
|
|
"Overdefined values should have been taken out of the map!");
|
2010-01-05 01:27:15 +00:00
|
|
|
DEBUG(dbgs() << "Found that GV '" << GV->getName() << "' is constant!\n");
|
2004-12-11 05:15:59 +00:00
|
|
|
while (!GV->use_empty()) {
|
|
|
|
StoreInst *SI = cast<StoreInst>(GV->use_back());
|
|
|
|
SI->eraseFromParent();
|
|
|
|
}
|
|
|
|
M.getGlobalList().erase(GV);
|
2004-12-11 06:05:53 +00:00
|
|
|
++IPNumGlobalConst;
|
2004-12-11 05:15:59 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
return MadeChanges;
|
|
|
|
}
|