// instruction being checked. They should return true if a common
// subexpression was folded.
//
- bool visitUnaryOperator(Instruction &I);
bool visitBinaryOperator(Instruction &I);
bool visitGetElementPtrInst(GetElementPtrInst &I);
- bool visitCastInst(CastInst &I){return visitUnaryOperator((Instruction&)I);}
+ bool visitCastInst(CastInst &I);
bool visitShiftInst(ShiftInst &I) {
return visitBinaryOperator((Instruction&)I);
}
// This transformation requires dominator and immediate dominator info
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.preservesCFG();
- AU.addRequired(DominatorSet::ID);
- AU.addRequired(ImmediateDominators::ID);
+ AU.addRequired<DominatorSet>();
+ AU.addRequired<ImmediateDominators>();
}
};
} else if (DomSetInfo->dominates(BB2, BB1)) { // Other dom I?
ReplaceInstWithInst(Other, I);
} else {
+ // This code is disabled because it has several problems:
+ // One, the actual assumption is wrong, as shown by this code:
+ // int "test"(int %X, int %Y) {
+ // %Z = add int %X, %Y
+ // ret int %Z
+ // Unreachable:
+ // %Q = add int %X, %Y
+ // ret int %Q
+ // }
+ //
+ // Here there are no shared dominators. Additionally, this had the habit of
+ // moving computations where they were not always computed. For example, in
+ // a cast like this:
+ // if (c) {
+ // if (d) ...
+ // else ... X+Y ...
+ // } else {
+ // ... X+Y ...
+ // }
+ //
+ // In thiscase, the expression would be hoisted to outside the 'if' stmt,
+ // causing the expression to be evaluated, even for the if (d) path, which
+ // could cause problems, if, for example, it caused a divide by zero. In
+ // general the problem this case is trying to solve is better addressed with
+ // PRE than GCSE.
+ //
+
+#if 0
// Handle the most general case now. In this case, neither I dom Other nor
// Other dom I. Because we are in SSA form, we are guaranteed that the
// operands of the two instructions both dominate the uses, so we _know_
// Eliminate 'Other' now.
ReplaceInstWithInst(I, Other);
+#endif
}
}
//
//===----------------------------------------------------------------------===//
-bool GCSE::visitUnaryOperator(Instruction &I) {
+bool GCSE::visitCastInst(CastInst &I) {
Value *Op = I.getOperand(0);
Function *F = I.getParent()->getParent();
for (Value::use_iterator UI = Op->use_begin(), UE = Op->use_end();
UI != UE; ++UI)
if (Instruction *Other = dyn_cast<Instruction>(*UI))
- // Check to see if this new binary operator is not I, but same operand...
+ // Check to see if this new cast is not I, but has the same operand...
if (Other != &I && Other->getOpcode() == I.getOpcode() &&
Other->getOperand(0) == Op && // Is the operand the same?
// Is it embeded in the same function? (This could be false if LHS