[llvm-commits] CVS: llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
Nate Begeman
natebegeman at mac.com
Mon Sep 5 21:43:14 PDT 2005
Changes in directory llvm/lib/CodeGen/SelectionDAG:
DAGCombiner.cpp updated: 1.4 -> 1.5
---
Log message:
Next round of DAGCombiner changes. This version now passes all the tests
I have run so far when run before Legalize. It still needs to pick up the
SetCC folds, and nodes that use SetCC.
---
Diffs of the changes: (+231 -236)
DAGCombiner.cpp | 467 +++++++++++++++++++++++++++-----------------------------
1 files changed, 231 insertions(+), 236 deletions(-)
Index: llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
diff -u llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp:1.4 llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp:1.5
--- llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp:1.4 Fri Sep 2 16:18:40 2005
+++ llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp Mon Sep 5 23:43:02 2005
@@ -26,10 +26,6 @@
// FIXME: make truncate see through SIGN_EXTEND and AND
// FIXME: sext_in_reg(setcc) on targets that return zero or one, and where
// EVT != MVT::i1 can drop the sext.
-// FIXME: (or x, c) -> c iff maskedValueIsZero(x, ~c)
-// FIXME: MaskedValueIsZero can see through SRL, so it should be sufficient to:
-//if (N1C && MaskedValueIsZero(SDOperand(N, 0), ~0ULL >> (64-OpSizeInBits),TLI))
-// return DAG.getConstant(0, VT).Val;
// FIXME: (sra (sra x, c1), c2) -> (sra x, c1+c2)
// FIXME: verify that getNode can't return extends with an operand whose type
// is >= to that of the extend.
@@ -75,7 +71,7 @@
/// visit - call the node-specific routine that knows how to fold each
/// particular type of node.
- SDNode *visit(SDNode *N);
+ SDOperand visit(SDNode *N);
// Visitation implementation - Implement dag node combining for different
// node types. The semantics are as follows:
@@ -83,41 +79,41 @@
// null - No change was made
// otherwise - Node N should be replaced by the returned node.
//
- SDNode *visitTokenFactor(SDNode *N);
- SDNode *visitADD(SDNode *N);
- SDNode *visitSUB(SDNode *N);
- SDNode *visitMUL(SDNode *N);
- SDNode *visitSDIV(SDNode *N);
- SDNode *visitUDIV(SDNode *N);
- SDNode *visitSREM(SDNode *N);
- SDNode *visitUREM(SDNode *N);
- SDNode *visitMULHU(SDNode *N);
- SDNode *visitMULHS(SDNode *N);
- SDNode *visitAND(SDNode *N);
- SDNode *visitOR(SDNode *N);
- SDNode *visitXOR(SDNode *N);
- SDNode *visitSHL(SDNode *N);
- SDNode *visitSRA(SDNode *N);
- SDNode *visitSRL(SDNode *N);
- SDNode *visitCTLZ(SDNode *N);
- SDNode *visitCTTZ(SDNode *N);
- SDNode *visitCTPOP(SDNode *N);
+ SDOperand visitTokenFactor(SDNode *N);
+ SDOperand visitADD(SDNode *N);
+ SDOperand visitSUB(SDNode *N);
+ SDOperand visitMUL(SDNode *N);
+ SDOperand visitSDIV(SDNode *N);
+ SDOperand visitUDIV(SDNode *N);
+ SDOperand visitSREM(SDNode *N);
+ SDOperand visitUREM(SDNode *N);
+ SDOperand visitMULHU(SDNode *N);
+ SDOperand visitMULHS(SDNode *N);
+ SDOperand visitAND(SDNode *N);
+ SDOperand visitOR(SDNode *N);
+ SDOperand visitXOR(SDNode *N);
+ SDOperand visitSHL(SDNode *N);
+ SDOperand visitSRA(SDNode *N);
+ SDOperand visitSRL(SDNode *N);
+ SDOperand visitCTLZ(SDNode *N);
+ SDOperand visitCTTZ(SDNode *N);
+ SDOperand visitCTPOP(SDNode *N);
// select
// select_cc
// setcc
- SDNode *visitSIGN_EXTEND(SDNode *N);
- SDNode *visitZERO_EXTEND(SDNode *N);
- SDNode *visitSIGN_EXTEND_INREG(SDNode *N);
- SDNode *visitTRUNCATE(SDNode *N);
- SDNode *visitSINT_TO_FP(SDNode *N);
- SDNode *visitUINT_TO_FP(SDNode *N);
- SDNode *visitFP_TO_SINT(SDNode *N);
- SDNode *visitFP_TO_UINT(SDNode *N);
- SDNode *visitFP_ROUND(SDNode *N);
- SDNode *visitFP_ROUND_INREG(SDNode *N);
- SDNode *visitFP_EXTEND(SDNode *N);
- SDNode *visitFNEG(SDNode *N);
- SDNode *visitFABS(SDNode *N);
+ SDOperand visitSIGN_EXTEND(SDNode *N);
+ SDOperand visitZERO_EXTEND(SDNode *N);
+ SDOperand visitSIGN_EXTEND_INREG(SDNode *N);
+ SDOperand visitTRUNCATE(SDNode *N);
+ SDOperand visitSINT_TO_FP(SDNode *N);
+ SDOperand visitUINT_TO_FP(SDNode *N);
+ SDOperand visitFP_TO_SINT(SDNode *N);
+ SDOperand visitFP_TO_UINT(SDNode *N);
+ SDOperand visitFP_ROUND(SDNode *N);
+ SDOperand visitFP_ROUND_INREG(SDNode *N);
+ SDOperand visitFP_EXTEND(SDNode *N);
+ SDOperand visitFNEG(SDNode *N);
+ SDOperand visitFABS(SDNode *N);
// brcond
// brcondtwoway
// br_cc
@@ -242,7 +238,7 @@
// Add all the dag nodes to the worklist.
WorkList.insert(WorkList.end(), DAG.allnodes_begin(), DAG.allnodes_end());
-
+
// while the worklist isn't empty, inspect the node on the end of it and
// try and combine it.
while (!WorkList.empty()) {
@@ -251,7 +247,9 @@
// If N has no uses, it is dead. Make sure to revisit all N's operands once
// N is deleted from the DAG, since they too may now be dead.
- if (N->use_empty()) {
+ // FIXME: is there a better way to keep from deleting the dag root because
+ // we think it has no uses? This works for now...
+ if (N->use_empty() && N != DAG.getRoot().Val) {
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
WorkList.push_back(N->getOperand(i).Val);
@@ -260,18 +258,22 @@
continue;
}
- if (SDNode *Result = visit(N)) {
+ SDOperand RV = visit(N);
+ if (RV.Val) {
++NodesCombined;
// If we get back the same node we passed in, rather than a new node or
// zero, we know that the node must have defined multiple values and
// CombineTo was used. Since CombineTo takes care of the worklist
// mechanics for us, we have no work to do in this case.
- if (Result != N) {
- DAG.ReplaceAllUsesWith(N, Result);
+ if (RV.Val != N) {
+ std::cerr << "\nReplacing "; N->dump();
+ std::cerr << "\nWith: "; RV.Val->dump();
+ std::cerr << '\n';
+ DAG.ReplaceAllUsesWith(SDOperand(N, 0), RV);
// Push the new node and any users onto the worklist
- WorkList.push_back(Result);
- AddUsersToWorkList(Result);
+ WorkList.push_back(RV.Val);
+ AddUsersToWorkList(RV.Val);
// Nodes can end up on the worklist more than once. Make sure we do
// not process a node that has been replaced.
@@ -281,7 +283,7 @@
}
}
-SDNode *DAGCombiner::visit(SDNode *N) {
+SDOperand DAGCombiner::visit(SDNode *N) {
switch(N->getOpcode()) {
default: break;
case ISD::TokenFactor: return visitTokenFactor(N);
@@ -317,26 +319,22 @@
case ISD::FNEG: return visitFNEG(N);
case ISD::FABS: return visitFABS(N);
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitTokenFactor(SDNode *N) {
- // If the token factor only has one operand, fold TF(x) -> x
- if (N->getNumOperands() == 1)
- return N->getOperand(0).Val;
-
+SDOperand DAGCombiner::visitTokenFactor(SDNode *N) {
// If the token factor has two operands and one is the entry token, replace
// the token factor with the other operand.
if (N->getNumOperands() == 2) {
if (N->getOperand(0).getOpcode() == ISD::EntryToken)
- return N->getOperand(1).Val;
+ return N->getOperand(1);
if (N->getOperand(1).getOpcode() == ISD::EntryToken)
- return N->getOperand(0).Val;
+ return N->getOperand(0);
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitADD(SDNode *N) {
+SDOperand DAGCombiner::visitADD(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -347,36 +345,36 @@
// fold (add c1, c2) -> c1+c2
if (N0C && N1C)
return DAG.getConstant(N0C->getValue() + N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (add x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// fold floating point (add c1, c2) -> c1+c2
if (N0CFP && N1CFP)
return DAG.getConstantFP(N0CFP->getValue() + N1CFP->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (A + (-B)) -> A-B
if (N1.getOpcode() == ISD::FNEG)
- return DAG.getNode(ISD::SUB, N->getValueType(0), N0, N1.getOperand(0)).Val;
+ return DAG.getNode(ISD::SUB, N->getValueType(0), N0, N1.getOperand(0));
// fold ((-A) + B) -> B-A
if (N0.getOpcode() == ISD::FNEG)
- return DAG.getNode(ISD::SUB, N->getValueType(0), N1, N0.getOperand(0)).Val;
+ return DAG.getNode(ISD::SUB, N->getValueType(0), N1, N0.getOperand(0));
// fold ((0-A) + B) -> B-A
if (N0.getOpcode() == ISD::SUB && isa<ConstantSDNode>(N0.getOperand(0)) &&
cast<ConstantSDNode>(N0.getOperand(0))->isNullValue())
- return DAG.getNode(ISD::SUB, N->getValueType(0), N1, N0.getOperand(1)).Val;
+ return DAG.getNode(ISD::SUB, N->getValueType(0), N1, N0.getOperand(1));
// fold (A + (0-B)) -> A-B
if (N1.getOpcode() == ISD::SUB && isa<ConstantSDNode>(N1.getOperand(0)) &&
cast<ConstantSDNode>(N1.getOperand(0))->isNullValue())
- return DAG.getNode(ISD::SUB, N->getValueType(0), N0, N1.getOperand(1)).Val;
+ return DAG.getNode(ISD::SUB, N->getValueType(0), N0, N1.getOperand(1));
// fold (A+(B-A)) -> B for non-fp types
if (N1.getOpcode() == ISD::SUB && N0 == N1.getOperand(1) &&
!MVT::isFloatingPoint(N1.getValueType()))
- return N1.getOperand(0).Val;
- return 0;
+ return N1.getOperand(0);
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSUB(SDNode *N) {
+SDOperand DAGCombiner::visitSUB(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.Val);
@@ -387,29 +385,29 @@
// fold (sub c1, c2) -> c1-c2
if (N0C && N1C)
return DAG.getConstant(N0C->getValue() - N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (sub x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// fold floating point (sub c1, c2) -> c1-c2
if (N0CFP && N1CFP)
return DAG.getConstantFP(N0CFP->getValue() - N1CFP->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (A+B)-A -> B
if (N0.getOpcode() == ISD::ADD && N0.getOperand(0) == N1 &&
!MVT::isFloatingPoint(N1.getValueType()))
- return N0.getOperand(1).Val;
+ return N0.getOperand(1);
// fold (A+B)-B -> A
if (N0.getOpcode() == ISD::ADD && N0.getOperand(1) == N1 &&
!MVT::isFloatingPoint(N1.getValueType()))
- return N0.getOperand(0).Val;
+ return N0.getOperand(0);
// fold (A-(-B)) -> A+B
if (N1.getOpcode() == ISD::FNEG)
- return DAG.getNode(ISD::ADD, N0.getValueType(), N0, N1.getOperand(0)).Val;
- return 0;
+ return DAG.getNode(ISD::ADD, N0.getValueType(), N0, N1.getOperand(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitMUL(SDNode *N) {
+SDOperand DAGCombiner::visitMUL(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -420,27 +418,27 @@
// fold (mul c1, c2) -> c1*c2
if (N0C && N1C)
return DAG.getConstant(N0C->getValue() * N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (mul x, 0) -> 0
if (N1C && N1C->isNullValue())
- return N1.Val;
+ return N1;
// fold (mul x, -1) -> 0-x
if (N1C && N1C->isAllOnesValue())
return DAG.getNode(ISD::SUB, N->getValueType(0),
- DAG.getConstant(0, N->getValueType(0)), N0).Val;
+ DAG.getConstant(0, N->getValueType(0)), N0);
// fold (mul x, (1 << c)) -> x << c
if (N1C && isPowerOf2_64(N1C->getValue()))
return DAG.getNode(ISD::SHL, N->getValueType(0), N0,
DAG.getConstant(Log2_64(N1C->getValue()),
- TLI.getShiftAmountTy())).Val;
+ TLI.getShiftAmountTy()));
// fold floating point (mul c1, c2) -> c1*c2
if (N0CFP && N1CFP)
return DAG.getConstantFP(N0CFP->getValue() * N1CFP->getValue(),
- N->getValueType(0)).Val;
- return 0;
+ N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSDIV(SDNode *N) {
+SDOperand DAGCombiner::visitSDIV(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.Val);
@@ -451,15 +449,15 @@
// fold (sdiv c1, c2) -> c1/c2
if (N0C && N1C && !N1C->isNullValue())
return DAG.getConstant(N0C->getSignExtended() / N1C->getSignExtended(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold floating point (sdiv c1, c2) -> c1/c2
if (N0CFP && N1CFP)
return DAG.getConstantFP(N0CFP->getValue() / N1CFP->getValue(),
- N->getValueType(0)).Val;
- return 0;
+ N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitUDIV(SDNode *N) {
+SDOperand DAGCombiner::visitUDIV(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.Val);
@@ -468,16 +466,16 @@
// fold (udiv c1, c2) -> c1/c2
if (N0C && N1C && !N1C->isNullValue())
return DAG.getConstant(N0C->getValue() / N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (udiv x, (1 << c)) -> x >>u c
if (N1C && isPowerOf2_64(N1C->getValue()))
return DAG.getNode(ISD::SRL, N->getValueType(0), N0,
DAG.getConstant(Log2_64(N1C->getValue()),
- TLI.getShiftAmountTy())).Val;
- return 0;
+ TLI.getShiftAmountTy()));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSREM(SDNode *N) {
+SDOperand DAGCombiner::visitSREM(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -488,15 +486,15 @@
// fold (srem c1, c2) -> c1%c2
if (N0C && N1C && !N1C->isNullValue())
return DAG.getConstant(N0C->getSignExtended() % N1C->getSignExtended(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold floating point (srem c1, c2) -> fmod(c1, c2)
if (N0CFP && N1CFP)
return DAG.getConstantFP(fmod(N0CFP->getValue(),N1CFP->getValue()),
- N->getValueType(0)).Val;
- return 0;
+ N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitUREM(SDNode *N) {
+SDOperand DAGCombiner::visitUREM(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -505,101 +503,103 @@
// fold (urem c1, c2) -> c1%c2
if (N0C && N1C && !N1C->isNullValue())
return DAG.getConstant(N0C->getValue() % N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// FIXME: c2 power of 2 -> mask?
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitMULHS(SDNode *N) {
+SDOperand DAGCombiner::visitMULHS(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
// fold (mulhs x, 0) -> 0
if (N1C && N1C->isNullValue())
- return N1.Val;
-
+ return N1;
// fold (mulhs x, 1) -> (sra x, size(x)-1)
if (N1C && N1C->getValue() == 1)
return DAG.getNode(ISD::SRA, N0.getValueType(), N0,
DAG.getConstant(MVT::getSizeInBits(N0.getValueType())-1,
- TLI.getShiftAmountTy())).Val;
- return 0;
+ TLI.getShiftAmountTy()));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitMULHU(SDNode *N) {
+SDOperand DAGCombiner::visitMULHU(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
// fold (mulhu x, 0) -> 0
if (N1C && N1C->isNullValue())
- return N1.Val;
-
+ return N1;
// fold (mulhu x, 1) -> 0
if (N1C && N1C->getValue() == 1)
- return DAG.getConstant(0, N0.getValueType()).Val;
- return 0;
+ return DAG.getConstant(0, N0.getValueType());
+ return SDOperand();
}
-SDNode *DAGCombiner::visitAND(SDNode *N) {
+SDOperand DAGCombiner::visitAND(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
MVT::ValueType VT = N1.getValueType();
+ unsigned OpSizeInBits = MVT::getSizeInBits(VT);
// fold (and c1, c2) -> c1&c2
if (N0C && N1C)
- return DAG.getConstant(N0C->getValue() & N1C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue() & N1C->getValue(), VT);
// fold (and x, -1) -> x
if (N1C && N1C->isAllOnesValue())
- return N0.Val;
- // fold (and x, 0) -> 0
- if (N1C && MaskedValueIsZero(N0, N1C->getValue(), TLI))
- return DAG.getConstant(0, VT).Val;
- // fold (and x, mask containing x) -> x
- if (N1C) {
- uint64_t NotC2 = ~N1C->getValue();
- NotC2 &= ~0ULL >> (64-MVT::getSizeInBits(VT));
- if (MaskedValueIsZero(N0, NotC2, TLI))
- return N0.Val;
- }
+ return N0;
+ // if (and x, c) is known to be zero, return 0
+ if (N1C && MaskedValueIsZero(SDOperand(N, 0), ~0ULL >> (64-OpSizeInBits),TLI))
+ return DAG.getConstant(0, VT);
+ // fold (and x, c) -> x iff (x & ~c) == 0
+ if (N1C && MaskedValueIsZero(N0,~N1C->getValue() & (~0ULL>>(64-OpSizeInBits)),
+ TLI))
+ return N0;
// fold (and (sign_extend_inreg x, i16 to i32), 1) -> (and x, 1)
if (N0.getOpcode() == ISD::SIGN_EXTEND_INREG) {
unsigned ExtendBits =
MVT::getSizeInBits(cast<VTSDNode>(N0.getOperand(1))->getVT());
if ((N1C->getValue() & (~0ULL << ExtendBits)) == 0)
- return DAG.getNode(ISD::AND, VT, N0.getOperand(0), N1).Val;
+ return DAG.getNode(ISD::AND, VT, N0.getOperand(0), N1);
}
// fold (and (or x, 0xFFFF), 0xFF) -> 0xFF
if (N0.getOpcode() == ISD::OR)
if (ConstantSDNode *ORI = dyn_cast<ConstantSDNode>(N0.getOperand(1)))
if ((ORI->getValue() & N1C->getValue()) == N1C->getValue())
- return N1.Val;
- return 0;
+ return N1;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitOR(SDNode *N) {
+SDOperand DAGCombiner::visitOR(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
+ MVT::ValueType VT = N1.getValueType();
+ unsigned OpSizeInBits = MVT::getSizeInBits(VT);
// fold (or c1, c2) -> c1|c2
if (N0C && N1C)
return DAG.getConstant(N0C->getValue() | N1C->getValue(),
- N->getValueType(0)).Val;
+ N->getValueType(0));
// fold (or x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// fold (or x, -1) -> -1
if (N1C && N1C->isAllOnesValue())
- return N1.Val;
- return 0;
+ return N1;
+ // fold (or x, c) -> c iff (x & ~c) == 0
+ if (N1C && MaskedValueIsZero(N0,~N1C->getValue() & (~0ULL>>(64-OpSizeInBits)),
+ TLI))
+ return N1;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitXOR(SDNode *N) {
+SDOperand DAGCombiner::visitXOR(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
SDOperand LHS, RHS, CC;
@@ -609,20 +609,19 @@
// fold (xor c1, c2) -> c1^c2
if (N0C && N1C)
- return DAG.getConstant(N0C->getValue() ^ N1C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue() ^ N1C->getValue(), VT);
// fold (xor x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// fold !(x cc y) -> (x !cc y)
if (N1C && N1C->getValue() == 1 && isSetCCEquivalent(N0, LHS, RHS, CC)) {
bool isInt = MVT::isInteger(LHS.getValueType());
ISD::CondCode NotCC = ISD::getSetCCInverse(cast<CondCodeSDNode>(CC)->get(),
isInt);
if (N0.getOpcode() == ISD::SETCC)
- return DAG.getSetCC(VT, LHS, RHS, NotCC).Val;
+ return DAG.getSetCC(VT, LHS, RHS, NotCC);
if (N0.getOpcode() == ISD::SELECT_CC)
- return DAG.getSelectCC(LHS, RHS, N0.getOperand(2), N0.getOperand(3),
- NotCC).Val;
+ return DAG.getSelectCC(LHS, RHS, N0.getOperand(2),N0.getOperand(3),NotCC);
assert(0 && "Unhandled SetCC Equivalent!");
abort();
}
@@ -632,7 +631,7 @@
if (isInvertibleForFree(RHS) || isInvertibleForFree(LHS)) {
LHS = DAG.getNode(ISD::XOR, VT, LHS, N1); // RHS = ~LHS
RHS = DAG.getNode(ISD::XOR, VT, RHS, N1); // RHS = ~RHS
- return DAG.getNode(ISD::AND, VT, LHS, RHS).Val;
+ return DAG.getNode(ISD::AND, VT, LHS, RHS);
}
}
// fold !(x and y) -> (!x or !y) iff x or y are freely invertible
@@ -641,13 +640,13 @@
if (isInvertibleForFree(RHS) || isInvertibleForFree(LHS)) {
LHS = DAG.getNode(ISD::XOR, VT, LHS, N1); // RHS = ~LHS
RHS = DAG.getNode(ISD::XOR, VT, RHS, N1); // RHS = ~RHS
- return DAG.getNode(ISD::OR, VT, LHS, RHS).Val;
+ return DAG.getNode(ISD::OR, VT, LHS, RHS);
}
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSHL(SDNode *N) {
+SDOperand DAGCombiner::visitSHL(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -657,29 +656,28 @@
// fold (shl c1, c2) -> c1<<c2
if (N0C && N1C)
- return DAG.getConstant(N0C->getValue() << N1C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue() << N1C->getValue(), VT);
// fold (shl 0, x) -> 0
if (N0C && N0C->isNullValue())
- return N0.Val;
+ return N0;
// fold (shl x, c >= size(x)) -> undef
if (N1C && N1C->getValue() >= OpSizeInBits)
- return DAG.getNode(ISD::UNDEF, VT).Val;
+ return DAG.getNode(ISD::UNDEF, VT);
// fold (shl x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// if (shl x, c) is known to be zero, return 0
- if (N1C && MaskedValueIsZero(N0,(~0ULL >> (64-OpSizeInBits))>>N1C->getValue(),
- TLI))
- return DAG.getConstant(0, VT).Val;
+ if (N1C && MaskedValueIsZero(SDOperand(N, 0), ~0ULL >> (64-OpSizeInBits),TLI))
+ return DAG.getConstant(0, VT);
// fold (shl (shl x, c1), c2) -> 0 or (shl x, c1+c2)
if (N1C && N0.getOpcode() == ISD::SHL &&
N0.getOperand(1).getOpcode() == ISD::Constant) {
uint64_t c1 = cast<ConstantSDNode>(N0.getOperand(1))->getValue();
uint64_t c2 = N1C->getValue();
if (c1 + c2 > OpSizeInBits)
- return DAG.getConstant(0, VT).Val;
+ return DAG.getConstant(0, VT);
return DAG.getNode(ISD::SHL, VT, N0.getOperand(0),
- DAG.getConstant(c1 + c2, N1.getValueType())).Val;
+ DAG.getConstant(c1 + c2, N1.getValueType()));
}
// fold (shl (srl x, c1), c2) -> (shl (and x, -1 << c1), c2-c1) or
// (srl (and x, -1 << c1), c1-c2)
@@ -691,19 +689,19 @@
DAG.getConstant(~0ULL << c1, VT));
if (c2 > c1)
return DAG.getNode(ISD::SHL, VT, Mask,
- DAG.getConstant(c2-c1, N1.getValueType())).Val;
+ DAG.getConstant(c2-c1, N1.getValueType()));
else
- return DAG.getNode(ISD::SRL, VT, Mask,
- DAG.getConstant(c1-c2, N1.getValueType())).Val;
+ return DAG.getNode(ISD::SRL, VT, Mask,
+ DAG.getConstant(c1-c2, N1.getValueType()));
}
// fold (shl (sra x, c1), c1) -> (and x, -1 << c1)
if (N1C && N0.getOpcode() == ISD::SRA && N1 == N0.getOperand(1))
return DAG.getNode(ISD::AND, VT, N0.getOperand(0),
- DAG.getConstant(~0ULL << N1C->getValue(), VT)).Val;
- return 0;
+ DAG.getConstant(~0ULL << N1C->getValue(), VT));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSRA(SDNode *N) {
+SDOperand DAGCombiner::visitSRA(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -713,26 +711,26 @@
// fold (sra c1, c2) -> c1>>c2
if (N0C && N1C)
- return DAG.getConstant(N0C->getSignExtended() >> N1C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getSignExtended() >> N1C->getValue(), VT);
// fold (sra 0, x) -> 0
if (N0C && N0C->isNullValue())
- return N0.Val;
+ return N0;
// fold (sra -1, x) -> -1
if (N0C && N0C->isAllOnesValue())
- return N0.Val;
+ return N0;
// fold (sra x, c >= size(x)) -> undef
if (N1C && N1C->getValue() >= OpSizeInBits)
- return DAG.getNode(ISD::UNDEF, VT).Val;
+ return DAG.getNode(ISD::UNDEF, VT);
// fold (sra x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// If the sign bit is known to be zero, switch this to a SRL.
if (N1C && MaskedValueIsZero(N0, (1ULL << (OpSizeInBits-1)), TLI))
- return DAG.getNode(ISD::SRL, VT, N0, N1).Val;
- return 0;
+ return DAG.getNode(ISD::SRL, VT, N0, N1);
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSRL(SDNode *N) {
+SDOperand DAGCombiner::visitSRL(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
@@ -742,95 +740,94 @@
// fold (srl c1, c2) -> c1 >>u c2
if (N0C && N1C)
- return DAG.getConstant(N0C->getValue() >> N1C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue() >> N1C->getValue(), VT);
// fold (srl 0, x) -> 0
if (N0C && N0C->isNullValue())
- return N0.Val;
+ return N0;
// fold (srl x, c >= size(x)) -> undef
if (N1C && N1C->getValue() >= OpSizeInBits)
- return DAG.getNode(ISD::UNDEF, VT).Val;
+ return DAG.getNode(ISD::UNDEF, VT);
// fold (srl x, 0) -> x
if (N1C && N1C->isNullValue())
- return N0.Val;
+ return N0;
// if (srl x, c) is known to be zero, return 0
- if (N1C && MaskedValueIsZero(N0,(~0ULL >> (64-OpSizeInBits))<<N1C->getValue(),
- TLI))
- return DAG.getConstant(0, VT).Val;
+ if (N1C && MaskedValueIsZero(SDOperand(N, 0), ~0ULL >> (64-OpSizeInBits),TLI))
+ return DAG.getConstant(0, VT);
// fold (srl (srl x, c1), c2) -> 0 or (srl x, c1+c2)
if (N1C && N0.getOpcode() == ISD::SRL &&
N0.getOperand(1).getOpcode() == ISD::Constant) {
uint64_t c1 = cast<ConstantSDNode>(N0.getOperand(1))->getValue();
uint64_t c2 = N1C->getValue();
if (c1 + c2 > OpSizeInBits)
- return DAG.getConstant(0, VT).Val;
+ return DAG.getConstant(0, VT);
return DAG.getNode(ISD::SRL, VT, N0.getOperand(0),
- DAG.getConstant(c1 + c2, N1.getValueType())).Val;
+ DAG.getConstant(c1 + c2, N1.getValueType()));
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitCTLZ(SDNode *N) {
+SDOperand DAGCombiner::visitCTLZ(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
// fold (ctlz c1) -> c2
if (N0C)
return DAG.getConstant(CountLeadingZeros_64(N0C->getValue()),
- N0.getValueType()).Val;
- return 0;
+ N0.getValueType());
+ return SDOperand();
}
-SDNode *DAGCombiner::visitCTTZ(SDNode *N) {
+SDOperand DAGCombiner::visitCTTZ(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
// fold (cttz c1) -> c2
if (N0C)
return DAG.getConstant(CountTrailingZeros_64(N0C->getValue()),
- N0.getValueType()).Val;
- return 0;
+ N0.getValueType());
+ return SDOperand();
}
-SDNode *DAGCombiner::visitCTPOP(SDNode *N) {
+SDOperand DAGCombiner::visitCTPOP(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
// fold (ctpop c1) -> c2
if (N0C)
return DAG.getConstant(CountPopulation_64(N0C->getValue()),
- N0.getValueType()).Val;
- return 0;
+ N0.getValueType());
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSIGN_EXTEND(SDNode *N) {
+SDOperand DAGCombiner::visitSIGN_EXTEND(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
MVT::ValueType VT = N->getValueType(0);
// fold (sext c1) -> c1
if (N0C)
- return DAG.getConstant(N0C->getSignExtended(), VT).Val;
+ return DAG.getConstant(N0C->getSignExtended(), VT);
// fold (sext (sext x)) -> (sext x)
if (N0.getOpcode() == ISD::SIGN_EXTEND)
- return DAG.getNode(ISD::SIGN_EXTEND, VT, N0.getOperand(0)).Val;
- return 0;
+ return DAG.getNode(ISD::SIGN_EXTEND, VT, N0.getOperand(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitZERO_EXTEND(SDNode *N) {
+SDOperand DAGCombiner::visitZERO_EXTEND(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
MVT::ValueType VT = N->getValueType(0);
// fold (zext c1) -> c1
if (N0C)
- return DAG.getConstant(N0C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue(), VT);
// fold (zext (zext x)) -> (zext x)
if (N0.getOpcode() == ISD::ZERO_EXTEND)
- return DAG.getNode(ISD::ZERO_EXTEND, VT, N0.getOperand(0)).Val;
- return 0;
+ return DAG.getNode(ISD::ZERO_EXTEND, VT, N0.getOperand(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSIGN_EXTEND_INREG(SDNode *N) {
+SDOperand DAGCombiner::visitSIGN_EXTEND_INREG(SDNode *N) {
SDOperand N0 = N->getOperand(0);
SDOperand N1 = N->getOperand(1);
SDOperand LHS, RHS, CC;
@@ -841,34 +838,34 @@
// fold (sext_in_reg c1) -> c1
if (N0C) {
SDOperand Truncate = DAG.getConstant(N0C->getValue(), EVT);
- return DAG.getNode(ISD::SIGN_EXTEND, VT, Truncate).Val;
+ return DAG.getNode(ISD::SIGN_EXTEND, VT, Truncate);
}
// fold (sext_in_reg (sext_in_reg x, VT2), VT1) -> (sext_in_reg x, minVT) pt1
if (N0.getOpcode() == ISD::SIGN_EXTEND_INREG &&
cast<VTSDNode>(N0.getOperand(1))->getVT() < EVT) {
- return N0.Val;
+ return N0;
}
// fold (sext_in_reg (sext_in_reg x, VT2), VT1) -> (sext_in_reg x, minVT) pt2
if (N0.getOpcode() == ISD::SIGN_EXTEND_INREG &&
EVT < cast<VTSDNode>(N0.getOperand(1))->getVT()) {
- return DAG.getNode(ISD::SIGN_EXTEND_INREG, VT, N0.getOperand(0), N1).Val;
+ return DAG.getNode(ISD::SIGN_EXTEND_INREG, VT, N0.getOperand(0), N1);
}
// fold (sext_in_reg (assert_sext x)) -> (assert_sext x)
if (N0.getOpcode() == ISD::AssertSext &&
cast<VTSDNode>(N0.getOperand(1))->getVT() <= EVT) {
- return N0.Val;
+ return N0;
}
// fold (sext_in_reg (sextload x)) -> (sextload x)
if (N0.getOpcode() == ISD::SEXTLOAD &&
cast<VTSDNode>(N0.getOperand(3))->getVT() <= EVT) {
- return N0.Val;
+ return N0;
}
// fold (sext_in_reg (setcc x)) -> setcc x iff (setcc x) == 0 or -1
// FIXME: teach isSetCCEquivalent about 0, -1 and then use it here
if (N0.getOpcode() == ISD::SETCC &&
TLI.getSetCCResultContents() ==
TargetLowering::ZeroOrNegativeOneSetCCResult)
- return N0.Val;
+ return N0;
// FIXME: this code is currently just ported over from SelectionDAG.cpp
// we probably actually want to handle this in two pieces. Rather than
// checking all the top bits for zero, just check the sign bit here and turn
@@ -880,91 +877,89 @@
uint64_t Mask = cast<ConstantSDNode>(N0.getOperand(1))->getValue();
unsigned NumBits = MVT::getSizeInBits(EVT);
if ((Mask & (~0ULL << (NumBits-1))) == 0)
- return N0.Val;
+ return N0;
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitTRUNCATE(SDNode *N) {
+SDOperand DAGCombiner::visitTRUNCATE(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
MVT::ValueType VT = N->getValueType(0);
// noop truncate
if (N0.getValueType() == N->getValueType(0))
- return N0.Val;
+ return N0;
// fold (truncate c1) -> c1
if (N0C)
- return DAG.getConstant(N0C->getValue(), VT).Val;
+ return DAG.getConstant(N0C->getValue(), VT);
// fold (truncate (truncate x)) -> (truncate x)
if (N0.getOpcode() == ISD::TRUNCATE)
- return DAG.getNode(ISD::TRUNCATE, VT, N0.getOperand(0)).Val;
+ return DAG.getNode(ISD::TRUNCATE, VT, N0.getOperand(0));
// fold (truncate (ext x)) -> (ext x) or (truncate x) or x
if (N0.getOpcode() == ISD::ZERO_EXTEND || N0.getOpcode() == ISD::SIGN_EXTEND){
if (N0.getValueType() < VT)
// if the source is smaller than the dest, we still need an extend
- return DAG.getNode(N0.getOpcode(), VT, N0.getOperand(0)).Val;
+ return DAG.getNode(N0.getOpcode(), VT, N0.getOperand(0));
else if (N0.getValueType() > VT)
// if the source is larger than the dest, than we just need the truncate
- return DAG.getNode(ISD::TRUNCATE, VT, N0.getOperand(0)).Val;
+ return DAG.getNode(ISD::TRUNCATE, VT, N0.getOperand(0));
else
// if the source and dest are the same type, we can drop both the extend
// and the truncate
- return N0.getOperand(0).Val;
+ return N0.getOperand(0);
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitSINT_TO_FP(SDNode *N) {
+SDOperand DAGCombiner::visitSINT_TO_FP(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
- MVT::ValueType VT = N->getValueType(0);
// fold (sint_to_fp c1) -> c1fp
if (N0C)
- return DAG.getConstantFP(N0C->getSignExtended(), VT).Val;
- return 0;
+ return DAG.getConstantFP(N0C->getSignExtended(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitUINT_TO_FP(SDNode *N) {
+SDOperand DAGCombiner::visitUINT_TO_FP(SDNode *N) {
SDOperand N0 = N->getOperand(0);
ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0);
- MVT::ValueType VT = N->getValueType(0);
// fold (uint_to_fp c1) -> c1fp
if (N0C)
- return DAG.getConstantFP(N0C->getValue(), VT).Val;
- return 0;
+ return DAG.getConstantFP(N0C->getValue(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFP_TO_SINT(SDNode *N) {
+SDOperand DAGCombiner::visitFP_TO_SINT(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (fp_to_sint c1fp) -> c1
if (N0CFP)
- return DAG.getConstant((int64_t)N0CFP->getValue(), N->getValueType(0)).Val;
- return 0;
+ return DAG.getConstant((int64_t)N0CFP->getValue(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFP_TO_UINT(SDNode *N) {
+SDOperand DAGCombiner::visitFP_TO_UINT(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (fp_to_uint c1fp) -> c1
if (N0CFP)
- return DAG.getConstant((uint64_t)N0CFP->getValue(), N->getValueType(0)).Val;
- return 0;
+ return DAG.getConstant((uint64_t)N0CFP->getValue(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFP_ROUND(SDNode *N) {
+SDOperand DAGCombiner::visitFP_ROUND(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (fp_round c1fp) -> c1fp
if (N0CFP)
- return DAG.getConstantFP(N0CFP->getValue(), N->getValueType(0)).Val;
- return 0;
+ return DAG.getConstantFP(N0CFP->getValue(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFP_ROUND_INREG(SDNode *N) {
+SDOperand DAGCombiner::visitFP_ROUND_INREG(SDNode *N) {
SDOperand N0 = N->getOperand(0);
MVT::ValueType VT = N->getValueType(0);
MVT::ValueType EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
@@ -972,52 +967,52 @@
// noop fp_round_inreg
if (EVT == VT)
- return N0.Val;
+ return N0;
// fold (fp_round_inreg c1fp) -> c1fp
if (N0CFP) {
SDOperand Round = DAG.getConstantFP(N0CFP->getValue(), EVT);
- return DAG.getNode(ISD::FP_EXTEND, VT, Round).Val;
+ return DAG.getNode(ISD::FP_EXTEND, VT, Round);
}
- return 0;
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFP_EXTEND(SDNode *N) {
+SDOperand DAGCombiner::visitFP_EXTEND(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (fp_extend c1fp) -> c1fp
if (N0CFP)
- return DAG.getConstantFP(N0CFP->getValue(), N->getValueType(0)).Val;
- return 0;
+ return DAG.getConstantFP(N0CFP->getValue(), N->getValueType(0));
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFNEG(SDNode *N) {
+SDOperand DAGCombiner::visitFNEG(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (neg c1) -> -c1
if (N0CFP)
- return DAG.getConstantFP(-N0CFP->getValue(), N->getValueType(0)).Val;
+ return DAG.getConstantFP(-N0CFP->getValue(), N->getValueType(0));
// fold (neg (sub x, y)) -> (sub y, x)
if (N->getOperand(0).getOpcode() == ISD::SUB)
return DAG.getNode(ISD::SUB, N->getValueType(0), N->getOperand(1),
- N->getOperand(0)).Val;
+ N->getOperand(0));
// fold (neg (neg x)) -> x
if (N->getOperand(0).getOpcode() == ISD::FNEG)
- return N->getOperand(0).getOperand(0).Val;
- return 0;
+ return N->getOperand(0).getOperand(0);
+ return SDOperand();
}
-SDNode *DAGCombiner::visitFABS(SDNode *N) {
+SDOperand DAGCombiner::visitFABS(SDNode *N) {
ConstantFPSDNode *N0CFP = dyn_cast<ConstantFPSDNode>(N->getOperand(0));
// fold (fabs c1) -> fabs(c1)
if (N0CFP)
- return DAG.getConstantFP(fabs(N0CFP->getValue()), N->getValueType(0)).Val;
+ return DAG.getConstantFP(fabs(N0CFP->getValue()), N->getValueType(0));
// fold (fabs (fabs x)) -> (fabs x)
if (N->getOperand(0).getOpcode() == ISD::FABS)
- return N->getOperand(0).Val;
+ return N->getOperand(0);
// fold (fabs (fneg x)) -> (fabs x)
if (N->getOperand(0).getOpcode() == ISD::FNEG)
return DAG.getNode(ISD::FABS, N->getValueType(0),
- N->getOperand(0).getOperand(0)).Val;
- return 0;
+ N->getOperand(0).getOperand(0));
+ return SDOperand();
}
// SelectionDAG::Combine - This is the entry point for the file.
More information about the llvm-commits
mailing list