[llvm-commits] CVS: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
Chris Lattner
lattner at cs.uiuc.edu
Mon Jan 12 13:36:01 PST 2004
Changes in directory llvm/lib/Transforms/Scalar:
InstructionCombining.cpp updated: 1.146 -> 1.147
---
Log message:
Eliminate use of ConstantHandling and ConstantExpr::getShift interfaces
---
Diffs of the changes: (+58 -39)
Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp
diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.146 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.147
--- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.146 Sun Jan 11 22:13:56 2004
+++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Mon Jan 12 13:35:11 2004
@@ -37,7 +37,6 @@
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Constants.h"
-#include "llvm/ConstantHandling.h"
#include "llvm/DerivedTypes.h"
#include "llvm/GlobalVariable.h"
#include "llvm/Target/TargetData.h"
@@ -234,14 +233,18 @@
return 0;
}
+static Constant *NotConstant(Constant *C) {
+ return ConstantExpr::get(Instruction::Xor, C,
+ ConstantIntegral::getAllOnesValue(C->getType()));
+}
+
static inline Value *dyn_castNotVal(Value *V) {
if (BinaryOperator::isNot(V))
return BinaryOperator::getNotArgument(cast<BinaryOperator>(V));
// Constants can be considered to be not'ed values...
if (ConstantIntegral *C = dyn_cast<ConstantIntegral>(V))
- return ConstantExpr::get(Instruction::Xor,
- ConstantIntegral::getAllOnesValue(C->getType()),C);
+ return NotConstant(C);
return 0;
}
@@ -458,7 +461,8 @@
if (ConstantInt *XorRHS = dyn_cast<ConstantInt>(ILHS->getOperand(1)))
if (XorRHS->isAllOnesValue())
return BinaryOperator::create(Instruction::Sub,
- *CRHS - *ConstantInt::get(I.getType(), 1),
+ ConstantExpr::get(Instruction::Sub,
+ CRHS, ConstantInt::get(I.getType(), 1)),
ILHS->getOperand(0));
break;
default: break;
@@ -498,8 +502,9 @@
// C - ~X == X + (1+C)
if (BinaryOperator::isNot(Op1))
return BinaryOperator::create(Instruction::Add,
- BinaryOperator::getNotArgument(cast<BinaryOperator>(Op1)),
- *C + *ConstantInt::get(I.getType(), 1));
+ BinaryOperator::getNotArgument(cast<BinaryOperator>(Op1)),
+ ConstantExpr::get(Instruction::Add, C,
+ ConstantInt::get(I.getType(), 1)));
}
if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1))
@@ -564,8 +569,8 @@
if (SI->getOpcode() == Instruction::Shl)
if (Constant *ShOp = dyn_cast<Constant>(SI->getOperand(1)))
return BinaryOperator::create(Instruction::Mul, SI->getOperand(0),
- *CI << *ShOp);
-
+ ConstantExpr::get(Instruction::Shl, CI, ShOp));
+
if (CI->isNullValue())
return ReplaceInstUsesWith(I, Op1); // X * 0 == 0
if (CI->equalsInt(1)) // X * 1 == X
@@ -763,9 +768,11 @@
ConstantIntegral *AndRHS,
BinaryOperator &TheAnd) {
Value *X = Op->getOperand(0);
+ Constant *Together = ConstantExpr::get(Instruction::And, AndRHS, OpRHS);
+
switch (Op->getOpcode()) {
case Instruction::Xor:
- if ((*AndRHS & *OpRHS)->isNullValue()) {
+ if (Together->isNullValue()) {
// (X ^ C1) & C2 --> (X & C2) iff (C1&C2) == 0
return BinaryOperator::create(Instruction::And, X, AndRHS);
} else if (Op->hasOneUse()) {
@@ -774,15 +781,14 @@
Instruction *And = BinaryOperator::create(Instruction::And,
X, AndRHS, OpName);
InsertNewInstBefore(And, TheAnd);
- return BinaryOperator::create(Instruction::Xor, And, *AndRHS & *OpRHS);
+ return BinaryOperator::create(Instruction::Xor, And, Together);
}
break;
case Instruction::Or:
// (X | C1) & C2 --> X & C2 iff C1 & C1 == 0
- if ((*AndRHS & *OpRHS)->isNullValue())
+ if (Together->isNullValue())
return BinaryOperator::create(Instruction::And, X, AndRHS);
else {
- Constant *Together = *AndRHS & *OpRHS;
if (Together == AndRHS) // (X | C) & C --> C
return ReplaceInstUsesWith(TheAnd, AndRHS);
@@ -840,7 +846,8 @@
// the anded constant includes them, clear them now!
//
Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType());
- Constant *CI = *AndRHS & *(*AllOne << *OpRHS);
+ Constant *CI = ConstantExpr::get(Instruction::And, AndRHS,
+ ConstantExpr::get(Instruction::Shl, AllOne, OpRHS));
if (CI != AndRHS) {
TheAnd.setOperand(1, CI);
return &TheAnd;
@@ -854,7 +861,8 @@
//
if (AndRHS->getType()->isUnsigned()) {
Constant *AllOne = ConstantIntegral::getAllOnesValue(AndRHS->getType());
- Constant *CI = *AndRHS & *(*AllOne >> *OpRHS);
+ Constant *CI = ConstantExpr::get(Instruction::And, AndRHS,
+ ConstantExpr::get(Instruction::Shr, AllOne, OpRHS));
if (CI != AndRHS) {
TheAnd.setOperand(1, CI);
return &TheAnd;
@@ -935,7 +943,8 @@
Op0I->getOperand(0), RHS,
Op0Name);
InsertNewInstBefore(Or, I);
- return BinaryOperator::create(Instruction::And, Or, *RHS | *Op0CI);
+ return BinaryOperator::create(Instruction::And, Or,
+ ConstantExpr::get(Instruction::Or, RHS, Op0CI));
}
// (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
@@ -946,7 +955,9 @@
Op0I->getOperand(0), RHS,
Op0Name);
InsertNewInstBefore(Or, I);
- return BinaryOperator::create(Instruction::Xor, Or, *Op0CI & *~*RHS);
+ return BinaryOperator::create(Instruction::Xor, Or,
+ ConstantExpr::get(Instruction::And, Op0CI,
+ NotConstant(RHS)));
}
}
}
@@ -958,7 +969,7 @@
if (Constant *C0 = dyn_castMaskingAnd(LHS))
if (Constant *C1 = dyn_castMaskingAnd(RHS))
return BinaryOperator::create(Instruction::And, LHS->getOperand(0),
- *C0 | *C1);
+ ConstantExpr::get(Instruction::Or, C0, C1));
Value *Op0NotVal = dyn_castNotVal(Op0);
Value *Op1NotVal = dyn_castNotVal(Op1);
@@ -1011,33 +1022,39 @@
SCI->getOperand(0), SCI->getOperand(1));
// ~(c-X) == X-c-1 == X+(-c-1)
- if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue() &&
- isa<Constant>(Op0I->getOperand(0))) {
- Constant *ConstantRHS = *-*cast<Constant>(Op0I->getOperand(0)) -
- *ConstantInt::get(I.getType(), 1);
- return BinaryOperator::create(Instruction::Add, Op0I->getOperand(1),
- ConstantRHS);
- }
+ if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue())
+ if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) {
+ Constant *NegOp0I0C = ConstantExpr::get(Instruction::Sub,
+ Constant::getNullValue(Op0I0C->getType()), Op0I0C);
+ Constant *ConstantRHS = ConstantExpr::get(Instruction::Sub, NegOp0I0C,
+ ConstantInt::get(I.getType(), 1));
+ return BinaryOperator::create(Instruction::Add, Op0I->getOperand(1),
+ ConstantRHS);
+ }
if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1)))
switch (Op0I->getOpcode()) {
case Instruction::Add:
// ~(X-c) --> (-c-1)-X
- if (RHS->isAllOnesValue())
+ if (RHS->isAllOnesValue()) {
+ Constant *NegOp0CI = ConstantExpr::get(Instruction::Sub,
+ Constant::getNullValue(Op0CI->getType()), Op0CI);
return BinaryOperator::create(Instruction::Sub,
- *-*Op0CI -
- *ConstantInt::get(I.getType(), 1),
+ ConstantExpr::get(Instruction::Sub, NegOp0CI,
+ ConstantInt::get(I.getType(), 1)),
Op0I->getOperand(0));
+ }
break;
case Instruction::And:
// (X & C1) ^ C2 --> (X & C1) | C2 iff (C1&C2) == 0
- if ((*RHS & *Op0CI)->isNullValue())
+ if (ConstantExpr::get(Instruction::And, RHS, Op0CI)->isNullValue())
return BinaryOperator::create(Instruction::Or, Op0, RHS);
break;
case Instruction::Or:
// (X | C1) ^ C2 --> (X | C1) & ~C2 iff (C1&C2) == C2
- if ((*RHS & *Op0CI) == RHS)
- return BinaryOperator::create(Instruction::And, Op0, ~*RHS);
+ if (ConstantExpr::get(Instruction::And, RHS, Op0CI) == RHS)
+ return BinaryOperator::create(Instruction::And, Op0,
+ NotConstant(RHS));
break;
default: break;
}
@@ -1197,7 +1214,7 @@
// the explicit xor.
if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1)))
return BinaryOperator::create(I.getOpcode(), BO->getOperand(0),
- *CI ^ *BOC);
+ ConstantExpr::get(Instruction::Xor, CI, BOC));
// FALLTHROUGH
case Instruction::Sub:
@@ -1210,16 +1227,19 @@
case Instruction::Or:
// If bits are being or'd in that are not present in the constant we
// are comparing against, then the comparison could never succeed!
- if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1)))
- if (!(*BOC & *~*CI)->isNullValue())
+ if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) {
+ Constant *NotCI = NotConstant(CI);
+ if (!ConstantExpr::get(Instruction::And, BOC, NotCI)->isNullValue())
return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
+ }
break;
case Instruction::And:
if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) {
// If bits are being compared against that are and'd out, then the
// comparison can never succeed!
- if (!(*CI & *~*BOC)->isNullValue())
+ if (!ConstantExpr::get(Instruction::And, CI,
+ NotConstant(BOC))->isNullValue())
return ReplaceInstUsesWith(I, ConstantBool::get(isSetNE));
// Replace (and X, (1 << size(X)-1) != 0) with x < 0, converting X
@@ -1403,7 +1423,7 @@
if (BO->getOpcode() == Instruction::Mul && isLeftShift)
if (Constant *BOOp = dyn_cast<Constant>(BO->getOperand(1)))
return BinaryOperator::create(Instruction::Mul, BO->getOperand(0),
- *BOOp << *CUI);
+ ConstantExpr::get(Instruction::Shl, BOOp, CUI));
// If the operand is an bitwise operator with a constant RHS, and the
@@ -1437,8 +1457,7 @@
}
if (isValid) {
- Constant *NewRHS =
- ConstantFoldShiftInstruction(I.getOpcode(), Op0C, CUI);
+ Constant *NewRHS = ConstantExpr::get(I.getOpcode(), Op0C, CUI);
Instruction *NewShift =
new ShiftInst(I.getOpcode(), Op0BO->getOperand(0), CUI,
@@ -1472,9 +1491,9 @@
// Calculate bitmask for what gets shifted off the edge...
Constant *C = ConstantIntegral::getAllOnesValue(I.getType());
if (isLeftShift)
- C = ConstantExpr::getShift(Instruction::Shl, C, ShiftAmt1C);
+ C = ConstantExpr::get(Instruction::Shl, C, ShiftAmt1C);
else
- C = ConstantExpr::getShift(Instruction::Shr, C, ShiftAmt1C);
+ C = ConstantExpr::get(Instruction::Shr, C, ShiftAmt1C);
Instruction *Mask =
BinaryOperator::create(Instruction::And, Op0SI->getOperand(0),
More information about the llvm-commits
mailing list