Hi,<br>You've forgotten to remove it also from CMakeLists.txt, patch attached<br><br><div class="gmail_quote">On Tue, Apr 13, 2010 at 7:24 AM, Owen Anderson <span dir="ltr"><<a href="mailto:resistor@mac.com">resistor@mac.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">Author: resistor<br>
Date: Tue Apr 13 00:24:08 2010<br>
New Revision: 101117<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=101117&view=rev" target="_blank">http://llvm.org/viewvc/llvm-project?rev=101117&view=rev</a><br>
Log:<br>
SCCVN, we hardly knew ye!<br>
<br>
Removed:<br>
llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp<br>
Modified:<br>
llvm/trunk/include/llvm/LinkAllPasses.h<br>
llvm/trunk/include/llvm/Transforms/Scalar.h<br>
<br>
Modified: llvm/trunk/include/llvm/LinkAllPasses.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LinkAllPasses.h?rev=101117&r1=101116&r2=101117&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LinkAllPasses.h?rev=101117&r1=101116&r2=101117&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/LinkAllPasses.h (original)<br>
+++ llvm/trunk/include/llvm/LinkAllPasses.h Tue Apr 13 00:24:08 2010<br>
@@ -136,7 +136,6 @@<br>
(void) llvm::createSSIPass();<br>
(void) llvm::createSSIEverythingPass();<br>
(void) llvm::createGEPSplitterPass();<br>
- (void) llvm::createSCCVNPass();<br>
(void) llvm::createABCDPass();<br>
(void) llvm::createLintPass();<br>
<br>
<br>
Modified: llvm/trunk/include/llvm/Transforms/Scalar.h<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Scalar.h?rev=101117&r1=101116&r2=101117&view=diff" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Scalar.h?rev=101117&r1=101116&r2=101117&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/include/llvm/Transforms/Scalar.h (original)<br>
+++ llvm/trunk/include/llvm/Transforms/Scalar.h Tue Apr 13 00:24:08 2010<br>
@@ -326,12 +326,6 @@<br>
<br>
//===----------------------------------------------------------------------===//<br>
//<br>
-// SCCVN - Aggressively eliminate redundant scalar values<br>
-//<br>
-FunctionPass *createSCCVNPass();<br>
-<br>
-//===----------------------------------------------------------------------===//<br>
-//<br>
// ABCD - Elimination of Array Bounds Checks on Demand<br>
//<br>
FunctionPass *createABCDPass();<br>
<br>
Removed: llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp?rev=101116&view=auto" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp?rev=101116&view=auto</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp (original)<br>
+++ llvm/trunk/lib/Transforms/Scalar/SCCVN.cpp (removed)<br>
@@ -1,716 +0,0 @@<br>
-//===- SCCVN.cpp - Eliminate redundant values -----------------------------===//<br>
-//<br>
-// The LLVM Compiler Infrastructure<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-//<br>
-// This pass performs global value numbering to eliminate fully redundant<br>
-// instructions. This is based on the paper "SCC-based Value Numbering"<br>
-// by Cooper, et al.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#define DEBUG_TYPE "sccvn"<br>
-#include "llvm/Transforms/Scalar.h"<br>
-#include "llvm/BasicBlock.h"<br>
-#include "llvm/Constants.h"<br>
-#include "llvm/DerivedTypes.h"<br>
-#include "llvm/Function.h"<br>
-#include "llvm/Operator.h"<br>
-#include "llvm/Value.h"<br>
-#include "llvm/ADT/DenseMap.h"<br>
-#include "llvm/ADT/DepthFirstIterator.h"<br>
-#include "llvm/ADT/PostOrderIterator.h"<br>
-#include "llvm/ADT/SmallPtrSet.h"<br>
-#include "llvm/ADT/SmallVector.h"<br>
-#include "llvm/ADT/SparseBitVector.h"<br>
-#include "llvm/ADT/Statistic.h"<br>
-#include "llvm/Analysis/Dominators.h"<br>
-#include "llvm/Support/CFG.h"<br>
-#include "llvm/Support/CommandLine.h"<br>
-#include "llvm/Support/Debug.h"<br>
-#include "llvm/Support/ErrorHandling.h"<br>
-#include "llvm/Transforms/Utils/SSAUpdater.h"<br>
-using namespace llvm;<br>
-<br>
-STATISTIC(NumSCCVNInstr, "Number of instructions deleted by SCCVN");<br>
-STATISTIC(NumSCCVNPhi, "Number of phis deleted by SCCVN");<br>
-<br>
-//===----------------------------------------------------------------------===//<br>
-// ValueTable Class<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-/// This class holds the mapping between values and value numbers. It is used<br>
-/// as an efficient mechanism to determine the expression-wise equivalence of<br>
-/// two values.<br>
-namespace {<br>
- struct Expression {<br>
- enum ExpressionOpcode { ADD, FADD, SUB, FSUB, MUL, FMUL,<br>
- UDIV, SDIV, FDIV, UREM, SREM,<br>
- FREM, SHL, LSHR, ASHR, AND, OR, XOR, ICMPEQ,<br>
- ICMPNE, ICMPUGT, ICMPUGE, ICMPULT, ICMPULE,<br>
- ICMPSGT, ICMPSGE, ICMPSLT, ICMPSLE, FCMPOEQ,<br>
- FCMPOGT, FCMPOGE, FCMPOLT, FCMPOLE, FCMPONE,<br>
- FCMPORD, FCMPUNO, FCMPUEQ, FCMPUGT, FCMPUGE,<br>
- FCMPULT, FCMPULE, FCMPUNE, EXTRACT, INSERT,<br>
- SHUFFLE, SELECT, TRUNC, ZEXT, SEXT, FPTOUI,<br>
- FPTOSI, UITOFP, SITOFP, FPTRUNC, FPEXT,<br>
- PTRTOINT, INTTOPTR, BITCAST, GEP, CALL, CONSTANT,<br>
- INSERTVALUE, EXTRACTVALUE, EMPTY, TOMBSTONE };<br>
-<br>
- ExpressionOpcode opcode;<br>
- const Type* type;<br>
- SmallVector<uint32_t, 4> varargs;<br>
-<br>
- Expression() { }<br>
- Expression(ExpressionOpcode o) : opcode(o) { }<br>
-<br>
- bool operator==(const Expression &other) const {<br>
- if (opcode != other.opcode)<br>
- return false;<br>
- else if (opcode == EMPTY || opcode == TOMBSTONE)<br>
- return true;<br>
- else if (type != other.type)<br>
- return false;<br>
- else {<br>
- if (varargs.size() != other.varargs.size())<br>
- return false;<br>
-<br>
- for (size_t i = 0; i < varargs.size(); ++i)<br>
- if (varargs[i] != other.varargs[i])<br>
- return false;<br>
-<br>
- return true;<br>
- }<br>
- }<br>
-<br>
- bool operator!=(const Expression &other) const {<br>
- return !(*this == other);<br>
- }<br>
- };<br>
-<br>
- class ValueTable {<br>
- private:<br>
- DenseMap<Value*, uint32_t> valueNumbering;<br>
- DenseMap<Expression, uint32_t> expressionNumbering;<br>
- DenseMap<Value*, uint32_t> constantsNumbering;<br>
-<br>
- uint32_t nextValueNumber;<br>
-<br>
- Expression::ExpressionOpcode getOpcode(BinaryOperator* BO);<br>
- Expression::ExpressionOpcode getOpcode(CmpInst* C);<br>
- Expression::ExpressionOpcode getOpcode(CastInst* C);<br>
- Expression create_expression(BinaryOperator* BO);<br>
- Expression create_expression(CmpInst* C);<br>
- Expression create_expression(ShuffleVectorInst* V);<br>
- Expression create_expression(ExtractElementInst* C);<br>
- Expression create_expression(InsertElementInst* V);<br>
- Expression create_expression(SelectInst* V);<br>
- Expression create_expression(CastInst* C);<br>
- Expression create_expression(GetElementPtrInst* G);<br>
- Expression create_expression(CallInst* C);<br>
- Expression create_expression(Constant* C);<br>
- Expression create_expression(ExtractValueInst* C);<br>
- Expression create_expression(InsertValueInst* C);<br>
- public:<br>
- ValueTable() : nextValueNumber(1) { }<br>
- uint32_t computeNumber(Value *V);<br>
- uint32_t lookup(Value *V);<br>
- void add(Value *V, uint32_t num);<br>
- void clear();<br>
- void clearExpressions();<br>
- void erase(Value *v);<br>
- unsigned size();<br>
- void verifyRemoved(const Value *) const;<br>
- };<br>
-}<br>
-<br>
-namespace llvm {<br>
-template <> struct DenseMapInfo<Expression> {<br>
- static inline Expression getEmptyKey() {<br>
- return Expression(Expression::EMPTY);<br>
- }<br>
-<br>
- static inline Expression getTombstoneKey() {<br>
- return Expression(Expression::TOMBSTONE);<br>
- }<br>
-<br>
- static unsigned getHashValue(const Expression e) {<br>
- unsigned hash = e.opcode;<br>
-<br>
- hash = ((unsigned)((uintptr_t)e.type >> 4) ^<br>
- (unsigned)((uintptr_t)e.type >> 9));<br>
-<br>
- for (SmallVector<uint32_t, 4>::const_iterator I = e.varargs.begin(),<br>
- E = e.varargs.end(); I != E; ++I)<br>
- hash = *I + hash * 37;<br>
-<br>
- return hash;<br>
- }<br>
- static bool isEqual(const Expression &LHS, const Expression &RHS) {<br>
- return LHS == RHS;<br>
- }<br>
-};<br>
-template <><br>
-struct isPodLike<Expression> { static const bool value = true; };<br>
-<br>
-}<br>
-<br>
-//===----------------------------------------------------------------------===//<br>
-// ValueTable Internal Functions<br>
-//===----------------------------------------------------------------------===//<br>
-Expression::ExpressionOpcode ValueTable::getOpcode(BinaryOperator* BO) {<br>
- switch(BO->getOpcode()) {<br>
- default: // THIS SHOULD NEVER HAPPEN<br>
- llvm_unreachable("Binary operator with unknown opcode?");<br>
- case Instruction::Add: return Expression::ADD;<br>
- case Instruction::FAdd: return Expression::FADD;<br>
- case Instruction::Sub: return Expression::SUB;<br>
- case Instruction::FSub: return Expression::FSUB;<br>
- case Instruction::Mul: return Expression::MUL;<br>
- case Instruction::FMul: return Expression::FMUL;<br>
- case Instruction::UDiv: return Expression::UDIV;<br>
- case Instruction::SDiv: return Expression::SDIV;<br>
- case Instruction::FDiv: return Expression::FDIV;<br>
- case Instruction::URem: return Expression::UREM;<br>
- case Instruction::SRem: return Expression::SREM;<br>
- case Instruction::FRem: return Expression::FREM;<br>
- case Instruction::Shl: return Expression::SHL;<br>
- case Instruction::LShr: return Expression::LSHR;<br>
- case Instruction::AShr: return Expression::ASHR;<br>
- case Instruction::And: return Expression::AND;<br>
- case Instruction::Or: return Expression::OR;<br>
- case Instruction::Xor: return Expression::XOR;<br>
- }<br>
-}<br>
-<br>
-Expression::ExpressionOpcode ValueTable::getOpcode(CmpInst* C) {<br>
- if (isa<ICmpInst>(C)) {<br>
- switch (C->getPredicate()) {<br>
- default: // THIS SHOULD NEVER HAPPEN<br>
- llvm_unreachable("Comparison with unknown predicate?");<br>
- case ICmpInst::ICMP_EQ: return Expression::ICMPEQ;<br>
- case ICmpInst::ICMP_NE: return Expression::ICMPNE;<br>
- case ICmpInst::ICMP_UGT: return Expression::ICMPUGT;<br>
- case ICmpInst::ICMP_UGE: return Expression::ICMPUGE;<br>
- case ICmpInst::ICMP_ULT: return Expression::ICMPULT;<br>
- case ICmpInst::ICMP_ULE: return Expression::ICMPULE;<br>
- case ICmpInst::ICMP_SGT: return Expression::ICMPSGT;<br>
- case ICmpInst::ICMP_SGE: return Expression::ICMPSGE;<br>
- case ICmpInst::ICMP_SLT: return Expression::ICMPSLT;<br>
- case ICmpInst::ICMP_SLE: return Expression::ICMPSLE;<br>
- }<br>
- } else {<br>
- switch (C->getPredicate()) {<br>
- default: // THIS SHOULD NEVER HAPPEN<br>
- llvm_unreachable("Comparison with unknown predicate?");<br>
- case FCmpInst::FCMP_OEQ: return Expression::FCMPOEQ;<br>
- case FCmpInst::FCMP_OGT: return Expression::FCMPOGT;<br>
- case FCmpInst::FCMP_OGE: return Expression::FCMPOGE;<br>
- case FCmpInst::FCMP_OLT: return Expression::FCMPOLT;<br>
- case FCmpInst::FCMP_OLE: return Expression::FCMPOLE;<br>
- case FCmpInst::FCMP_ONE: return Expression::FCMPONE;<br>
- case FCmpInst::FCMP_ORD: return Expression::FCMPORD;<br>
- case FCmpInst::FCMP_UNO: return Expression::FCMPUNO;<br>
- case FCmpInst::FCMP_UEQ: return Expression::FCMPUEQ;<br>
- case FCmpInst::FCMP_UGT: return Expression::FCMPUGT;<br>
- case FCmpInst::FCMP_UGE: return Expression::FCMPUGE;<br>
- case FCmpInst::FCMP_ULT: return Expression::FCMPULT;<br>
- case FCmpInst::FCMP_ULE: return Expression::FCMPULE;<br>
- case FCmpInst::FCMP_UNE: return Expression::FCMPUNE;<br>
- }<br>
- }<br>
-}<br>
-<br>
-Expression::ExpressionOpcode ValueTable::getOpcode(CastInst* C) {<br>
- switch(C->getOpcode()) {<br>
- default: // THIS SHOULD NEVER HAPPEN<br>
- llvm_unreachable("Cast operator with unknown opcode?");<br>
- case Instruction::Trunc: return Expression::TRUNC;<br>
- case Instruction::ZExt: return Expression::ZEXT;<br>
- case Instruction::SExt: return Expression::SEXT;<br>
- case Instruction::FPToUI: return Expression::FPTOUI;<br>
- case Instruction::FPToSI: return Expression::FPTOSI;<br>
- case Instruction::UIToFP: return Expression::UITOFP;<br>
- case Instruction::SIToFP: return Expression::SITOFP;<br>
- case Instruction::FPTrunc: return Expression::FPTRUNC;<br>
- case Instruction::FPExt: return Expression::FPEXT;<br>
- case Instruction::PtrToInt: return Expression::PTRTOINT;<br>
- case Instruction::IntToPtr: return Expression::INTTOPTR;<br>
- case Instruction::BitCast: return Expression::BITCAST;<br>
- }<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(CallInst* C) {<br>
- Expression e;<br>
-<br>
- e.type = C->getType();<br>
- e.opcode = Expression::CALL;<br>
-<br>
- e.varargs.push_back(lookup(C->getCalledFunction()));<br>
- for (CallInst::op_iterator I = C->op_begin()+1, E = C->op_end();<br>
- I != E; ++I)<br>
- e.varargs.push_back(lookup(*I));<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(BinaryOperator* BO) {<br>
- Expression e;<br>
- e.varargs.push_back(lookup(BO->getOperand(0)));<br>
- e.varargs.push_back(lookup(BO->getOperand(1)));<br>
- e.type = BO->getType();<br>
- e.opcode = getOpcode(BO);<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(CmpInst* C) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(C->getOperand(0)));<br>
- e.varargs.push_back(lookup(C->getOperand(1)));<br>
- e.type = C->getType();<br>
- e.opcode = getOpcode(C);<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(CastInst* C) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(C->getOperand(0)));<br>
- e.type = C->getType();<br>
- e.opcode = getOpcode(C);<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(ShuffleVectorInst* S) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(S->getOperand(0)));<br>
- e.varargs.push_back(lookup(S->getOperand(1)));<br>
- e.varargs.push_back(lookup(S->getOperand(2)));<br>
- e.type = S->getType();<br>
- e.opcode = Expression::SHUFFLE;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(ExtractElementInst* E) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(E->getOperand(0)));<br>
- e.varargs.push_back(lookup(E->getOperand(1)));<br>
- e.type = E->getType();<br>
- e.opcode = Expression::EXTRACT;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(InsertElementInst* I) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(I->getOperand(0)));<br>
- e.varargs.push_back(lookup(I->getOperand(1)));<br>
- e.varargs.push_back(lookup(I->getOperand(2)));<br>
- e.type = I->getType();<br>
- e.opcode = Expression::INSERT;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(SelectInst* I) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(I->getCondition()));<br>
- e.varargs.push_back(lookup(I->getTrueValue()));<br>
- e.varargs.push_back(lookup(I->getFalseValue()));<br>
- e.type = I->getType();<br>
- e.opcode = Expression::SELECT;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(GetElementPtrInst* G) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(G->getPointerOperand()));<br>
- e.type = G->getType();<br>
- e.opcode = Expression::GEP;<br>
-<br>
- for (GetElementPtrInst::op_iterator I = G->idx_begin(), E = G->idx_end();<br>
- I != E; ++I)<br>
- e.varargs.push_back(lookup(*I));<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(ExtractValueInst* E) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(E->getAggregateOperand()));<br>
- for (ExtractValueInst::idx_iterator II = E->idx_begin(), IE = E->idx_end();<br>
- II != IE; ++II)<br>
- e.varargs.push_back(*II);<br>
- e.type = E->getType();<br>
- e.opcode = Expression::EXTRACTVALUE;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-Expression ValueTable::create_expression(InsertValueInst* E) {<br>
- Expression e;<br>
-<br>
- e.varargs.push_back(lookup(E->getAggregateOperand()));<br>
- e.varargs.push_back(lookup(E->getInsertedValueOperand()));<br>
- for (InsertValueInst::idx_iterator II = E->idx_begin(), IE = E->idx_end();<br>
- II != IE; ++II)<br>
- e.varargs.push_back(*II);<br>
- e.type = E->getType();<br>
- e.opcode = Expression::INSERTVALUE;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-//===----------------------------------------------------------------------===//<br>
-// ValueTable External Functions<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-/// add - Insert a value into the table with a specified value number.<br>
-void ValueTable::add(Value *V, uint32_t num) {<br>
- valueNumbering[V] = num;<br>
-}<br>
-<br>
-/// computeNumber - Returns the value number for the specified value, assigning<br>
-/// it a new number if it did not have one before.<br>
-uint32_t ValueTable::computeNumber(Value *V) {<br>
- if (uint32_t v = valueNumbering[V])<br>
- return v;<br>
- else if (uint32_t v= constantsNumbering[V])<br>
- return v;<br>
-<br>
- if (!isa<Instruction>(V)) {<br>
- constantsNumbering[V] = nextValueNumber;<br>
- return nextValueNumber++;<br>
- }<br>
-<br>
- Instruction* I = cast<Instruction>(V);<br>
- Expression exp;<br>
- switch (I->getOpcode()) {<br>
- case Instruction::Add:<br>
- case Instruction::FAdd:<br>
- case Instruction::Sub:<br>
- case Instruction::FSub:<br>
- case Instruction::Mul:<br>
- case Instruction::FMul:<br>
- case Instruction::UDiv:<br>
- case Instruction::SDiv:<br>
- case Instruction::FDiv:<br>
- case Instruction::URem:<br>
- case Instruction::SRem:<br>
- case Instruction::FRem:<br>
- case Instruction::Shl:<br>
- case Instruction::LShr:<br>
- case Instruction::AShr:<br>
- case Instruction::And:<br>
- case Instruction::Or :<br>
- case Instruction::Xor:<br>
- exp = create_expression(cast<BinaryOperator>(I));<br>
- break;<br>
- case Instruction::ICmp:<br>
- case Instruction::FCmp:<br>
- exp = create_expression(cast<CmpInst>(I));<br>
- break;<br>
- case Instruction::Trunc:<br>
- case Instruction::ZExt:<br>
- case Instruction::SExt:<br>
- case Instruction::FPToUI:<br>
- case Instruction::FPToSI:<br>
- case Instruction::UIToFP:<br>
- case Instruction::SIToFP:<br>
- case Instruction::FPTrunc:<br>
- case Instruction::FPExt:<br>
- case Instruction::PtrToInt:<br>
- case Instruction::IntToPtr:<br>
- case Instruction::BitCast:<br>
- exp = create_expression(cast<CastInst>(I));<br>
- break;<br>
- case Instruction::Select:<br>
- exp = create_expression(cast<SelectInst>(I));<br>
- break;<br>
- case Instruction::ExtractElement:<br>
- exp = create_expression(cast<ExtractElementInst>(I));<br>
- break;<br>
- case Instruction::InsertElement:<br>
- exp = create_expression(cast<InsertElementInst>(I));<br>
- break;<br>
- case Instruction::ShuffleVector:<br>
- exp = create_expression(cast<ShuffleVectorInst>(I));<br>
- break;<br>
- case Instruction::ExtractValue:<br>
- exp = create_expression(cast<ExtractValueInst>(I));<br>
- break;<br>
- case Instruction::InsertValue:<br>
- exp = create_expression(cast<InsertValueInst>(I));<br>
- break;<br>
- case Instruction::GetElementPtr:<br>
- exp = create_expression(cast<GetElementPtrInst>(I));<br>
- break;<br>
- default:<br>
- valueNumbering[V] = nextValueNumber;<br>
- return nextValueNumber++;<br>
- }<br>
-<br>
- uint32_t& e = expressionNumbering[exp];<br>
- if (!e) e = nextValueNumber++;<br>
- valueNumbering[V] = e;<br>
-<br>
- return e;<br>
-}<br>
-<br>
-/// lookup - Returns the value number of the specified value. Returns 0 if<br>
-/// the value has not yet been numbered.<br>
-uint32_t ValueTable::lookup(Value *V) {<br>
- if (!isa<Instruction>(V)) {<br>
- if (!constantsNumbering.count(V))<br>
- constantsNumbering[V] = nextValueNumber++;<br>
- return constantsNumbering[V];<br>
- }<br>
-<br>
- return valueNumbering[V];<br>
-}<br>
-<br>
-/// clear - Remove all entries from the ValueTable<br>
-void ValueTable::clear() {<br>
- valueNumbering.clear();<br>
- expressionNumbering.clear();<br>
- constantsNumbering.clear();<br>
- nextValueNumber = 1;<br>
-}<br>
-<br>
-void ValueTable::clearExpressions() {<br>
- expressionNumbering.clear();<br>
- constantsNumbering.clear();<br>
- nextValueNumber = 1;<br>
-}<br>
-<br>
-/// erase - Remove a value from the value numbering<br>
-void ValueTable::erase(Value *V) {<br>
- valueNumbering.erase(V);<br>
-}<br>
-<br>
-/// verifyRemoved - Verify that the value is removed from all internal data<br>
-/// structures.<br>
-void ValueTable::verifyRemoved(const Value *V) const {<br>
- for (DenseMap<Value*, uint32_t>::const_iterator<br>
- I = valueNumbering.begin(), E = valueNumbering.end(); I != E; ++I) {<br>
- assert(I->first != V && "Inst still occurs in value numbering map!");<br>
- }<br>
-}<br>
-<br>
-//===----------------------------------------------------------------------===//<br>
-// SCCVN Pass<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-namespace {<br>
-<br>
- struct ValueNumberScope {<br>
- ValueNumberScope* parent;<br>
- DenseMap<uint32_t, Value*> table;<br>
- SparseBitVector<128> availIn;<br>
- SparseBitVector<128> availOut;<br>
-<br>
- ValueNumberScope(ValueNumberScope* p) : parent(p) { }<br>
- };<br>
-<br>
- class SCCVN : public FunctionPass {<br>
- bool runOnFunction(Function &F);<br>
- public:<br>
- static char ID; // Pass identification, replacement for typeid<br>
- SCCVN() : FunctionPass(&ID) { }<br>
-<br>
- private:<br>
- ValueTable VT;<br>
- DenseMap<BasicBlock*, ValueNumberScope*> BBMap;<br>
-<br>
- // This transformation requires dominator postdominator info<br>
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {<br>
- AU.addRequired<DominatorTree>();<br>
-<br>
- AU.addPreserved<DominatorTree>();<br>
- AU.setPreservesCFG();<br>
- }<br>
- };<br>
-<br>
- char SCCVN::ID = 0;<br>
-}<br>
-<br>
-// createSCCVNPass - The public interface to this file...<br>
-FunctionPass *llvm::createSCCVNPass() { return new SCCVN(); }<br>
-<br>
-static RegisterPass<SCCVN> X("sccvn",<br>
- "SCC Value Numbering");<br>
-<br>
-static Value *lookupNumber(ValueNumberScope *Locals, uint32_t num) {<br>
- while (Locals) {<br>
- DenseMap<uint32_t, Value*>::iterator I = Locals->table.find(num);<br>
- if (I != Locals->table.end())<br>
- return I->second;<br>
- Locals = Locals->parent;<br>
- }<br>
-<br>
- return 0;<br>
-}<br>
-<br>
-bool SCCVN::runOnFunction(Function& F) {<br>
- // Implement the RPO version of the SCCVN algorithm. Conceptually,<br>
- // we optimisitically assume that all instructions with the same opcode have<br>
- // the same VN. Then we deepen our comparison by one level, to all<br>
- // instructions whose operands have the same opcodes get the same VN. We<br>
- // iterate this process until the partitioning stops changing, at which<br>
- // point we have computed a full numbering.<br>
- ReversePostOrderTraversal<Function*> RPOT(&F);<br>
- bool done = false;<br>
- while (!done) {<br>
- done = true;<br>
- VT.clearExpressions();<br>
- for (ReversePostOrderTraversal<Function*>::rpo_iterator I = RPOT.begin(),<br>
- E = RPOT.end(); I != E; ++I) {<br>
- BasicBlock* BB = *I;<br>
- for (BasicBlock::iterator BI = BB->begin(), BE = BB->end();<br>
- BI != BE; ++BI) {<br>
- uint32_t origVN = VT.lookup(BI);<br>
- uint32_t newVN = VT.computeNumber(BI);<br>
- if (origVN != newVN)<br>
- done = false;<br>
- }<br>
- }<br>
- }<br>
-<br>
- // Now, do a dominator walk, eliminating simple, dominated redundancies as we<br>
- // go. Also, build the ValueNumberScope structure that will be used for<br>
- // computing full availability.<br>
- DominatorTree& DT = getAnalysis<DominatorTree>();<br>
- bool changed = false;<br>
- for (df_iterator<DomTreeNode*> DI = df_begin(DT.getRootNode()),<br>
- DE = df_end(DT.getRootNode()); DI != DE; ++DI) {<br>
- BasicBlock* BB = DI->getBlock();<br>
- if (DI->getIDom())<br>
- BBMap[BB] = new ValueNumberScope(BBMap[DI->getIDom()->getBlock()]);<br>
- else<br>
- BBMap[BB] = new ValueNumberScope(0);<br>
-<br>
- for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ) {<br>
- uint32_t num = VT.lookup(I);<br>
- Value* repl = lookupNumber(BBMap[BB], num);<br>
-<br>
- if (repl) {<br>
- if (isa<PHINode>(I))<br>
- ++NumSCCVNPhi;<br>
- else<br>
- ++NumSCCVNInstr;<br>
- I->replaceAllUsesWith(repl);<br>
- Instruction* OldInst = I;<br>
- ++I;<br>
- BBMap[BB]->table[num] = repl;<br>
- OldInst->eraseFromParent();<br>
- changed = true;<br>
- } else {<br>
- BBMap[BB]->table[num] = I;<br>
- BBMap[BB]->availOut.set(num);<br>
-<br>
- ++I;<br>
- }<br>
- }<br>
- }<br>
-<br>
- // Perform a forward data-flow to compute availability at all points on<br>
- // the CFG.<br>
- do {<br>
- changed = false;<br>
- for (ReversePostOrderTraversal<Function*>::rpo_iterator I = RPOT.begin(),<br>
- E = RPOT.end(); I != E; ++I) {<br>
- BasicBlock* BB = *I;<br>
- ValueNumberScope *VNS = BBMap[BB];<br>
-<br>
- SparseBitVector<128> preds;<br>
- bool first = true;<br>
- for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB);<br>
- PI != PE; ++PI) {<br>
- if (first) {<br>
- preds = BBMap[*PI]->availOut;<br>
- first = false;<br>
- } else {<br>
- preds &= BBMap[*PI]->availOut;<br>
- }<br>
- }<br>
-<br>
- changed |= (VNS->availIn |= preds);<br>
- changed |= (VNS->availOut |= preds);<br>
- }<br>
- } while (changed);<br>
-<br>
- // Use full availability information to perform non-dominated replacements.<br>
- SSAUpdater SSU;<br>
- for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ++FI) {<br>
- if (!BBMap.count(FI)) continue;<br>
- for (BasicBlock::iterator BI = FI->begin(), BE = FI->end();<br>
- BI != BE; ) {<br>
- uint32_t num = VT.lookup(BI);<br>
- if (!BBMap[FI]->availIn.test(num)) {<br>
- ++BI;<br>
- continue;<br>
- }<br>
-<br>
- SSU.Initialize(BI);<br>
-<br>
- SmallPtrSet<BasicBlock*, 8> visited;<br>
- SmallVector<BasicBlock*, 8> stack;<br>
- visited.insert(FI);<br>
- for (pred_iterator PI = pred_begin(FI), PE = pred_end(FI);<br>
- PI != PE; ++PI)<br>
- if (!visited.count(*PI))<br>
- stack.push_back(*PI);<br>
-<br>
- while (!stack.empty()) {<br>
- BasicBlock* CurrBB = stack.pop_back_val();<br>
- visited.insert(CurrBB);<br>
-<br>
- ValueNumberScope* S = BBMap[CurrBB];<br>
- if (S->table.count(num)) {<br>
- SSU.AddAvailableValue(CurrBB, S->table[num]);<br>
- } else {<br>
- for (pred_iterator PI = pred_begin(CurrBB), PE = pred_end(CurrBB);<br>
- PI != PE; ++PI)<br>
- if (!visited.count(*PI))<br>
- stack.push_back(*PI);<br>
- }<br>
- }<br>
-<br>
- Value* repl = SSU.GetValueInMiddleOfBlock(FI);<br>
- BI->replaceAllUsesWith(repl);<br>
- Instruction* CurInst = BI;<br>
- ++BI;<br>
- BBMap[FI]->table[num] = repl;<br>
- if (isa<PHINode>(CurInst))<br>
- ++NumSCCVNPhi;<br>
- else<br>
- ++NumSCCVNInstr;<br>
-<br>
- CurInst->eraseFromParent();<br>
- }<br>
- }<br>
-<br>
- VT.clear();<br>
- for (DenseMap<BasicBlock*, ValueNumberScope*>::iterator<br>
- I = BBMap.begin(), E = BBMap.end(); I != E; ++I)<br>
- delete I->second;<br>
- BBMap.clear();<br>
-<br>
- return changed;<br>
-}<br>
<br>
<br>
_______________________________________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@cs.uiuc.edu">llvm-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
</blockquote></div><br>