Changes in directory llvm/lib/Transforms/Utils:
CloneFunction.cpp updated: 1.36 -> 1.37
Local.cpp updated: 1.65 -> 1.66
---
Log message:
Change constant folding APIs to take an optional TargetData, and change
ConstantFoldInstOperands/ConstantFoldCall to take a pointer to an array
of operands + size, instead of an std::vector.
In some cases, switch to using a SmallVector instead of a vector.
This allows us to get rid of some special case gross code that was there
to avoid the cost of constructing a vector.
---
Diffs of the changes: (+18 -41)
CloneFunction.cpp | 22 +++-------------------
Local.cpp | 37 +++++++++++++++----------------------
2 files changed, 18 insertions(+), 41 deletions(-)
Index: llvm/lib/Transforms/Utils/CloneFunction.cpp
diff -u llvm/lib/Transforms/Utils/CloneFunction.cpp:1.36
llvm/lib/Transforms/Utils/CloneFunction.cpp:1.37
--- llvm/lib/Transforms/Utils/CloneFunction.cpp:1.36 Thu Jan 11 22:24:46 2007
+++ llvm/lib/Transforms/Utils/CloneFunction.cpp Tue Jan 30 17:13:49 2007
@@ -21,6 +21,7 @@
#include "llvm/Support/CFG.h"
#include "ValueMapper.h"
#include "llvm/Transforms/Utils/Local.h"
+#include "llvm/ADT/SmallVector.h"
using namespace llvm;
// CloneBasicBlock - See comments in Cloning.h
@@ -281,24 +282,7 @@
/// mapping its operands through ValueMap if they are available.
Constant *PruningFunctionCloner::
ConstantFoldMappedInstruction(const Instruction *I) {
- if (isa<CmpInst>(I)) {
- if (Constant *Op0 = dyn_cast_or_null<Constant>(MapValue(I->getOperand(0),
- ValueMap)))
- if (Constant *Op1 = dyn_cast_or_null<Constant>(MapValue(I->getOperand(1),
- ValueMap)))
- return ConstantExpr::getCompare(cast<CmpInst>(I)->getPredicate(), Op0,
- Op1);
- return 0;
- } else if (isa<BinaryOperator>(I) || isa<ShiftInst>(I)) {
- if (Constant *Op0 = dyn_cast_or_null<Constant>(MapValue(I->getOperand(0),
- ValueMap)))
- if (Constant *Op1 = dyn_cast_or_null<Constant>(MapValue(I->getOperand(1),
- ValueMap)))
- return ConstantExpr::get(I->getOpcode(), Op0, Op1);
- return 0;
- }
-
- std::vector<Constant*> Ops;
+ SmallVector<Constant*, 8> Ops;
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
if (Constant *Op = dyn_cast_or_null<Constant>(MapValue(I->getOperand(i),
ValueMap)))
@@ -306,7 +290,7 @@
else
return 0; // All operands not constant!
- return ConstantFoldInstOperands(I, Ops);
+ return ConstantFoldInstOperands(I, &Ops[0], Ops.size());
}
/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,
Index: llvm/lib/Transforms/Utils/Local.cpp
diff -u llvm/lib/Transforms/Utils/Local.cpp:1.65
llvm/lib/Transforms/Utils/Local.cpp:1.66
--- llvm/lib/Transforms/Utils/Local.cpp:1.65 Thu Jan 11 22:24:46 2007
+++ llvm/lib/Transforms/Utils/Local.cpp Tue Jan 30 17:13:49 2007
@@ -18,8 +18,10 @@
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Target/TargetData.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/ADT/SmallVector.h"
#include <cerrno>
using namespace llvm;
@@ -30,8 +32,9 @@
/// doConstantPropagation - If an instruction references constants, try to fold
/// them together...
///
-bool llvm::doConstantPropagation(BasicBlock::iterator &II) {
- if (Constant *C = ConstantFoldInstruction(II)) {
+bool llvm::doConstantPropagation(BasicBlock::iterator &II,
+ const TargetData *TD) {
+ if (Constant *C = ConstantFoldInstruction(II, TD)) {
// Replaces all of the uses of a variable with uses of the constant.
II->replaceAllUsesWith(C);
@@ -48,7 +51,7 @@
/// is returned. Note that this function can only fail when attempting to fold
/// instructions like loads and stores, which have no constant expression form.
///
-Constant *llvm::ConstantFoldInstruction(Instruction *I) {
+Constant *llvm::ConstantFoldInstruction(Instruction *I, const TargetData *TD) {
if (PHINode *PN = dyn_cast<PHINode>(I)) {
if (PN->getNumIncomingValues() == 0)
return Constant::getNullValue(PN->getType());
@@ -79,24 +82,16 @@
case 0: return 0;
}
- if (isa<BinaryOperator>(I) || isa<ShiftInst>(I)) {
- return ConstantExpr::get(I->getOpcode(), Op0, Op1);
- } else if (isa<ICmpInst>(I)) {
- return ConstantExpr::getICmp(cast<ICmpInst>(I)->getPredicate(), Op0, Op1);
- } else if (isa<FCmpInst>(I)) {
- return ConstantExpr::getFCmp(cast<FCmpInst>(I)->getPredicate(), Op0, Op1);
- }
-
// Scan the operand list, checking to see if they are all constants, if so,
// hand off to ConstantFoldInstOperands.
- std::vector<Constant*> Ops;
+ SmallVector<Constant*, 8> Ops;
for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
if (Constant *Op = dyn_cast<Constant>(I->getOperand(i)))
Ops.push_back(Op);
else
return 0; // All operands not constant!
- return ConstantFoldInstOperands(I, Ops);
+ return ConstantFoldInstOperands(I, &Ops[0], Ops.size());
}
/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
@@ -106,7 +101,8 @@
/// constant expression form.
///
Constant *llvm::ConstantFoldInstOperands(const Instruction* I,
- const std::vector<Constant*> &Ops) {
+ Constant** Ops, unsigned NumOps,
+ const TargetData *TD) {
unsigned Opc = I->getOpcode();
const Type *DestTy = I->getType();
@@ -117,12 +113,9 @@
switch (Opc) {
default: return 0;
case Instruction::Call:
- if (Function *F = dyn_cast<Function>(Ops[0])) {
- if (canConstantFoldCallTo(F)) {
- std::vector<Constant*> Args(Ops.begin()+1, Ops.end());
- return ConstantFoldCall(F, Args);
- }
- }
+ if (Function *F = dyn_cast<Function>(Ops[0]))
+ if (canConstantFoldCallTo(F))
+ return ConstantFoldCall(F, Ops+1, NumOps);
return 0;
case Instruction::ICmp:
case Instruction::FCmp:
@@ -155,8 +148,8 @@
return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]);
case Instruction::GetElementPtr:
return ConstantExpr::getGetElementPtr(Ops[0],
-
std::vector<Constant*>(Ops.begin()+1,
- Ops.end()));
+ std::vector<Constant*>(Ops+1,
+ Ops+NumOps));
}
}
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
