6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-09-28 22:55:52 +00:00
Code Issues Projects Releases Wiki Activity

Change constant folding APIs to take an optional TargetData, and change

Browse Source 
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.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33670 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2007-01-30 23:13:49 +00:00
parent 73259caa44
commit 9fa038dc21
2 changed files with 18 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
lib/Transforms/Utils/CloneFunction.cpp
View File

@ -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 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB) {
/// 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 @@ ConstantFoldMappedInstruction(const Instruction *I) {
else
return 0; // All operands not constant!
return ConstantFoldInstOperands(I, Ops);
return ConstantFoldInstOperands(I, &Ops[0], Ops.size());
}
/// CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto,

37
lib/Transforms/Utils/Local.cpp
View File

@ -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 @@ using namespace llvm;
/// 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 @@ bool llvm::doConstantPropagation(BasicBlock::iterator &II) {
/// 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 @@ Constant *llvm::ConstantFoldInstruction(Instruction *I) {
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 *llvm::ConstantFoldInstruction(Instruction *I) {
/// 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 @@ Constant *llvm::ConstantFoldInstOperands(const Instruction* I,
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 @@ Constant *llvm::ConstantFoldInstOperands(const Instruction* I,
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));
}
}