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
|
|
|
//
|
|
|
|
// Notice that:
|
|
|
|
// * This pass has a habit of making definitions be dead. It is a good idea
|
|
|
|
// to to run a DCE pass sometime after running this pass.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
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"
|
2004-12-10 08:02:06 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2007-02-05 23:32:05 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2007-01-30 23:46:24 +00:00
|
|
|
#include "llvm/Support/InstVisitor.h"
|
2007-02-02 20:38:30 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2007-02-02 20:57:39 +00:00
|
|
|
#include "llvm/ADT/SmallSet.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(IPNumDeadBlocks , "Number of basic blocks unreachable by IPSCCP");
|
|
|
|
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.
|
|
|
|
///
|
2007-02-05 23:32:05 +00:00
|
|
|
class VISIBILITY_HIDDEN LatticeVal {
|
2005-04-21 23:48:37 +00:00
|
|
|
enum {
|
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
|
|
|
|
} LatticeValue; // The current lattice position
|
|
|
|
|
2001-12-03 22:26:30 +00:00
|
|
|
Constant *ConstantVal; // If Constant value, the current value
|
2001-06-27 23:38:11 +00:00
|
|
|
public:
|
2004-11-15 05:03:30 +00:00
|
|
|
inline LatticeVal() : LatticeValue(undefined), ConstantVal(0) {}
|
2006-12-20 06:21:33 +00:00
|
|
|
|
2001-06-27 23:38:11 +00:00
|
|
|
// markOverdefined - Return true if this is a new status to be in...
|
|
|
|
inline bool markOverdefined() {
|
2001-12-03 22:26:30 +00:00
|
|
|
if (LatticeValue != overdefined) {
|
|
|
|
LatticeValue = overdefined;
|
2001-06-27 23:38:11 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
// markConstant - Return true if this is a new status for us.
|
2001-12-03 22:26:30 +00:00
|
|
|
inline bool markConstant(Constant *V) {
|
|
|
|
if (LatticeValue != constant) {
|
2006-12-20 06:21:33 +00:00
|
|
|
if (LatticeValue == undefined) {
|
|
|
|
LatticeValue = constant;
|
2007-01-03 00:11:03 +00:00
|
|
|
assert(V && "Marking constant with NULL");
|
2006-12-20 06:21:33 +00:00
|
|
|
ConstantVal = V;
|
|
|
|
} else {
|
|
|
|
assert(LatticeValue == forcedconstant &&
|
|
|
|
"Cannot move from overdefined to constant!");
|
|
|
|
// Stay at forcedconstant if the constant is the same.
|
|
|
|
if (V == ConstantVal) 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.
|
|
|
|
LatticeValue = overdefined;
|
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
return true;
|
|
|
|
} else {
|
2001-09-07 16:43:22 +00:00
|
|
|
assert(ConstantVal == V && "Marking constant with different value");
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
inline void markForcedConstant(Constant *V) {
|
|
|
|
assert(LatticeValue == undefined && "Can't force a defined value!");
|
|
|
|
LatticeValue = forcedconstant;
|
|
|
|
ConstantVal = V;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool isUndefined() const { return LatticeValue == undefined; }
|
|
|
|
inline bool isConstant() const {
|
|
|
|
return LatticeValue == constant || LatticeValue == forcedconstant;
|
|
|
|
}
|
2001-12-03 22:26:30 +00:00
|
|
|
inline bool isOverdefined() const { return LatticeValue == overdefined; }
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-01-12 03:57:30 +00:00
|
|
|
inline Constant *getConstant() const {
|
|
|
|
assert(isConstant() && "Cannot get the constant of a non-constant!");
|
|
|
|
return ConstantVal;
|
|
|
|
}
|
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> {
|
2007-02-02 20:57:39 +00:00
|
|
|
SmallSet<BasicBlock*, 16> BBExecutable;// The basic blocks that are executable
|
2007-02-02 22:36:16 +00:00
|
|
|
std::map<Value*, LatticeVal> ValueState; // The state each value is in.
|
2004-07-15 23:36:43 +00:00
|
|
|
|
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-04-23 05:38:20 +00:00
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal> TrackedMultipleRetVals;
|
2004-12-10 08:02:06 +00:00
|
|
|
|
2004-07-15 23:36:43 +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.
|
2004-12-10 08:02:06 +00:00
|
|
|
std::vector<Value*> OverdefinedInstWorkList;
|
|
|
|
std::vector<Value*> InstWorkList;
|
2004-07-15 23:36:43 +00:00
|
|
|
|
|
|
|
|
2002-01-20 22:54:45 +00:00
|
|
|
std::vector<BasicBlock*> 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.
|
|
|
|
typedef std::pair<BasicBlock*,BasicBlock*> Edge;
|
|
|
|
std::set<Edge> KnownFeasibleEdges;
|
2002-04-29 21:26:08 +00:00
|
|
|
public:
|
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.
|
|
|
|
void MarkBlockExecutable(BasicBlock *BB) {
|
2008-05-11 01:55:59 +00:00
|
|
|
DOUT << "Marking Block Executable: " << BB->getNameStart() << "\n";
|
2004-11-15 04:44:20 +00:00
|
|
|
BBExecutable.insert(BB); // Basic block is executable!
|
|
|
|
BBWorkList.push_back(BB); // Add the block to the work list!
|
|
|
|
}
|
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) {
|
|
|
|
const Type *ElTy = GV->getType()->getElementType();
|
|
|
|
if (ElTy->isFirstClassType()) {
|
|
|
|
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) {
|
|
|
|
assert(F->hasInternalLinkage() && "Can only track internal functions!");
|
|
|
|
// Add an entry, F -> undef.
|
2008-03-11 05:46:42 +00:00
|
|
|
if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
/// getExecutableBlocks - Once we have solved for constants, return the set of
|
|
|
|
/// blocks that is known to be executable.
|
2007-02-02 20:57:39 +00:00
|
|
|
SmallSet<BasicBlock*, 16> &getExecutableBlocks() {
|
2004-11-15 04:44:20 +00:00
|
|
|
return BBExecutable;
|
2002-04-29 21:26:08 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
/// getValueMapping - Once we have solved for constants, return the mapping of
|
2004-11-15 05:03:30 +00:00
|
|
|
/// LLVM values to LatticeVals.
|
2007-02-02 22:36:16 +00:00
|
|
|
std::map<Value*, LatticeVal> &getValueMapping() {
|
2004-11-15 04:44:20 +00:00
|
|
|
return ValueState;
|
|
|
|
}
|
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;
|
|
|
|
}
|
|
|
|
|
2007-03-04 04:50:21 +00:00
|
|
|
inline void markOverdefined(Value *V) {
|
|
|
|
markOverdefined(ValueState[V], V);
|
|
|
|
}
|
2004-12-11 02:53:57 +00:00
|
|
|
|
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.
|
|
|
|
//
|
2004-12-10 08:02:06 +00:00
|
|
|
inline void markConstant(LatticeVal &IV, Value *V, Constant *C) {
|
2003-10-08 16:21:03 +00:00
|
|
|
if (IV.markConstant(C)) {
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "markConstant: " << *C << ": " << *V;
|
2004-12-10 08:02:06 +00:00
|
|
|
InstWorkList.push_back(V);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
2003-10-08 16:21:03 +00:00
|
|
|
}
|
2006-12-20 06:21:33 +00:00
|
|
|
|
|
|
|
inline void markForcedConstant(LatticeVal &IV, Value *V, Constant *C) {
|
|
|
|
IV.markForcedConstant(C);
|
|
|
|
DOUT << "markForcedConstant: " << *C << ": " << *V;
|
|
|
|
InstWorkList.push_back(V);
|
|
|
|
}
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
inline void markConstant(Value *V, Constant *C) {
|
|
|
|
markConstant(ValueState[V], V, C);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
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.
|
2004-12-10 08:02:06 +00:00
|
|
|
inline void markOverdefined(LatticeVal &IV, Value *V) {
|
2003-10-08 16:21:03 +00:00
|
|
|
if (IV.markOverdefined()) {
|
2006-11-26 09:46:52 +00:00
|
|
|
DEBUG(DOUT << "markOverdefined: ";
|
2004-12-11 06:05:53 +00:00
|
|
|
if (Function *F = dyn_cast<Function>(V))
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "Function '" << F->getName() << "'\n";
|
2004-12-11 06:05:53 +00:00
|
|
|
else
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << *V);
|
2004-11-15 04:44:20 +00:00
|
|
|
// Only instructions go on the work list
|
2004-12-10 08:02:06 +00:00
|
|
|
OverdefinedInstWorkList.push_back(V);
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
2003-10-08 16:21:03 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
|
|
|
|
inline void mergeInValue(LatticeVal &IV, Value *V, LatticeVal &MergeWithV) {
|
|
|
|
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
|
|
|
|
|
|
|
inline void mergeInValue(Value *V, LatticeVal &MergeWithV) {
|
|
|
|
return mergeInValue(ValueState[V], V, MergeWithV);
|
|
|
|
}
|
|
|
|
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
// getValueState - Return the LatticeVal object that corresponds to the value.
|
2003-08-18 14:43:39 +00:00
|
|
|
// This function is necessary because not all values should start out in the
|
2002-04-09 19:48:49 +00:00
|
|
|
// underdefined state... Argument's should be overdefined, and
|
2002-03-26 18:01:55 +00:00
|
|
|
// constants should be marked as constants. If a value is not known to be an
|
2001-06-27 23:38:11 +00:00
|
|
|
// Instruction object, then use this accessor to get its value from the map.
|
|
|
|
//
|
2004-11-15 05:03:30 +00:00
|
|
|
inline LatticeVal &getValueState(Value *V) {
|
2007-02-02 22:36:16 +00:00
|
|
|
std::map<Value*, LatticeVal>::iterator I = ValueState.find(V);
|
2001-06-27 23:38:11 +00:00
|
|
|
if (I != ValueState.end()) return I->second; // Common case, in the map
|
2004-10-16 18:09:41 +00:00
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
2004-11-15 05:45:33 +00:00
|
|
|
if (isa<UndefValue>(V)) {
|
|
|
|
// Nothing to do, remain undefined.
|
|
|
|
} else {
|
2007-02-02 20:38:30 +00:00
|
|
|
LatticeVal &LV = ValueState[C];
|
|
|
|
LV.markConstant(C); // Constants are constant
|
|
|
|
return LV;
|
2004-11-15 05:45:33 +00:00
|
|
|
}
|
2002-08-30 23:39:00 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
// All others are underdefined by default...
|
|
|
|
return ValueState[V];
|
|
|
|
}
|
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
// markEdgeExecutable - Mark a basic block as executable, adding it to the BB
|
2001-06-27 23:38:11 +00:00
|
|
|
// work list if it is not already executable...
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
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!
|
|
|
|
|
|
|
|
if (BBExecutable.count(Dest)) {
|
2008-05-11 01:55:59 +00:00
|
|
|
DOUT << "Marking Edge Executable: " << Source->getNameStart()
|
|
|
|
<< " -> " << Dest->getNameStart() << "\n";
|
2003-10-08 16:55:34 +00:00
|
|
|
|
|
|
|
// The destination is already executable, but 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.
|
2004-12-10 08:02:06 +00:00
|
|
|
for (BasicBlock::iterator I = Dest->begin(); isa<PHINode>(I); ++I)
|
|
|
|
visitPHINode(*cast<PHINode>(I));
|
2003-04-25 02:50:03 +00:00
|
|
|
|
|
|
|
} else {
|
2004-11-15 04:44:20 +00:00
|
|
|
MarkBlockExecutable(Dest);
|
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
|
|
|
|
// block to the 'To' basic block is currently feasible...
|
|
|
|
//
|
|
|
|
bool isEdgeFeasible(BasicBlock *From, BasicBlock *To);
|
|
|
|
|
|
|
|
// OperandChangedState - This method is invoked on all of the users of an
|
|
|
|
// instruction that was just changed state somehow.... Based on this
|
|
|
|
// information, we need to update the specified user of this instruction.
|
|
|
|
//
|
|
|
|
void OperandChangedState(User *U) {
|
|
|
|
// Only instructions use other variable values!
|
|
|
|
Instruction &I = cast<Instruction>(*U);
|
|
|
|
if (BBExecutable.count(I.getParent())) // Inst is executable?
|
|
|
|
visit(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
friend class InstVisitor<SCCPSolver>;
|
2001-06-29 23:56:23 +00:00
|
|
|
|
2005-04-21 23:48:37 +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);
|
2008-03-11 05:46:42 +00:00
|
|
|
void visitGetResultInst(GetResultInst &GRI);
|
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
|
|
|
|
|
|
|
// Instructions that cannot be folded away...
|
2004-12-11 05:15:59 +00:00
|
|
|
void visitStoreInst (Instruction &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);
|
2004-12-10 08:02:06 +00:00
|
|
|
void visitCallInst (CallInst &I) { visitCallSite(CallSite::get(&I)); }
|
|
|
|
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*/ }
|
2002-06-25 16:13:24 +00:00
|
|
|
void visitAllocationInst(Instruction &I) { markOverdefined(&I); }
|
2003-10-18 05:56:52 +00:00
|
|
|
void visitVANextInst (Instruction &I) { markOverdefined(&I); }
|
|
|
|
void visitVAArgInst (Instruction &I) { markOverdefined(&I); }
|
2002-06-25 16:13:24 +00:00
|
|
|
void visitFreeInst (Instruction &I) { /*returns void*/ }
|
|
|
|
|
|
|
|
void visitInstruction(Instruction &I) {
|
2002-04-18 15:13:15 +00:00
|
|
|
// If a new instruction is added to LLVM that we don't handle...
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "SCCP: Don't know how to handle: " << I;
|
2002-06-25 16:13:24 +00:00
|
|
|
markOverdefined(&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;
|
|
|
|
} else {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &BCValue = getValueState(BI->getCondition());
|
2004-01-12 17:40:36 +00:00
|
|
|
if (BCValue.isOverdefined() ||
|
2007-01-12 04:24:46 +00:00
|
|
|
(BCValue.isConstant() && !isa<ConstantInt>(BCValue.getConstant()))) {
|
2004-01-12 17:40:36 +00:00
|
|
|
// Overdefined condition variables, and branches on unfoldable constant
|
|
|
|
// conditions, mean the branch could go either way.
|
2002-05-02 21:44:00 +00:00
|
|
|
Succs[0] = Succs[1] = true;
|
|
|
|
} else if (BCValue.isConstant()) {
|
|
|
|
// Constant condition variables mean the branch can only go a single way
|
2007-01-11 12:24:14 +00:00
|
|
|
Succs[BCValue.getConstant() == ConstantInt::getFalse()] = true;
|
2002-05-02 21:44:00 +00:00
|
|
|
}
|
|
|
|
}
|
2006-11-02 20:25:50 +00:00
|
|
|
} else if (isa<InvokeInst>(&TI)) {
|
2002-05-02 21:44:00 +00:00
|
|
|
// Invoke instructions successors are always executable.
|
|
|
|
Succs[0] = Succs[1] = true;
|
2002-06-25 16:13:24 +00:00
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(&TI)) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &SCValue = getValueState(SI->getCondition());
|
2004-01-12 17:40:36 +00:00
|
|
|
if (SCValue.isOverdefined() || // Overdefined condition?
|
|
|
|
(SCValue.isConstant() && !isa<ConstantInt>(SCValue.getConstant()))) {
|
2002-05-02 21:44:00 +00:00
|
|
|
// All destinations are executable!
|
2002-06-25 16:13:24 +00:00
|
|
|
Succs.assign(TI.getNumSuccessors(), true);
|
2008-05-10 23:56:54 +00:00
|
|
|
} else if (SCValue.isConstant())
|
|
|
|
Succs[SI->findCaseValue(cast<ConstantInt>(SCValue.getConstant()))] = true;
|
2002-05-02 21:44:00 +00:00
|
|
|
} else {
|
2007-02-02 21:15:06 +00:00
|
|
|
assert(0 && "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
|
|
|
|
// block to the 'To' basic block is currently feasible...
|
|
|
|
//
|
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
|
|
|
|
2002-05-02 21:44:00 +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;
|
2003-10-08 15:47:41 +00:00
|
|
|
else {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &BCValue = getValueState(BI->getCondition());
|
2003-10-08 15:47:41 +00:00
|
|
|
if (BCValue.isOverdefined()) {
|
|
|
|
// Overdefined condition variables mean the branch could go either way.
|
|
|
|
return true;
|
|
|
|
} else if (BCValue.isConstant()) {
|
2004-01-12 17:40:36 +00:00
|
|
|
// Not branching on an evaluatable constant?
|
2007-01-13 00:42:58 +00:00
|
|
|
if (!isa<ConstantInt>(BCValue.getConstant())) return true;
|
2004-01-12 17:40:36 +00:00
|
|
|
|
2003-10-08 15:47:41 +00:00
|
|
|
// Constant condition variables mean the branch can only go a single way
|
2005-04-21 23:48:37 +00:00
|
|
|
return BI->getSuccessor(BCValue.getConstant() ==
|
2007-01-11 12:24:14 +00:00
|
|
|
ConstantInt::getFalse()) == To;
|
2003-10-08 15:47:41 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2006-11-02 20:25:50 +00:00
|
|
|
} else if (isa<InvokeInst>(TI)) {
|
2003-10-08 15:47:41 +00:00
|
|
|
// Invoke instructions successors are always executable.
|
|
|
|
return true;
|
|
|
|
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &SCValue = getValueState(SI->getCondition());
|
2003-10-08 15:47:41 +00:00
|
|
|
if (SCValue.isOverdefined()) { // Overdefined condition?
|
|
|
|
// All destinations are executable!
|
|
|
|
return true;
|
|
|
|
} else if (SCValue.isConstant()) {
|
|
|
|
Constant *CPV = SCValue.getConstant();
|
2004-01-12 17:40:36 +00:00
|
|
|
if (!isa<ConstantInt>(CPV))
|
|
|
|
return true; // not a foldable constant?
|
|
|
|
|
2003-10-08 15:47:41 +00:00
|
|
|
// 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) == CPV) // Found the taken branch...
|
|
|
|
return SI->getSuccessor(i) == To;
|
|
|
|
|
|
|
|
// Constant value not equal to any of the branches... must execute
|
|
|
|
// default branch then...
|
|
|
|
return SI->getDefaultDest() == To;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
} else {
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << "Unknown terminator instruction: " << *TI;
|
2003-10-08 15:47:41 +00:00
|
|
|
abort();
|
|
|
|
}
|
2002-05-02 21:18:01 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2002-04-18 15:13:15 +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) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &PNIV = getValueState(&PN);
|
2004-01-12 03:57:30 +00:00
|
|
|
if (PNIV.isOverdefined()) {
|
|
|
|
// 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);
|
|
|
|
if (I != E) {
|
2007-02-02 21:15:06 +00:00
|
|
|
SmallVector<Instruction*, 16> Users;
|
2004-01-12 03:57:30 +00:00
|
|
|
for (; I != E; ++I) Users.push_back(I->second);
|
|
|
|
while (!Users.empty()) {
|
|
|
|
visit(Users.back());
|
|
|
|
Users.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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.
|
|
|
|
if (PN.getNumIncomingValues() > 64) {
|
|
|
|
markOverdefined(PNIV, &PN);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
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) {
|
2004-11-15 05:03:30 +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
|
|
|
|
2002-06-25 16:13:24 +00:00
|
|
|
if (isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent())) {
|
2003-06-24 20:29:52 +00:00
|
|
|
if (IV.isOverdefined()) { // PHI node becomes overdefined!
|
2003-10-08 16:21:03 +00:00
|
|
|
markOverdefined(PNIV, &PN);
|
2003-06-24 20:29:52 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2003-04-25 02:50:03 +00:00
|
|
|
if (OperandVal == 0) { // Grab the first value...
|
|
|
|
OperandVal = IV.getConstant();
|
2002-04-18 15:13:15 +00:00
|
|
|
} else { // Another value is being merged in!
|
|
|
|
// 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.
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-04-18 15:13:15 +00:00
|
|
|
// Check to see if there are two different constants merging...
|
2003-04-25 02:50:03 +00:00
|
|
|
if (IV.getConstant() != OperandVal) {
|
2002-04-18 15:13:15 +00:00
|
|
|
// Yes there is. This means the PHI node is not constant.
|
|
|
|
// You must be overdefined poor PHI.
|
|
|
|
//
|
2003-10-08 16:21:03 +00:00
|
|
|
markOverdefined(PNIV, &PN); // The PHI node now becomes overdefined
|
2002-04-18 15:13:15 +00:00
|
|
|
return; // I'm done analyzing you
|
2001-11-26 18:57:38 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
}
|
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)
|
2003-10-10 17:57:28 +00:00
|
|
|
markConstant(PNIV, &PN, OperandVal); // Acquire operand value
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
2001-06-27 23:38:11 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
void SCCPSolver::visitReturnInst(ReturnInst &I) {
|
|
|
|
if (I.getNumOperands() == 0) return; // Ret void
|
|
|
|
|
|
|
|
Function *F = I.getParent()->getParent();
|
2008-03-11 05:46:42 +00:00
|
|
|
// If we are tracking the return value of this function, merge it in.
|
|
|
|
if (!F->hasInternalLinkage())
|
|
|
|
return;
|
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
if (!TrackedRetVals.empty() && I.getNumOperands() == 1) {
|
2007-02-02 20:38:30 +00:00
|
|
|
DenseMap<Function*, LatticeVal>::iterator TFRVI =
|
2008-03-11 05:46:42 +00:00
|
|
|
TrackedRetVals.find(F);
|
|
|
|
if (TFRVI != TrackedRetVals.end() &&
|
2004-12-10 08:02:06 +00:00
|
|
|
!TFRVI->second.isOverdefined()) {
|
|
|
|
LatticeVal &IV = getValueState(I.getOperand(0));
|
|
|
|
mergeInValue(TFRVI->second, F, IV);
|
2008-03-11 05:46:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// Handle functions that return multiple values.
|
|
|
|
if (!TrackedMultipleRetVals.empty() && I.getNumOperands() > 1) {
|
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
It = TrackedMultipleRetVals.find(std::make_pair(F, i));
|
|
|
|
if (It == TrackedMultipleRetVals.end()) break;
|
|
|
|
mergeInValue(It->second, F, getValueState(I.getOperand(i)));
|
2004-12-10 08:02:06 +00:00
|
|
|
}
|
2008-06-20 01:15:44 +00:00
|
|
|
} else if (!TrackedMultipleRetVals.empty() &&
|
|
|
|
I.getNumOperands() == 1 &&
|
|
|
|
isa<StructType>(I.getOperand(0)->getType())) {
|
|
|
|
for (unsigned i = 0, e = I.getOperand(0)->getType()->getNumContainedTypes();
|
|
|
|
i != e; ++i) {
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
It = TrackedMultipleRetVals.find(std::make_pair(F, i));
|
|
|
|
if (It == TrackedMultipleRetVals.end()) break;
|
|
|
|
Value *Val = FindInsertedValue(I.getOperand(0), i);
|
|
|
|
mergeInValue(It->second, F, getValueState(Val));
|
|
|
|
}
|
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();
|
|
|
|
|
2002-05-02 21:44:00 +00:00
|
|
|
// Mark all feasible successors executable...
|
|
|
|
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) {
|
2002-06-25 16:13:24 +00:00
|
|
|
Value *V = I.getOperand(0);
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &VState = getValueState(V);
|
2004-01-12 17:43:40 +00:00
|
|
|
if (VState.isOverdefined()) // Inherit overdefinedness of operand
|
2002-06-25 16:13:24 +00:00
|
|
|
markOverdefined(&I);
|
2004-01-12 17:43:40 +00:00
|
|
|
else if (VState.isConstant()) // Propagate constant value
|
2006-12-12 05:05:00 +00:00
|
|
|
markConstant(&I, ConstantExpr::getCast(I.getOpcode(),
|
|
|
|
VState.getConstant(), I.getType()));
|
2001-06-27 23:38:11 +00:00
|
|
|
}
|
|
|
|
|
2008-03-11 05:46:42 +00:00
|
|
|
void SCCPSolver::visitGetResultInst(GetResultInst &GRI) {
|
|
|
|
Value *Aggr = GRI.getOperand(0);
|
2008-04-23 05:38:20 +00:00
|
|
|
|
|
|
|
// If the operand to the getresult is an undef, the result is undef.
|
|
|
|
if (isa<UndefValue>(Aggr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
Function *F;
|
2008-04-09 15:58:24 +00:00
|
|
|
if (CallInst *CI = dyn_cast<CallInst>(Aggr))
|
2008-03-11 05:46:42 +00:00
|
|
|
F = CI->getCalledFunction();
|
2008-04-23 05:38:20 +00:00
|
|
|
else
|
|
|
|
F = cast<InvokeInst>(Aggr)->getCalledFunction();
|
2008-03-11 05:46:42 +00:00
|
|
|
|
2008-04-23 05:38:20 +00:00
|
|
|
// TODO: If IPSCCP resolves the callee of this function, we could propagate a
|
|
|
|
// result back!
|
|
|
|
if (F == 0 || TrackedMultipleRetVals.empty()) {
|
|
|
|
markOverdefined(&GRI);
|
2008-04-09 15:58:24 +00:00
|
|
|
return;
|
2008-04-23 05:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// See if we are tracking the result of the callee.
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
It = TrackedMultipleRetVals.find(std::make_pair(F, GRI.getIndex()));
|
|
|
|
|
|
|
|
// If not tracking this function (for example, it is a declaration) just move
|
|
|
|
// to overdefined.
|
|
|
|
if (It == TrackedMultipleRetVals.end()) {
|
|
|
|
markOverdefined(&GRI);
|
2008-03-11 05:46:42 +00:00
|
|
|
return;
|
|
|
|
}
|
2008-04-23 05:38:20 +00:00
|
|
|
|
|
|
|
// Otherwise, the value will be merged in here as a result of CallSite
|
|
|
|
// handling.
|
2008-03-11 05:46:42 +00:00
|
|
|
}
|
|
|
|
|
2008-06-20 01:15:44 +00:00
|
|
|
void SCCPSolver::visitExtractValueInst(ExtractValueInst &EVI) {
|
|
|
|
Value *Aggr = EVI.getOperand(0);
|
|
|
|
|
|
|
|
// If the operand to the getresult is an undef, the result is undef.
|
|
|
|
if (isa<UndefValue>(Aggr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Currently only handle single-index extractvalues.
|
|
|
|
if (EVI.getNumIndices() != 1) {
|
|
|
|
markOverdefined(&EVI);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Function *F = 0;
|
|
|
|
if (CallInst *CI = dyn_cast<CallInst>(Aggr))
|
|
|
|
F = CI->getCalledFunction();
|
|
|
|
else if (InvokeInst *II = dyn_cast<InvokeInst>(Aggr))
|
|
|
|
F = II->getCalledFunction();
|
|
|
|
|
|
|
|
// TODO: If IPSCCP resolves the callee of this function, we could propagate a
|
|
|
|
// result back!
|
|
|
|
if (F == 0 || TrackedMultipleRetVals.empty()) {
|
|
|
|
markOverdefined(&EVI);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// See if we are tracking the result of the callee.
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
It = TrackedMultipleRetVals.find(std::make_pair(F, *EVI.idx_begin()));
|
|
|
|
|
|
|
|
// If not tracking this function (for example, it is a declaration) just move
|
|
|
|
// to overdefined.
|
|
|
|
if (It == TrackedMultipleRetVals.end()) {
|
|
|
|
markOverdefined(&EVI);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, the value will be merged in here as a result of CallSite
|
|
|
|
// handling.
|
|
|
|
}
|
|
|
|
|
|
|
|
void SCCPSolver::visitInsertValueInst(InsertValueInst &IVI) {
|
|
|
|
Value *Aggr = IVI.getOperand(0);
|
|
|
|
Value *Val = IVI.getOperand(1);
|
|
|
|
|
|
|
|
// If the operand to the getresult is an undef, the result is undef.
|
|
|
|
if (isa<UndefValue>(Aggr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Currently only handle single-index insertvalues.
|
|
|
|
if (IVI.getNumIndices() != 1) {
|
|
|
|
markOverdefined(&IVI);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// See if we are tracking the result of the callee.
|
|
|
|
Function *F = IVI.getParent()->getParent();
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
It = TrackedMultipleRetVals.find(std::make_pair(F, *IVI.idx_begin()));
|
|
|
|
|
|
|
|
// Merge in the inserted member value.
|
|
|
|
if (It != TrackedMultipleRetVals.end())
|
|
|
|
mergeInValue(It->second, F, getValueState(Val));
|
|
|
|
|
|
|
|
// Mark the aggregate result of the IVI overdefined; any tracking that we do will
|
|
|
|
// be done on the individual member values.
|
|
|
|
markOverdefined(&IVI);
|
|
|
|
}
|
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitSelectInst(SelectInst &I) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &CondValue = getValueState(I.getCondition());
|
2006-02-08 02:38:11 +00:00
|
|
|
if (CondValue.isUndefined())
|
|
|
|
return;
|
2007-01-12 04:24:46 +00:00
|
|
|
if (CondValue.isConstant()) {
|
2007-01-11 12:24:14 +00:00
|
|
|
if (ConstantInt *CondCB = dyn_cast<ConstantInt>(CondValue.getConstant())){
|
2007-01-12 04:24:46 +00:00
|
|
|
mergeInValue(&I, getValueState(CondCB->getZExtValue() ? I.getTrueValue()
|
2007-01-11 12:24:14 +00:00
|
|
|
: I.getFalseValue()));
|
2006-02-08 02:38:11 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
LatticeVal &TVal = getValueState(I.getTrueValue());
|
|
|
|
LatticeVal &FVal = getValueState(I.getFalseValue());
|
|
|
|
|
|
|
|
// select ?, C, C -> C.
|
|
|
|
if (TVal.isConstant() && FVal.isConstant() &&
|
|
|
|
TVal.getConstant() == FVal.getConstant()) {
|
|
|
|
markConstant(&I, FVal.getConstant());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TVal.isUndefined()) { // select ?, undef, X -> X.
|
|
|
|
mergeInValue(&I, FVal);
|
|
|
|
} else if (FVal.isUndefined()) { // select ?, X, undef -> X.
|
|
|
|
mergeInValue(&I, TVal);
|
|
|
|
} else {
|
|
|
|
markOverdefined(&I);
|
2004-03-12 05:52:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-18 15:13:15 +00:00
|
|
|
// Handle BinaryOperators and Shift Instructions...
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitBinaryOperator(Instruction &I) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
2004-01-12 03:57:30 +00:00
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &V1State = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal &V2State = getValueState(I.getOperand(1));
|
2004-01-12 03:57:30 +00:00
|
|
|
|
2002-04-18 15:13:15 +00:00
|
|
|
if (V1State.isOverdefined() || V2State.isOverdefined()) {
|
2004-12-11 23:15:19 +00:00
|
|
|
// 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()));
|
2007-02-15 02:26:10 +00:00
|
|
|
else if (const VectorType *PT = dyn_cast<VectorType>(I.getType()))
|
|
|
|
markConstant(IV, &I, ConstantVector::getAllOnesValue(PT));
|
2007-01-04 02:12:40 +00:00
|
|
|
else
|
|
|
|
markConstant(IV, &I, ConstantInt::getAllOnesValue(I.getType()));
|
2004-12-11 23:15:19 +00:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
if (I.getOpcode() == Instruction::And) {
|
|
|
|
if (NonOverdefVal->getConstant()->isNullValue()) {
|
|
|
|
markConstant(IV, &I, NonOverdefVal->getConstant());
|
2007-01-03 00:11:03 +00:00
|
|
|
return; // X and 0 = 0
|
2004-12-11 23:15:19 +00:00
|
|
|
}
|
|
|
|
} else {
|
2007-01-11 12:24:14 +00:00
|
|
|
if (ConstantInt *CI =
|
|
|
|
dyn_cast<ConstantInt>(NonOverdefVal->getConstant()))
|
2004-12-11 23:15:19 +00:00
|
|
|
if (CI->isAllOnesValue()) {
|
|
|
|
markConstant(IV, &I, NonOverdefVal->getConstant());
|
|
|
|
return; // X or -1 = -1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-01-12 03:57:30 +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!
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal Result;
|
2004-01-12 03:57:30 +00:00
|
|
|
for (unsigned i = 0, e = PN1->getNumIncomingValues(); i != e; ++i) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &In1 = getValueState(PN1->getIncomingValue(i));
|
2004-01-12 03:57:30 +00:00
|
|
|
BasicBlock *InBlock = PN1->getIncomingBlock(i);
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &In2 =
|
|
|
|
getValueState(PN2->getIncomingValueForBlock(InBlock));
|
2004-01-12 03:57:30 +00:00
|
|
|
|
|
|
|
if (In1.isOverdefined() || In2.isOverdefined()) {
|
|
|
|
Result.markOverdefined();
|
|
|
|
break; // Cannot fold this operation over the PHI nodes!
|
|
|
|
} else if (In1.isConstant() && In2.isConstant()) {
|
2004-01-12 19:08:43 +00:00
|
|
|
Constant *V = ConstantExpr::get(I.getOpcode(), In1.getConstant(),
|
|
|
|
In2.getConstant());
|
2004-01-12 03:57:30 +00:00
|
|
|
if (Result.isUndefined())
|
2004-01-12 19:08:43 +00:00
|
|
|
Result.markConstant(V);
|
|
|
|
else if (Result.isConstant() && Result.getConstant() != V) {
|
2004-01-12 03:57:30 +00:00
|
|
|
Result.markOverdefined();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
} else if (Result.isUndefined()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
std::multimap<PHINode*, Instruction*>::iterator It, E;
|
|
|
|
tie(It, E) = UsersOfOverdefinedPHIs.equal_range(PN1);
|
|
|
|
while (It != E) {
|
|
|
|
if (It->second == &I) {
|
|
|
|
UsersOfOverdefinedPHIs.erase(It++);
|
|
|
|
} else
|
|
|
|
++It;
|
|
|
|
}
|
|
|
|
tie(It, E) = UsersOfOverdefinedPHIs.equal_range(PN2);
|
|
|
|
while (It != E) {
|
|
|
|
if (It->second == &I) {
|
|
|
|
UsersOfOverdefinedPHIs.erase(It++);
|
|
|
|
} else
|
|
|
|
++It;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
markOverdefined(IV, &I);
|
2002-04-18 15:13:15 +00:00
|
|
|
} else if (V1State.isConstant() && V2State.isConstant()) {
|
2004-01-12 19:08:43 +00:00
|
|
|
markConstant(IV, &I, ConstantExpr::get(I.getOpcode(), V1State.getConstant(),
|
|
|
|
V2State.getConstant()));
|
2002-04-18 15:13:15 +00:00
|
|
|
}
|
|
|
|
}
|
2002-08-30 23:39:00 +00:00
|
|
|
|
2006-12-23 06:05:41 +00:00
|
|
|
// Handle ICmpInst instruction...
|
|
|
|
void SCCPSolver::visitCmpInst(CmpInst &I) {
|
|
|
|
LatticeVal &IV = ValueState[&I];
|
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
|
|
|
LatticeVal &V1State = getValueState(I.getOperand(0));
|
|
|
|
LatticeVal &V2State = getValueState(I.getOperand(1));
|
|
|
|
|
|
|
|
if (V1State.isOverdefined() || V2State.isOverdefined()) {
|
|
|
|
// 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!
|
|
|
|
} else 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) {
|
|
|
|
Result.markOverdefined();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
} else if (Result.isUndefined()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
std::multimap<PHINode*, Instruction*>::iterator It, E;
|
|
|
|
tie(It, E) = UsersOfOverdefinedPHIs.equal_range(PN1);
|
|
|
|
while (It != E) {
|
|
|
|
if (It->second == &I) {
|
|
|
|
UsersOfOverdefinedPHIs.erase(It++);
|
|
|
|
} else
|
|
|
|
++It;
|
|
|
|
}
|
|
|
|
tie(It, E) = UsersOfOverdefinedPHIs.equal_range(PN2);
|
|
|
|
while (It != E) {
|
|
|
|
if (It->second == &I) {
|
|
|
|
UsersOfOverdefinedPHIs.erase(It++);
|
|
|
|
} else
|
|
|
|
++It;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
markOverdefined(IV, &I);
|
|
|
|
} else if (V1State.isConstant() && V2State.isConstant()) {
|
|
|
|
markConstant(IV, &I, ConstantExpr::getCompare(I.getPredicate(),
|
|
|
|
V1State.getConstant(),
|
|
|
|
V2State.getConstant()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-10 19:05:05 +00:00
|
|
|
void SCCPSolver::visitExtractElementInst(ExtractElementInst &I) {
|
2006-12-04 23:54:59 +00:00
|
|
|
// FIXME : SCCP does not handle vectors properly.
|
|
|
|
markOverdefined(&I);
|
|
|
|
return;
|
|
|
|
|
|
|
|
#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) {
|
2006-12-04 23:54:59 +00:00
|
|
|
// FIXME : SCCP does not handle vectors properly.
|
|
|
|
markOverdefined(&I);
|
|
|
|
return;
|
|
|
|
#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) {
|
2006-12-04 23:54:59 +00:00
|
|
|
// FIXME : SCCP does not handle vectors properly.
|
|
|
|
markOverdefined(&I);
|
|
|
|
return;
|
|
|
|
#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
|
|
|
}
|
|
|
|
|
2002-08-30 23:39:00 +00:00
|
|
|
// Handle getelementptr instructions... if all operands are constants then we
|
|
|
|
// can turn this into a getelementptr ConstantExpr.
|
|
|
|
//
|
2004-11-15 04:44:20 +00:00
|
|
|
void SCCPSolver::visitGetElementPtrInst(GetElementPtrInst &I) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
2004-01-12 04:29:41 +00:00
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
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) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &State = getValueState(I.getOperand(i));
|
2002-08-30 23:39:00 +00:00
|
|
|
if (State.isUndefined())
|
|
|
|
return; // Operands are not resolved yet...
|
|
|
|
else if (State.isOverdefined()) {
|
2004-01-12 04:29:41 +00:00
|
|
|
markOverdefined(IV, &I);
|
2002-08-30 23:39:00 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
assert(State.isConstant() && "Unknown state!");
|
|
|
|
Operands.push_back(State.getConstant());
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *Ptr = Operands[0];
|
|
|
|
Operands.erase(Operands.begin()); // Erase the pointer from idx list...
|
|
|
|
|
2007-02-02 20:51:48 +00:00
|
|
|
markConstant(IV, &I, ConstantExpr::getGetElementPtr(Ptr, &Operands[0],
|
|
|
|
Operands.size()));
|
2004-01-12 04:29:41 +00:00
|
|
|
}
|
|
|
|
|
2004-12-11 05:15:59 +00:00
|
|
|
void SCCPSolver::visitStoreInst(Instruction &SI) {
|
|
|
|
if (TrackedGlobals.empty() || !isa<GlobalVariable>(SI.getOperand(1)))
|
|
|
|
return;
|
|
|
|
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;
|
|
|
|
|
|
|
|
// Get the value we are storing into the global.
|
|
|
|
LatticeVal &PtrVal = getValueState(SI.getOperand(0));
|
|
|
|
|
|
|
|
mergeInValue(I->second, GV, PtrVal);
|
|
|
|
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) {
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &IV = ValueState[&I];
|
2004-01-12 04:29:41 +00:00
|
|
|
if (IV.isOverdefined()) return;
|
|
|
|
|
2004-11-15 05:03:30 +00:00
|
|
|
LatticeVal &PtrVal = getValueState(I.getOperand(0));
|
2004-01-12 04:29:41 +00:00
|
|
|
if (PtrVal.isUndefined()) return; // The pointer is not resolved yet!
|
|
|
|
if (PtrVal.isConstant() && !I.isVolatile()) {
|
|
|
|
Value *Ptr = PtrVal.getConstant();
|
2007-12-29 07:56:53 +00:00
|
|
|
// TODO: Consider a target hook for valid address spaces for this xform.
|
|
|
|
if (isa<ConstantPointerNull>(Ptr) &&
|
|
|
|
cast<PointerType>(Ptr->getType())->getAddressSpace() == 0) {
|
2004-03-07 22:16:24 +00:00
|
|
|
// load null -> null
|
|
|
|
markConstant(IV, &I, Constant::getNullValue(I.getType()));
|
|
|
|
return;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-01-12 04:29:41 +00:00
|
|
|
// Transform load (constant global) into the value loaded.
|
2004-12-11 05:15:59 +00:00
|
|
|
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
|
|
|
|
if (GV->isConstant()) {
|
2007-01-30 20:08:39 +00:00
|
|
|
if (!GV->isDeclaration()) {
|
2004-12-11 05:15:59 +00:00
|
|
|
markConstant(IV, &I, GV->getInitializer());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (!TrackedGlobals.empty()) {
|
|
|
|
// If we are tracking this global, merge in the known value for it.
|
2007-02-02 20:38:30 +00:00
|
|
|
DenseMap<GlobalVariable*, LatticeVal>::iterator It =
|
2004-12-11 05:15:59 +00:00
|
|
|
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
|
|
|
|
|
|
|
// Transform load (constantexpr_GEP global, 0, ...) into the value loaded.
|
|
|
|
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr))
|
|
|
|
if (CE->getOpcode() == Instruction::GetElementPtr)
|
2005-04-23 21:38:35 +00:00
|
|
|
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(CE->getOperand(0)))
|
2007-01-30 20:08:39 +00:00
|
|
|
if (GV->isConstant() && !GV->isDeclaration())
|
2005-04-23 21:38:35 +00:00
|
|
|
if (Constant *V =
|
2005-09-26 05:28:52 +00:00
|
|
|
ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE)) {
|
2005-04-23 21:38:35 +00:00
|
|
|
markConstant(IV, &I, V);
|
|
|
|
return;
|
|
|
|
}
|
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.
|
|
|
|
if (F == 0 || !F->hasInternalLinkage()) {
|
|
|
|
CallOverdefined:
|
|
|
|
// Void return and not tracking callee, just bail.
|
|
|
|
if (I->getType() == Type::VoidTy) 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.
|
|
|
|
if (!isa<StructType>(I->getType()) && F && F->isDeclaration() &&
|
|
|
|
canConstantFoldCallTo(F)) {
|
|
|
|
|
|
|
|
SmallVector<Constant*, 8> Operands;
|
|
|
|
for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end();
|
|
|
|
AI != E; ++AI) {
|
|
|
|
LatticeVal &State = getValueState(*AI);
|
|
|
|
if (State.isUndefined())
|
|
|
|
return; // Operands are not resolved yet.
|
|
|
|
else if (State.isOverdefined()) {
|
|
|
|
markOverdefined(I);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
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.
|
|
|
|
if (Constant *C = ConstantFoldCall(F, &Operands[0], Operands.size())) {
|
|
|
|
markConstant(I, C);
|
|
|
|
return;
|
|
|
|
}
|
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.
|
|
|
|
markOverdefined(I);
|
2004-12-10 08:02:06 +00:00
|
|
|
return;
|
|
|
|
}
|
2005-04-21 23:48:37 +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.
|
2008-06-20 01:15:44 +00:00
|
|
|
DenseMap<Function*, LatticeVal>::iterator TFRVI = TrackedRetVals.find(F);
|
|
|
|
if (TFRVI != TrackedRetVals.end()) {
|
2008-04-23 05:38:20 +00:00
|
|
|
// If so, propagate the return value of the callee into this call result.
|
|
|
|
mergeInValue(I, TFRVI->second);
|
2008-06-20 01:15:44 +00:00
|
|
|
} else if (isa<StructType>(I->getType())) {
|
2008-04-23 05:38:20 +00:00
|
|
|
// Check to see if we're tracking this callee, if not, handle it in the
|
|
|
|
// common path above.
|
|
|
|
std::map<std::pair<Function*, unsigned>, LatticeVal>::iterator
|
|
|
|
TMRVI = TrackedMultipleRetVals.find(std::make_pair(F, 0));
|
|
|
|
if (TMRVI == TrackedMultipleRetVals.end())
|
|
|
|
goto CallOverdefined;
|
|
|
|
|
|
|
|
// If we are tracking this callee, propagate the return values of the call
|
2008-06-20 01:15:44 +00:00
|
|
|
// into this call site. We do this by walking all the uses. Single-index
|
|
|
|
// ExtractValueInst uses can be tracked; anything more complicated is
|
|
|
|
// currently handled conservatively.
|
2008-04-23 05:38:20 +00:00
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI) {
|
2008-06-20 01:15:44 +00:00
|
|
|
if (GetResultInst *GRI = dyn_cast<GetResultInst>(*UI)) {
|
|
|
|
mergeInValue(GRI,
|
|
|
|
TrackedMultipleRetVals[std::make_pair(F, GRI->getIndex())]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(*UI)) {
|
|
|
|
if (EVI->getNumIndices() == 1) {
|
|
|
|
mergeInValue(EVI,
|
|
|
|
TrackedMultipleRetVals[std::make_pair(F, *EVI->idx_begin())]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// The aggregate value is used in a way not handled here. Assume nothing.
|
|
|
|
markOverdefined(*UI);
|
2004-04-13 19:43:54 +00:00
|
|
|
}
|
2008-06-20 01:15:44 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise we're not tracking this callee, so handle it in the
|
|
|
|
// common path above.
|
|
|
|
goto CallOverdefined;
|
2004-04-13 19:43:54 +00:00
|
|
|
}
|
2008-04-23 05:38:20 +00:00
|
|
|
|
|
|
|
// Finally, if this is the first call to the function hit, mark its entry
|
|
|
|
// block executable.
|
|
|
|
if (!BBExecutable.count(F->begin()))
|
|
|
|
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) {
|
|
|
|
LatticeVal &IV = ValueState[AI];
|
|
|
|
if (!IV.isOverdefined())
|
|
|
|
mergeInValue(IV, AI, getValueState(*CAI));
|
|
|
|
}
|
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()) {
|
2004-11-15 04:44:20 +00:00
|
|
|
// Process the instruction work list...
|
|
|
|
while (!OverdefinedInstWorkList.empty()) {
|
2004-12-10 08:02:06 +00:00
|
|
|
Value *I = OverdefinedInstWorkList.back();
|
2004-11-15 04:44:20 +00:00
|
|
|
OverdefinedInstWorkList.pop_back();
|
|
|
|
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "\nPopped off OI-WL: " << *I;
|
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
|
|
|
|
// Update all of the users of this instruction's value...
|
|
|
|
//
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI)
|
|
|
|
OperandChangedState(*UI);
|
|
|
|
}
|
|
|
|
// Process the instruction work list...
|
|
|
|
while (!InstWorkList.empty()) {
|
2004-12-10 08:02:06 +00:00
|
|
|
Value *I = InstWorkList.back();
|
2004-11-15 04:44:20 +00:00
|
|
|
InstWorkList.pop_back();
|
|
|
|
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "\nPopped off I-WL: " << *I;
|
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.
|
|
|
|
// Update all of the users of this instruction's value...
|
|
|
|
//
|
|
|
|
if (!getValueState(I).isOverdefined())
|
|
|
|
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
|
|
|
|
UI != E; ++UI)
|
|
|
|
OperandChangedState(*UI);
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-11-15 04:44:20 +00:00
|
|
|
// Process the basic block work list...
|
|
|
|
while (!BBWorkList.empty()) {
|
|
|
|
BasicBlock *BB = BBWorkList.back();
|
|
|
|
BBWorkList.pop_back();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "\nPopped off BBWL: " << *BB;
|
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.
|
|
|
|
if (I->getType() == Type::VoidTy) continue;
|
|
|
|
|
|
|
|
LatticeVal &LV = getValueState(I);
|
|
|
|
if (!LV.isUndefined()) continue;
|
|
|
|
|
|
|
|
// Get the lattice values of the first two operands for use below.
|
|
|
|
LatticeVal &Op0LV = getValueState(I->getOperand(0));
|
|
|
|
LatticeVal Op1LV;
|
|
|
|
if (I->getNumOperands() == 2) {
|
|
|
|
// 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.
|
|
|
|
assert(Op0LV.isUndefined());
|
|
|
|
markForcedConstant(LV, I, Constant::getNullValue(ITy));
|
|
|
|
return true;
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::And:
|
|
|
|
// undef * X -> 0. X could be zero.
|
|
|
|
// undef & X -> 0. X could be zero.
|
|
|
|
markForcedConstant(LV, I, Constant::getNullValue(ITy));
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case Instruction::Or:
|
|
|
|
// undef | X -> -1. X could be -1.
|
2007-02-15 02:26:10 +00:00
|
|
|
if (const VectorType *PTy = dyn_cast<VectorType>(ITy))
|
|
|
|
markForcedConstant(LV, I, ConstantVector::getAllOnesValue(PTy));
|
2007-01-04 02:12:40 +00:00
|
|
|
else
|
|
|
|
markForcedConstant(LV, I, ConstantInt::getAllOnesValue(ITy));
|
|
|
|
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.
|
|
|
|
markForcedConstant(LV, I, Constant::getNullValue(ITy));
|
|
|
|
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())
|
|
|
|
markForcedConstant(LV, I, Op0LV.getConstant());
|
|
|
|
else
|
|
|
|
markOverdefined(LV, I);
|
|
|
|
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.
|
|
|
|
markForcedConstant(LV, I, Constant::getNullValue(ITy));
|
|
|
|
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())
|
|
|
|
markForcedConstant(LV, I, Op1LV.getConstant());
|
|
|
|
else
|
|
|
|
markOverdefined(LV, 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.
|
|
|
|
markOverdefined(LV, 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)) {
|
2008-05-23 01:01:31 +00:00
|
|
|
if (SI->getNumSuccessors()<2) // no cases
|
|
|
|
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)) {
|
|
|
|
BI->setCondition(ConstantInt::getFalse());
|
|
|
|
} 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
|
|
|
///
|
2007-02-05 23:32:05 +00:00
|
|
|
struct VISIBILITY_HIDDEN SCCP : public FunctionPass {
|
2007-05-06 13:37:16 +00:00
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2007-05-01 21:15:47 +00:00
|
|
|
SCCP() : FunctionPass((intptr_t)&ID) {}
|
|
|
|
|
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
|
|
|
|
|
|
|
// createSCCPPass - This is the public interface to this file...
|
|
|
|
FunctionPass *llvm::createSCCPPass() {
|
|
|
|
return new SCCP();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// runOnFunction() - Run the Sparse Conditional Constant Propagation algorithm,
|
|
|
|
// and return true if the function was modified.
|
|
|
|
//
|
|
|
|
bool SCCP::runOnFunction(Function &F) {
|
2008-05-11 01:55:59 +00:00
|
|
|
DOUT << "SCCP on function '" << F.getNameStart() << "'\n";
|
2004-11-15 04:44:20 +00:00
|
|
|
SCCPSolver Solver;
|
|
|
|
|
|
|
|
// 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)
|
2007-03-04 04:50:21 +00:00
|
|
|
Solver.markOverdefined(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();
|
2006-12-20 06:21:33 +00:00
|
|
|
DOUT << "RESOLVING UNDEFs\n";
|
|
|
|
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-02-02 20:57:39 +00:00
|
|
|
SmallSet<BasicBlock*, 16> &ExecutableBBs = Solver.getExecutableBlocks();
|
2007-02-02 21:15:06 +00:00
|
|
|
SmallVector<Instruction*, 32> Insts;
|
2007-03-04 04:50:21 +00:00
|
|
|
std::map<Value*, LatticeVal> &Values = Solver.getValueMapping();
|
|
|
|
|
2004-11-15 05:45:33 +00:00
|
|
|
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
|
|
|
if (!ExecutableBBs.count(BB)) {
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << " BasicBlock Dead:" << *BB;
|
2004-11-15 07:02:42 +00:00
|
|
|
++NumDeadBlocks;
|
|
|
|
|
2004-11-15 05:45:33 +00:00
|
|
|
// Delete the instructions backwards, as it has a reduced likelihood of
|
|
|
|
// having to update as many def-use and use-def chains.
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = BB->getTerminator();
|
|
|
|
I != E; ++I)
|
|
|
|
Insts.push_back(I);
|
|
|
|
while (!Insts.empty()) {
|
|
|
|
Instruction *I = Insts.back();
|
|
|
|
Insts.pop_back();
|
|
|
|
if (!I->use_empty())
|
|
|
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
|
|
|
BB->getInstList().erase(I);
|
|
|
|
MadeChanges = true;
|
2004-11-15 07:02:42 +00:00
|
|
|
++NumInstRemoved;
|
2004-11-15 05:45:33 +00:00
|
|
|
}
|
2004-12-10 08:02:06 +00:00
|
|
|
} else {
|
|
|
|
// 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++;
|
2008-04-24 00:19:54 +00:00
|
|
|
if (Inst->getType() == Type::VoidTy ||
|
|
|
|
isa<StructType>(Inst->getType()) ||
|
2008-04-24 00:16:28 +00:00
|
|
|
isa<TerminatorInst>(Inst))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
LatticeVal &IV = Values[Inst];
|
|
|
|
if (!IV.isConstant() && !IV.isUndefined())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Constant *Const = IV.isConstant()
|
|
|
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
|
|
|
DOUT << " Constant: " << *Const << " = " << *Inst;
|
|
|
|
|
|
|
|
// 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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return MadeChanges;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
/// IPSCCP Class - This class implements interprocedural Sparse Conditional
|
|
|
|
/// Constant Propagation.
|
|
|
|
///
|
2007-02-05 23:32:05 +00:00
|
|
|
struct VISIBILITY_HIDDEN IPSCCP : public ModulePass {
|
2007-05-03 01:11:54 +00:00
|
|
|
static char ID;
|
2007-05-01 21:15:47 +00:00
|
|
|
IPSCCP() : ModulePass((intptr_t)&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");
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
// createIPSCCPPass - This is the public interface to this file...
|
|
|
|
ModulePass *llvm::createIPSCCPPass() {
|
|
|
|
return new IPSCCP();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool AddressIsTaken(GlobalValue *GV) {
|
2005-04-19 19:16:19 +00:00
|
|
|
// Delete any dead constantexpr klingons.
|
|
|
|
GV->removeDeadConstantUsers();
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end();
|
|
|
|
UI != E; ++UI)
|
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(*UI)) {
|
2004-12-11 05:15:59 +00:00
|
|
|
if (SI->getOperand(0) == GV || SI->isVolatile())
|
|
|
|
return true; // Storing addr of GV.
|
2004-12-10 08:02:06 +00:00
|
|
|
} else if (isa<InvokeInst>(*UI) || isa<CallInst>(*UI)) {
|
|
|
|
// Make sure we are calling the function, not passing the address.
|
|
|
|
CallSite CS = CallSite::get(cast<Instruction>(*UI));
|
|
|
|
for (CallSite::arg_iterator AI = CS.arg_begin(),
|
|
|
|
E = CS.arg_end(); AI != E; ++AI)
|
|
|
|
if (*AI == GV)
|
|
|
|
return true;
|
2004-12-11 05:15:59 +00:00
|
|
|
} else if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) {
|
|
|
|
if (LI->isVolatile())
|
|
|
|
return true;
|
|
|
|
} else {
|
2004-12-10 08:02:06 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IPSCCP::runOnModule(Module &M) {
|
|
|
|
SCCPSolver Solver;
|
|
|
|
|
|
|
|
// Loop over all functions, marking arguments to those with their addresses
|
|
|
|
// taken or that are external as overdefined.
|
|
|
|
//
|
|
|
|
for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
|
|
|
|
if (!F->hasInternalLinkage() || AddressIsTaken(F)) {
|
2007-01-30 20:08:39 +00:00
|
|
|
if (!F->isDeclaration())
|
2004-12-10 08:02:06 +00:00
|
|
|
Solver.MarkBlockExecutable(F->begin());
|
2005-04-19 19:16:19 +00:00
|
|
|
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
|
|
|
|
AI != E; ++AI)
|
2007-03-04 04:50:21 +00:00
|
|
|
Solver.markOverdefined(AI);
|
2004-12-10 08:02:06 +00:00
|
|
|
} else {
|
|
|
|
Solver.AddTrackedFunction(F);
|
2004-11-15 05:45:33 +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)
|
2004-12-11 05:15:59 +00:00
|
|
|
if (!G->isConstant() && G->hasInternalLinkage() && !AddressIsTaken(G))
|
|
|
|
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();
|
|
|
|
|
2006-12-20 06:21:33 +00:00
|
|
|
DOUT << "RESOLVING UNDEFS\n";
|
|
|
|
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.
|
|
|
|
//
|
2007-02-02 20:57:39 +00:00
|
|
|
SmallSet<BasicBlock*, 16> &ExecutableBBs = Solver.getExecutableBlocks();
|
2007-02-02 21:15:06 +00:00
|
|
|
SmallVector<Instruction*, 32> Insts;
|
|
|
|
SmallVector<BasicBlock*, 32> BlocksToErase;
|
2007-03-04 04:50:21 +00:00
|
|
|
std::map<Value*, LatticeVal> &Values = Solver.getValueMapping();
|
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) {
|
2005-04-19 19:16:19 +00:00
|
|
|
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
|
|
|
|
AI != E; ++AI)
|
2004-12-10 08:02:06 +00:00
|
|
|
if (!AI->use_empty()) {
|
|
|
|
LatticeVal &IV = Values[AI];
|
|
|
|
if (IV.isConstant() || IV.isUndefined()) {
|
|
|
|
Constant *CST = IV.isConstant() ?
|
|
|
|
IV.getConstant() : UndefValue::get(AI->getType());
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << "*** Arg " << *AI << " = " << *CST <<"\n";
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
// Replaces all of the uses of a variable with uses of the
|
|
|
|
// constant.
|
|
|
|
AI->replaceAllUsesWith(CST);
|
|
|
|
++IPNumArgsElimed;
|
2004-11-15 04:44:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
|
|
|
if (!ExecutableBBs.count(BB)) {
|
2006-11-26 09:46:52 +00:00
|
|
|
DOUT << " BasicBlock Dead:" << *BB;
|
2004-12-10 08:02:06 +00:00
|
|
|
++IPNumDeadBlocks;
|
2004-12-10 20:41:50 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
// Delete the instructions backwards, as it has a reduced likelihood of
|
|
|
|
// having to update as many def-use and use-def chains.
|
2004-12-10 22:29:08 +00:00
|
|
|
TerminatorInst *TI = BB->getTerminator();
|
|
|
|
for (BasicBlock::iterator I = BB->begin(), E = TI; I != E; ++I)
|
2004-12-10 08:02:06 +00:00
|
|
|
Insts.push_back(I);
|
2004-12-10 22:29:08 +00:00
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
while (!Insts.empty()) {
|
|
|
|
Instruction *I = Insts.back();
|
|
|
|
Insts.pop_back();
|
|
|
|
if (!I->use_empty())
|
|
|
|
I->replaceAllUsesWith(UndefValue::get(I->getType()));
|
|
|
|
BB->getInstList().erase(I);
|
|
|
|
MadeChanges = true;
|
|
|
|
++IPNumInstRemoved;
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-12-10 22:29:08 +00:00
|
|
|
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())
|
|
|
|
TI->replaceAllUsesWith(UndefValue::get(TI->getType()));
|
2004-12-10 22:29:08 +00:00
|
|
|
BB->getInstList().erase(TI);
|
|
|
|
|
2004-12-11 05:32:19 +00:00
|
|
|
if (&*BB != &F->front())
|
|
|
|
BlocksToErase.push_back(BB);
|
|
|
|
else
|
|
|
|
new UnreachableInst(BB);
|
|
|
|
|
2004-12-10 08:02:06 +00:00
|
|
|
} else {
|
|
|
|
for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) {
|
|
|
|
Instruction *Inst = BI++;
|
2008-04-24 00:21:50 +00:00
|
|
|
if (Inst->getType() == Type::VoidTy ||
|
|
|
|
isa<StructType>(Inst->getType()) ||
|
|
|
|
isa<TerminatorInst>(Inst))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
LatticeVal &IV = Values[Inst];
|
|
|
|
if (!IV.isConstant() && !IV.isUndefined())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Constant *Const = IV.isConstant()
|
|
|
|
? IV.getConstant() : UndefValue::get(Inst->getType());
|
|
|
|
DOUT << " Constant: " << *Const << " = " << *Inst;
|
|
|
|
|
|
|
|
// Replaces all of the uses of a variable with uses of the
|
|
|
|
// constant.
|
|
|
|
Inst->replaceAllUsesWith(Const);
|
|
|
|
|
|
|
|
// Delete the instruction.
|
|
|
|
if (!isa<CallInst>(Inst))
|
|
|
|
Inst->eraseFromParent();
|
|
|
|
|
|
|
|
// Hey, we just changed something!
|
|
|
|
MadeChanges = true;
|
|
|
|
++IPNumInstRemoved;
|
2004-12-10 08:02:06 +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];
|
|
|
|
while (!DeadBB->use_empty()) {
|
|
|
|
Instruction *I = cast<Instruction>(DeadBB->use_back());
|
|
|
|
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.
|
|
|
|
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 {
|
|
|
|
assert(0 && "Didn't fold away reference to block!");
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
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(),
|
2004-12-11 02:53:57 +00:00
|
|
|
E = RV.end(); I != E; ++I)
|
|
|
|
if (!I->second.isOverdefined() &&
|
|
|
|
I->first->getReturnType() != Type::VoidTy) {
|
|
|
|
Function *F = I->first;
|
|
|
|
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)))
|
|
|
|
RI->setOperand(0, UndefValue::get(F->getReturnType()));
|
|
|
|
}
|
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!");
|
2008-05-11 01:55:59 +00:00
|
|
|
DOUT << "Found that GV '" << GV->getNameStart() << "' 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;
|
|
|
|
}
|