#include "llvm/Transforms/LevelChange.h"
#include "TransformInternals.h"
-#include "llvm/Method.h"
#include "llvm/iOther.h"
#include "llvm/iMemory.h"
-#include "llvm/ConstantVals.h"
+#include "llvm/Pass.h"
+#include "llvm/ConstantHandling.h"
#include "llvm/Transforms/Scalar/DCE.h"
-#include "llvm/Transforms/Scalar/ConstantHandling.h"
#include "llvm/Transforms/Scalar/ConstantProp.h"
#include "llvm/Analysis/Expressions.h"
#include "Support/STLExtras.h"
#include <algorithm>
-#include "llvm/Assembly/Writer.h"
-
//#define DEBUG_PEEPHOLE_INSTS 1
#ifdef DEBUG_PEEPHOLE_INSTS
#define PRINT_PEEPHOLE(ID, NUM, I) \
- cerr << "Inst P/H " << ID << "[" << NUM << "] " << I;
+ std::cerr << "Inst P/H " << ID << "[" << NUM << "] " << I;
#else
#define PRINT_PEEPHOLE(ID, NUM, I)
#endif
}
-
// Peephole optimize the following instructions:
// %t1 = cast ? to x *
// %t2 = add x * %SP, %t1 ;; Constant must be 2nd operand
static bool HandleCastToPointer(BasicBlock::iterator BI,
const PointerType *DestPTy) {
CastInst *CI = cast<CastInst>(*BI);
+ if (CI->use_empty()) return false;
// Scan all of the uses, looking for any uses that are not add
// instructions. If we have non-adds, do not make this transformation.
// If we have a getelementptr capability... transform all of the
// add instruction uses into getelementptr's.
- for (Value::use_iterator UI = CI->use_begin(), E = CI->use_end();
- UI != E; ++UI) {
- Instruction *I = cast<Instruction>(*UI);
+ while (!CI->use_empty()) {
+ BinaryOperator *I = cast<BinaryOperator>(*CI->use_begin());
assert(I->getOpcode() == Instruction::Add && I->getNumOperands() == 2 &&
"Use is not a valid add instruction!");
// Get the value added to the cast result pointer...
Value *OtherPtr = I->getOperand((I->getOperand(0) == CI) ? 1 : 0);
- BasicBlock *BB = I->getParent();
- BasicBlock::iterator AddIt = find(BB->getInstList().begin(),
- BB->getInstList().end(), I);
+ Instruction *GEP = new GetElementPtrInst(OtherPtr, Indices, I->getName());
+ PRINT_PEEPHOLE1("cast-add-to-gep:i", I);
- GetElementPtrInst *GEP = new GetElementPtrInst(OtherPtr, Indices);
+ if (GEP->getType() == I->getType()) {
+ // Replace the old add instruction with the shiny new GEP inst
+ ReplaceInstWithInst(I, GEP);
+ } else {
+ // If the type produced by the gep instruction differs from the original
+ // add instruction type, insert a cast now.
+ //
+
+ // Insert the GEP instruction before the old add instruction... and get an
+ // iterator to point at the add instruction...
+ BasicBlock::iterator GEPI = InsertInstBeforeInst(GEP, I)+1;
+
+ PRINT_PEEPHOLE1("cast-add-to-gep:o", GEP);
+ CastInst *CI = new CastInst(GEP, I->getType());
+ GEP = CI;
+
+ // Replace the old add instruction with the shiny new GEP inst
+ ReplaceInstWithInst(I->getParent()->getInstList(), GEPI, GEP);
+ }
- PRINT_PEEPHOLE1("cast-add-to-gep:i", I);
-
- // Replace the old add instruction with the shiny new GEP inst
- ReplaceInstWithInst(BB->getInstList(), AddIt, GEP);
PRINT_PEEPHOLE1("cast-add-to-gep:o", GEP);
}
return true;
return true;
}
- // Peephole optimize the following instructions:
- // %tmp = cast <ty> %V to <ty2>
- // %V = cast <ty2> %tmp to <ty3> ; Where ty & ty2 are same size
- //
- // Into: cast <ty> %V to <ty3>
- //
- if (SrcI)
- if (CastInst *CSrc = dyn_cast<CastInst>(SrcI))
- if (isReinterpretingCast(CI) + isReinterpretingCast(CSrc) < 2) {
- // We can only do c-c elimination if, at most, one cast does a
- // reinterpretation of the input data.
- //
- // If legal, make this cast refer the the original casts argument!
- //
- PRINT_PEEPHOLE2("cast-cast:in ", CI, CSrc);
- CI->setOperand(0, CSrc->getOperand(0));
- PRINT_PEEPHOLE1("cast-cast:out", CI);
- return true;
- }
-
// Check to see if it's a cast of an instruction that does not depend on the
// specific type of the operands to do it's job.
if (!isReinterpretingCast(CI)) {
-static bool DoRaisePass(Method *M) {
+static bool DoRaisePass(Function *F) {
bool Changed = false;
- for (Method::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) {
+ for (Function::iterator MI = F->begin(), ME = F->end(); MI != ME; ++MI) {
BasicBlock *BB = *MI;
BasicBlock::InstListType &BIL = BB->getInstList();
#if DEBUG_PEEPHOLE_INSTS
cerr << "Processing: " << *BI;
#endif
- if (DeadCodeElimination::dceInstruction(BIL, BI) ||
- ConstantPropogation::doConstantPropogation(BB, BI)) {
+ if (dceInstruction(BIL, BI) || doConstantPropogation(BB, BI)) {
Changed = true;
#ifdef DEBUG_PEEPHOLE_INSTS
- cerr << "DeadCode Elinated!\n";
+ cerr << "***\t\t^^-- DeadCode Elinated!\n";
#endif
} else if (PeepholeOptimize(BB, BI))
Changed = true;
}
-
-
-// RaisePointerReferences::doit - Raise a method representation to a higher
+// RaisePointerReferences::doit - Raise a function representation to a higher
// level.
//
-bool RaisePointerReferences::doit(Method *M) {
- if (M->isExternal()) return false;
-
+static bool doRPR(Function *F) {
#ifdef DEBUG_PEEPHOLE_INSTS
- cerr << "\n\n\nStarting to work on Method '" << M->getName() << "'\n";
+ cerr << "\n\n\nStarting to work on Function '" << F->getName() << "'\n";
#endif
// Insert casts for all incoming pointer pointer values that are treated as
do {
#ifdef DEBUG_PEEPHOLE_INSTS
- cerr << "Looping: \n" << M;
+ cerr << "Looping: \n" << F;
#endif
- // Iterate over the method, refining it, until it converges on a stable
+ // Iterate over the function, refining it, until it converges on a stable
// state
LocalChange = false;
- while (DoRaisePass(M)) LocalChange = true;
+ while (DoRaisePass(F)) LocalChange = true;
Changed |= LocalChange;
} while (LocalChange);
return Changed;
}
+
+namespace {
+ struct RaisePointerReferences : public FunctionPass {
+ const char *getPassName() const { return "Raise Pointer References"; }
+
+ virtual bool runOnFunction(Function *F) { return doRPR(F); }
+
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.preservesCFG();
+ }
+ };
+}
+
+Pass *createRaisePointerReferencesPass() {
+ return new RaisePointerReferences();
+}
+
+
projects / oota-llvm.git / blobdiff