diff options
| -rw-r--r-- | lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 511 |
1 files changed, 194 insertions, 317 deletions
diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index 0f455d431a..7a3c506f4e 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -326,30 +326,25 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case ISD::AssertSext: case ISD::AssertZext: Tmp1 = LegalizeOp(Node->getOperand(0)); - if (Tmp1 != Node->getOperand(0)) - Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1, - Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); break; case ISD::MERGE_VALUES: + // Legalize eliminates MERGE_VALUES nodes. Result = Node->getOperand(Op.ResNo); break; case ISD::CopyFromReg: Tmp1 = LegalizeOp(Node->getOperand(0)); Result = Op.getValue(0); if (Node->getNumValues() == 2) { - if (Tmp1 != Node->getOperand(0)) - Result = DAG.getCopyFromReg(Tmp1, - cast<RegisterSDNode>(Node->getOperand(1))->getReg(), - Node->getValueType(0)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); } else { assert(Node->getNumValues() == 3 && "Invalid copyfromreg!"); - if (Node->getNumOperands() == 3) + if (Node->getNumOperands() == 3) { Tmp2 = LegalizeOp(Node->getOperand(2)); - if (Tmp1 != Node->getOperand(0) || - (Node->getNumOperands() == 3 && Tmp2 != Node->getOperand(2))) - Result = DAG.getCopyFromReg(Tmp1, - cast<RegisterSDNode>(Node->getOperand(1))->getReg(), - Node->getValueType(0), Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1),Tmp2); + } else { + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); + } AddLegalizedOperand(Op.getValue(2), Result.getValue(2)); } // Since CopyFromReg produces two values, make sure to remember that we @@ -431,7 +426,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } Ops.push_back(Node->getOperand(3)); // filename must be legal. Ops.push_back(Node->getOperand(4)); // working dir # must be legal. - Result = DAG.getNode(ISD::LOCATION, MVT::Other, Ops); + Result = DAG.UpdateNodeOperands(Result, Ops); } break; } @@ -446,13 +441,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the line #. Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the col #. Tmp4 = LegalizeOp(Node->getOperand(3)); // Legalize the source file id. - - if (Tmp1 != Node->getOperand(0) || - Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2) || - Tmp4 != Node->getOperand(3)) { - Result = DAG.getNode(ISD::DEBUG_LOC,MVT::Other, Tmp1, Tmp2, Tmp3, Tmp4); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4); break; } break; @@ -464,11 +453,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case TargetLowering::Legal: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the label id. - - if (Tmp1 != Node->getOperand(0) || - Tmp2 != Node->getOperand(1)) { - Result = DAG.getNode(ISD::DEBUG_LABEL, MVT::Other, Tmp1, Tmp2); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); break; } break; @@ -554,22 +539,20 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } case ISD::TokenFactor: if (Node->getNumOperands() == 2) { - bool Changed = false; - SDOperand Op0 = LegalizeOp(Node->getOperand(0)); - SDOperand Op1 = LegalizeOp(Node->getOperand(1)); - if (Op0 != Node->getOperand(0) || Op1 != Node->getOperand(1)) - Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Op0, Op1); + Tmp1 = LegalizeOp(Node->getOperand(0)); + Tmp2 = LegalizeOp(Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); + } else if (Node->getNumOperands() == 3) { + Tmp1 = LegalizeOp(Node->getOperand(0)); + Tmp2 = LegalizeOp(Node->getOperand(1)); + Tmp3 = LegalizeOp(Node->getOperand(2)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); } else { std::vector<SDOperand> Ops; - bool Changed = false; // Legalize the operands. - for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) { - SDOperand Op = Node->getOperand(i); - Ops.push_back(LegalizeOp(Op)); - Changed |= Ops[i] != Op; - } - if (Changed) - Result = DAG.getNode(ISD::TokenFactor, MVT::Other, Ops); + for (unsigned i = 0, e = Node->getNumOperands(); i != e; ++i) + Ops.push_back(LegalizeOp(Node->getOperand(i))); + Result = DAG.UpdateNodeOperands(Result, Ops); } break; @@ -597,16 +580,9 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the size. Tmp3 = LegalizeOp(Node->getOperand(2)); // Legalize the alignment. - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2)) { - std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); - Result = DAG.getNode(ISD::DYNAMIC_STACKALLOC, VTs, Ops); - } else - Result = Op.getValue(0); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); - Tmp1 = Result; + Tmp1 = Result.getValue(0); Tmp2 = Result.getValue(1); switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { @@ -620,13 +596,15 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { SDOperand SP = DAG.getCopyFromReg(Chain, SPReg, Node->getValueType(0)); Tmp1 = DAG.getNode(ISD::SUB, Node->getValueType(0), SP, Size); // Value Tmp2 = DAG.getCopyToReg(SP.getValue(1), SPReg, Tmp1); // Output chain + Tmp1 = LegalizeOp(Tmp1); + Tmp2 = LegalizeOp(Tmp2); break; } case TargetLowering::Custom: Tmp3 = TLI.LowerOperation(Tmp1, DAG); if (Tmp3.Val) { - Tmp1 = Tmp3; - Tmp2 = Tmp3.getValue(1); + Tmp1 = LegalizeOp(Tmp3); + Tmp2 = LegalizeOp(Tmp3.getValue(1)); } break; case TargetLowering::Legal: @@ -634,14 +612,14 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } // Since this op produce two values, make sure to remember that we // legalized both of them. - AddLegalizedOperand(SDOperand(Node, 0), LegalizeOp(Tmp1)); - AddLegalizedOperand(SDOperand(Node, 1), LegalizeOp(Tmp2)); + AddLegalizedOperand(SDOperand(Node, 0), Tmp1); + AddLegalizedOperand(SDOperand(Node, 1), Tmp2); return Op.ResNo ? Tmp2 : Tmp1; } case ISD::INLINEASM: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize Chain. Tmp2 = Node->getOperand(Node->getNumOperands()-1); - if (Tmp2.getValueType() != MVT::Flag) // Legalize Flag if it exists. + if (Tmp2.getValueType() == MVT::Flag) // Legalize Flag if it exists. Tmp2 = Tmp3 = SDOperand(0, 0); else Tmp3 = LegalizeOp(Tmp2); @@ -649,21 +627,17 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { if (Tmp1 != Node->getOperand(0) || Tmp2 != Tmp3) { std::vector<SDOperand> Ops(Node->op_begin(), Node->op_end()); Ops[0] = Tmp1; - Ops.back() = Tmp3; - std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); - Result = DAG.getNode(ISD::INLINEASM, VTs, Ops); - } else { - Result = SDOperand(Node, 0); + if (Tmp3.Val) Ops.back() = Tmp3; + Result = DAG.UpdateNodeOperands(Result, Ops); } // INLINE asm returns a chain and flag, make sure to add both to the map. - AddLegalizedOperand(SDOperand(Node, 0), Result); + AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0)); AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); return Result.getValue(Op.ResNo); case ISD::BR: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. - if (Tmp1 != Node->getOperand(0)) - Result = DAG.getNode(ISD::BR, MVT::Other, Tmp1, Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); break; case ISD::BRCOND: @@ -680,9 +654,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } // Basic block destination (Op#2) is always legal. - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, - Node->getOperand(2)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); switch (TLI.getOperationAction(ISD::BRCOND, MVT::Other)) { default: assert(0 && "This action is not supported yet!"); @@ -738,11 +710,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp2 = LegalizeOp(Node->getOperand(2)); // LHS Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || - Tmp3 != Node->getOperand(3)) { - Result = DAG.getNode(ISD::BR_CC, MVT::Other, Tmp1, Node->getOperand(1), - Tmp2, Tmp3, Node->getOperand(4)); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1), Tmp2, + Tmp3, Node->getOperand(4)); switch (TLI.getOperationAction(ISD::BR_CC, Tmp3.getValueType())) { default: assert(0 && "Unexpected action for BR_CC!"); @@ -765,21 +734,14 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { break; } - // If this target does not support BRCONDTWOWAY, lower it to a BRCOND/BR // pair. switch (TLI.getOperationAction(ISD::BRCONDTWOWAY, MVT::Other)) { case TargetLowering::Promote: default: assert(0 && "This action is not supported yet!"); case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); - Ops.push_back(Tmp2); - Ops.push_back(Node->getOperand(2)); - Ops.push_back(Node->getOperand(3)); - Result = DAG.getNode(ISD::BRCONDTWOWAY, MVT::Other, Ops); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2), + Node->getOperand(3)); break; case TargetLowering::Expand: // If BRTWOWAY_CC is legal for this target, then simply expand this node @@ -810,8 +772,14 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp3 = LegalizeOp(Node->getOperand(3)); // RHS if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || Tmp3 != Node->getOperand(3)) { - Result = DAG.getBR2Way_CC(Tmp1, Node->getOperand(1), Tmp2, Tmp3, - Node->getOperand(4), Node->getOperand(5)); + std::vector<SDOperand> Ops; + Ops.push_back(Tmp1); + Ops.push_back(Node->getOperand(1)); + Ops.push_back(Tmp2); + Ops.push_back(Tmp3); + Ops.push_back(Node->getOperand(4)); + Ops.push_back(Node->getOperand(5)); + Result = DAG.UpdateNodeOperands(Result, Ops); } break; } else { @@ -823,21 +791,27 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { // pair. switch (TLI.getOperationAction(ISD::BRTWOWAY_CC, MVT::Other)) { default: assert(0 && "This action is not supported yet!"); - case TargetLowering::Legal: + case TargetLowering::Legal: { // If we get a SETCC back from legalizing the SETCC node we just // created, then use its LHS, RHS, and CC directly in creating a new // node. Otherwise, select between the true and false value based on // comparing the result of the legalized with zero. + std::vector<SDOperand> Ops; + Ops.push_back(Tmp1); if (Tmp2.getOpcode() == ISD::SETCC) { - Result = DAG.getBR2Way_CC(Tmp1, Tmp2.getOperand(2), - Tmp2.getOperand(0), Tmp2.getOperand(1), - Node->getOperand(4), Node->getOperand(5)); + Ops.push_back(Tmp2.getOperand(2)); + Ops.push_back(Tmp2.getOperand(0)); + Ops.push_back(Tmp2.getOperand(1)); } else { - Result = DAG.getBR2Way_CC(Tmp1, DAG.getCondCode(ISD::SETNE), Tmp2, - DAG.getConstant(0, Tmp2.getValueType()), - Node->getOperand(4), Node->getOperand(5)); + Ops.push_back(DAG.getCondCode(ISD::SETNE)); + Ops.push_back(Tmp2); + Ops.push_back(DAG.getConstant(0, Tmp2.getValueType())); } + Ops.push_back(Node->getOperand(4)); + Ops.push_back(Node->getOperand(5)); + Result = DAG.UpdateNodeOperands(Result, Ops); break; + } case TargetLowering::Expand: Result = DAG.getNode(ISD::BRCOND, MVT::Other, Tmp1, Tmp2, Node->getOperand(4)); @@ -851,31 +825,26 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. MVT::ValueType VT = Node->getValueType(0); - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getLoad(VT, Tmp1, Tmp2, Node->getOperand(2)); - else - Result = SDOperand(Node, 0); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); + Tmp2 = Result.getValue(0); + Tmp3 = Result.getValue(1); switch (TLI.getOperationAction(Node->getOpcode(), VT)) { default: assert(0 && "This action is not supported yet!"); + case TargetLowering::Legal: break; case TargetLowering::Custom: - Tmp1 = TLI.LowerOperation(Result, DAG); + Tmp1 = TLI.LowerOperation(Tmp2, DAG); if (Tmp1.Val) { - // Since loads produce two values, make sure to remember that we - // legalized both of them. - AddLegalizedOperand(SDOperand(Node, 0), LegalizeOp(Tmp1)); - AddLegalizedOperand(SDOperand(Node, 1), LegalizeOp(Tmp1.getValue(1))); - return Tmp1.getValue(Op.ResNo); + Tmp2 = LegalizeOp(Tmp1); + Tmp3 = LegalizeOp(Tmp1.getValue(1)); } - // FALLTHROUGH if the target thinks it is legal. - case TargetLowering::Legal: - // Since loads produce two values, make sure to remember that we legalized - // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); - AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Result.getValue(Op.ResNo); + break; } - assert(0 && "Unreachable"); + // Since loads produce two values, make sure to remember that we + // legalized both of them. + AddLegalizedOperand(SDOperand(Node, 0), Tmp2); + AddLegalizedOperand(SDOperand(Node, 1), Tmp3); + return Op.ResNo ? Tmp3 : Tmp2; } case ISD::EXTLOAD: case ISD::SEXTLOAD: @@ -888,48 +857,36 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { default: assert(0 && "This action is not supported yet!"); case TargetLowering::Promote: assert(SrcVT == MVT::i1 && "Can only promote EXTLOAD from i1 -> i8!"); - Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), - Tmp1, Tmp2, Node->getOperand(2), MVT::i8); - // Since loads produce two values, make sure to remember that we legalized - // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); - AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Result.getValue(Op.ResNo); - + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2), + DAG.getValueType(MVT::i8)); + Tmp1 = Result.getValue(0); + Tmp2 = Result.getValue(1); + break; case TargetLowering::Custom: isCustom = true; // FALLTHROUGH case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getExtLoad(Node->getOpcode(), Node->getValueType(0), - Tmp1, Tmp2, Node->getOperand(2), SrcVT); - else - Result = SDOperand(Node, 0); - Tmp1 = Result.getValue(1); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2), + Node->getOperand(3)); + Tmp1 = Result.getValue(0); + Tmp2 = Result.getValue(1); if (isCustom) { Tmp3 = TLI.LowerOperation(Tmp3, DAG); if (Tmp3.Val) { - Result = LegalizeOp(Tmp3); - Tmp1 = LegalizeOp(Tmp3.getValue(1)); + Tmp1 = LegalizeOp(Tmp3); + Tmp2 = LegalizeOp(Tmp3.getValue(1)); } } - - // Since loads produce two values, make sure to remember that we legalized - // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); - AddLegalizedOperand(SDOperand(Node, 1), Tmp1); - return Op.ResNo ? Tmp1 : Result; + break; case TargetLowering::Expand: // f64 = EXTLOAD f32 should expand to LOAD, FP_EXTEND if (SrcVT == MVT::f32 && Node->getValueType(0) == MVT::f64) { SDOperand Load = DAG.getLoad(SrcVT, Tmp1, Tmp2, Node->getOperand(2)); Result = DAG.getNode(ISD::FP_EXTEND, Node->getValueType(0), Load); - Result = LegalizeOp(Result); // Relegalize new nodes. - Load = LegalizeOp(Load); - AddLegalizedOperand(SDOperand(Node, 0), Result); - AddLegalizedOperand(SDOperand(Node, 1), Load.getValue(1)); - return Op.ResNo ? Load.getValue(1) : Result; + Tmp1 = LegalizeOp(Result); // Relegalize new nodes. + Tmp2 = LegalizeOp(Load.getValue(1)); + break; } assert(Node->getOpcode() != ISD::EXTLOAD && "EXTLOAD should always be supported!"); @@ -943,20 +900,20 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Result, DAG.getValueType(SrcVT)); else ValRes = DAG.getZeroExtendInReg(Result, SrcVT); - Result = LegalizeOp(Result); // Relegalize new nodes. - ValRes = LegalizeOp(ValRes); // Relegalize new nodes. - AddLegalizedOperand(SDOperand(Node, 0), ValRes); - AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Op.ResNo ? Result.getValue(1) : ValRes; + Tmp1 = LegalizeOp(ValRes); // Relegalize new nodes. + Tmp2 = LegalizeOp(Result.getValue(1)); // Relegalize new nodes. + break; } - assert(0 && "Unreachable"); + // Since loads produce two values, make sure to remember that we legalized + // both of them. + AddLegalizedOperand(SDOperand(Node, 0), Tmp1); + AddLegalizedOperand(SDOperand(Node, 1), Tmp2); + return Op.ResNo ? Tmp2 : Tmp1; } case ISD::EXTRACT_ELEMENT: { MVT::ValueType OpTy = Node->getOperand(0).getValueType(); switch (getTypeAction(OpTy)) { - default: - assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); - break; + default: assert(0 && "EXTRACT_ELEMENT action for type unimplemented!"); case Legal: if (cast<ConstantSDNode>(Node->getOperand(1))->getValue()) { // 1 -> Hi @@ -990,24 +947,22 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { // Legalize the incoming value (must be a legal type). Tmp2 = LegalizeOp(Node->getOperand(2)); if (Node->getNumValues() == 1) { - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2)) - Result = DAG.getNode(ISD::CopyToReg, MVT::Other, Tmp1, - Node->getOperand(1), Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1), Tmp2); } else { assert(Node->getNumValues() == 2 && "Unknown CopyToReg"); - if (Node->getNumOperands() == 4) + if (Node->getNumOperands() == 4) { Tmp3 = LegalizeOp(Node->getOperand(3)); - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(2) || - (Node->getNumOperands() == 4 && Tmp3 != Node->getOperand(3))) { - unsigned Reg = cast<RegisterSDNode>(Node->getOperand(1))->getReg(); - Result = DAG.getCopyToReg(Tmp1, Reg, Tmp2, Tmp3); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1), Tmp2, + Tmp3); + } else { + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1),Tmp2); } // Since this produces two values, make sure to remember that we legalized // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); + AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0)); AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Result.getValue(Op.ResNo); + return Result; } break; @@ -1018,8 +973,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { switch (getTypeAction(Node->getOperand(1).getValueType())) { case Legal: Tmp2 = LegalizeOp(Node->getOperand(1)); - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); break; case Expand: { SDOperand Lo, Hi; @@ -1029,13 +983,13 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } case Promote: Tmp2 = PromoteOp(Node->getOperand(1)); - Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1, Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); + Result = LegalizeOp(Result); break; } break; case 1: // ret void - if (Tmp1 != Node->getOperand(0)) - Result = DAG.getNode(ISD::RET, MVT::Other, Tmp1); + Result = DAG.UpdateNodeOperands(Result, Tmp1); break; default: { // ret <values> std::vector<SDOperand> NewValues; @@ -1055,7 +1009,11 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case Promote: assert(0 && "Can't promote multiple return value yet!"); } - Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); + + if (NewValues.size() == Node->getNumOperands()) + Result = DAG.UpdateNodeOperands(Result, NewValues); + else + Result = DAG.getNode(ISD::RET, MVT::Other, NewValues); break; } } @@ -1078,29 +1036,23 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { // FIXME: We shouldn't do this for TargetConstantFP's. if (ConstantFPSDNode *CFP =dyn_cast<ConstantFPSDNode>(Node->getOperand(1))){ if (CFP->getValueType(0) == MVT::f32) { - Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, - DAG.getConstant(FloatToBits(CFP->getValue()), - MVT::i32), - Tmp2, Node->getOperand(3)); + Tmp3 = DAG.getConstant(FloatToBits(CFP->getValue()), MVT::i32); } else { assert(CFP->getValueType(0) == MVT::f64 && "Unknown FP type!"); - Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, - DAG.getConstant(DoubleToBits(CFP->getValue()), - MVT::i64), - Tmp2, Node->getOperand(3)); + Tmp3 = DAG.getConstant(DoubleToBits(CFP->getValue()), MVT::i64); } + Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Tmp3, Tmp2, + Node->getOperand(3)); break; } switch (getTypeAction(Node->getOperand(1).getValueType())) { case Legal: { - SDOperand Val = LegalizeOp(Node->getOperand(1)); - if (Tmp1 != Node->getOperand(0) || Val != Node->getOperand(1) || - Tmp2 != Node->getOperand(2)) - Result = DAG.getNode(ISD::STORE, MVT::Other, Tmp1, Val, Tmp2, - Node->getOperand(3)); + Tmp3 = LegalizeOp(Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp3, Tmp2, + Node->getOperand(3)); - MVT::ValueType VT = Result.Val->getOperand(1).getValueType(); + MVT::ValueType VT = Tmp3.getValueType(); switch (TLI.getOperationAction(ISD::STORE, VT)) { default: assert(0 && "This action is not supported yet!"); case TargetLowering::Legal: break; @@ -1154,58 +1106,48 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } case ISD::PCMARKER: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. - if (Tmp1 != Node->getOperand(0)) - Result = DAG.getNode(ISD::PCMARKER, MVT::Other, Tmp1,Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Node->getOperand(1)); break; case ISD::STACKSAVE: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. - if (Tmp1 != Node->getOperand(0)) { - std::vector<MVT::ValueType> VTs; - VTs.push_back(Node->getValueType(0)); - VTs.push_back(MVT::Other); - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); - Result = DAG.getNode(ISD::STACKSAVE, VTs, Ops); - } - - Tmp1 = Result.getValue(1); + Result = DAG.UpdateNodeOperands(Result, Tmp1); + Tmp1 = Result.getValue(0); + Tmp2 = Result.getValue(1); switch (TLI.getOperationAction(ISD::STACKSAVE, MVT::Other)) { default: assert(0 && "This action is not supported yet!"); case TargetLowering::Legal: break; case TargetLowering::Custom: - Tmp2 = TLI.LowerOperation(Result, DAG); - if (Tmp2.Val) { - Result = LegalizeOp(Tmp2); - Tmp1 = LegalizeOp(Tmp2.getValue(1)); + Tmp3 = TLI.LowerOperation(Result, DAG); + if (Tmp3.Val) { + Tmp1 = LegalizeOp(Tmp3); + Tmp2 = LegalizeOp(Tmp3.getValue(1)); } break; case TargetLowering::Expand: // Expand to CopyFromReg if the target set // StackPointerRegisterToSaveRestore. if (unsigned SP = TLI.getStackPointerRegisterToSaveRestore()) { - Tmp2 = DAG.getCopyFromReg(Result.getOperand(0), SP, + Tmp1 = DAG.getCopyFromReg(Result.getOperand(0), SP, Node->getValueType(0)); - Result = Tmp2; - Tmp1 = Tmp2.getValue(1); + Tmp2 = Tmp1.getValue(1); } else { - Result = DAG.getNode(ISD::UNDEF, Node->getValueType(0)); - Tmp1 = Node->getOperand(0); + Tmp1 = DAG.getNode(ISD::UNDEF, Node->getValueType(0)); + Tmp2 = Node->getOperand(0); } break; } // Since stacksave produce two values, make sure to remember that we // legalized both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); - AddLegalizedOperand(SDOperand(Node, 1), Tmp1); - return Op.ResNo ? Tmp1 : Result; + AddLegalizedOperand(SDOperand(Node, 0), Tmp1); + AddLegalizedOperand(SDOperand(Node, 1), Tmp2); + return Op.ResNo ? Tmp2 : Tmp1; case ISD::STACKRESTORE: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. Tmp2 = LegalizeOp(Node->getOperand(1)); // Legalize the pointer. - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(ISD::STACKRESTORE, MVT::Other, Tmp1, Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); switch (TLI.getOperationAction(ISD::STACKRESTORE, MVT::Other)) { default: assert(0 && "This action is not supported yet!"); @@ -1228,20 +1170,13 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case ISD::READCYCLECOUNTER: Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain - if (Tmp1 != Node->getOperand(0)) { - std::vector<MVT::ValueType> rtypes; - std::vector<SDOperand> rvals; - rtypes.push_back(MVT::i64); - rtypes.push_back(MVT::Other); - rvals.push_back(Tmp1); - Result = DAG.getNode(ISD::READCYCLECOUNTER, rtypes, rvals); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1); // Since rdcc produce two values, make sure to remember that we legalized // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); + AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0)); AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Result.getValue(Op.ResNo); + return Result; case ISD::TRUNCSTORE: { Tmp1 = LegalizeOp(Node->getOperand(0)); // Legalize the chain. @@ -1264,8 +1199,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { } else if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || Tmp3 != Node->getOperand(2)) { - Result = DAG.getNode(ISD::TRUNCSTORE, MVT::Other, Tmp1, Tmp2, Tmp3, - Node->getOperand(3), Node->getOperand(4)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, + Node->getOperand(3), Node->getOperand(4)); } MVT::ValueType StVT = cast<VTSDNode>(Result.Val->getOperand(4))->getVT(); @@ -1292,10 +1227,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp2 = LegalizeOp(Node->getOperand(1)); // TrueVal Tmp3 = LegalizeOp(Node->getOperand(2)); // FalseVal - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2)) - Result = DAG.getNode(ISD::SELECT, Node->getValueType(0), - Tmp1, Tmp2, Tmp3); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); switch (TLI.getOperationAction(ISD::SELECT, Tmp2.getValueType())) { default: assert(0 && "This action is not supported yet!"); @@ -1347,11 +1279,9 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { if (isTypeLegal(Node->getOperand(0).getValueType())) { Tmp1 = LegalizeOp(Node->getOperand(0)); // LHS Tmp2 = LegalizeOp(Node->getOperand(1)); // RHS - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3)) { - Result = DAG.getNode(ISD::SELECT_CC, Node->getValueType(0), Tmp1,Tmp2, - Tmp3, Tmp4, Node->getOperand(4)); - } + + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4, + Node->getOperand(4)); // Everything is legal, see if we should expand this op or something. switch (TLI.getOperationAction(ISD::SELECT_CC, @@ -1501,9 +1431,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { isCustom = true; // FALLTHROUGH. case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, - Node->getOperand(2)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); if (isCustom) { Tmp3 = TLI.LowerOperation(Result, DAG); if (Tmp3.Val) Result = Tmp3; @@ -1535,9 +1463,9 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp1 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp1); Tmp2 = DAG.getNode(ISD::FP_EXTEND, NewInTy, Tmp2); } - - Result = DAG.getNode(ISD::SETCC, Node->getValueType(0), Tmp1, Tmp2, - Node->getOperand(2)); + Tmp1 = LegalizeOp(Tmp1); + Tmp2 = LegalizeOp(Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); Result = LegalizeOp(Result); break; } @@ -1548,7 +1476,6 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Result = DAG.getNode(ISD::SELECT_CC, VT, Tmp1, Tmp2, DAG.getConstant(1, VT), DAG.getConstant(0, VT), Node->getOperand(2)); - Result = LegalizeOp(Result); break; } break; @@ -1605,14 +1532,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { isCustom = true; // FALLTHROUGH case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2) || Tmp4 != Node->getOperand(3) || - Tmp5 != Node->getOperand(4)) { - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); Ops.push_back(Tmp2); Ops.push_back(Tmp3); - Ops.push_back(Tmp4); Ops.push_back(Tmp5); - Result = DAG.getNode(Node->getOpcode(), MVT::Other, Ops); - } + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, Tmp4, Tmp5); if (isCustom) { Tmp1 = TLI.LowerOperation(Result, DAG); if (Tmp1.Val) Result = Tmp1; @@ -1657,27 +1577,18 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case ISD::READPORT: Tmp1 = LegalizeOp(Node->getOperand(0)); Tmp2 = LegalizeOp(Node->getOperand(1)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { - std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); - Ops.push_back(Tmp2); - Result = DAG.getNode(ISD::READPORT, VTs, Ops); - } else - Result = SDOperand(Node, 0); // Since these produce two values, make sure to remember that we legalized // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); + AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0)); AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); - return Result.getValue(Op.ResNo); + return Result; case ISD::WRITEPORT: Tmp1 = LegalizeOp(Node->getOperand(0)); Tmp2 = LegalizeOp(Node->getOperand(1)); Tmp3 = LegalizeOp(Node->getOperand(2)); - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2)) - Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); break; case ISD::READIO: @@ -1688,14 +1599,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case TargetLowering::Custom: default: assert(0 && "This action not implemented for this operation!"); case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) { - std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); - std::vector<SDOperand> Ops; - Ops.push_back(Tmp1); - Ops.push_back(Tmp2); - Result = DAG.getNode(ISD::READPORT, VTs, Ops); - } else - Result = SDOperand(Node, 0); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); break; case TargetLowering::Expand: // Replace this with a load from memory. @@ -1707,7 +1611,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { // Since these produce two values, make sure to remember that we legalized // both of them. - AddLegalizedOperand(SDOperand(Node, 0), Result); + AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0)); AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1)); return Result.getValue(Op.ResNo); @@ -1721,9 +1625,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { case TargetLowering::Custom: default: assert(0 && "This action not implemented for this operation!"); case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2)) - Result = DAG.getNode(Node->getOpcode(), MVT::Other, Tmp1, Tmp2, Tmp3); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3); break; case TargetLowering::Expand: // Replace this with a store to memory. @@ -1745,10 +1647,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Ops.push_back(LegalizeOp(Node->getOperand(i))); Changed |= Ops.back() != Node->getOperand(i); } - if (Changed) { - std::vector<MVT::ValueType> VTs(Node->value_begin(), Node->value_end()); - Result = DAG.getNode(Node->getOpcode(), VTs, Ops); - } + if (Changed) + Result = DAG.UpdateNodeOperands(Result, Ops); switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { @@ -1805,9 +1705,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { Tmp2 = PromoteOp(Node->getOperand(1)); // Promote the RHS. break; } - - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), Tmp1,Tmp2); + + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) { default: assert(0 && "Operation not supported"); @@ -1856,9 +1755,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { isCustom = true; // FALLTHROUGH case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getNode(Node->getOpcode(), Node->getValueType(0), - Tmp1, Tmp2); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2); if (isCustom) { Tmp1 = TLI.LowerOperation(Result, DAG); if (Tmp1.Val) Result = Tmp1; @@ -1892,10 +1789,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { isCustom = true; // FALLTHROUGH case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1)) - Result = DAG.getVAArg(VT, Tmp1, Tmp2, Node->getOperand(2)); - else - Result = SDOperand(Node, 0); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Node->getOperand(2)); + Result = Result.getValue(0); Tmp1 = Result.getValue(1); if (isCustom) { @@ -1941,10 +1836,8 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) { isCustom = true; // FALLTHROUGH case TargetLowering::Legal: - if (Tmp1 != Node->getOperand(0) || Tmp2 != Node->getOperand(1) || - Tmp3 != Node->getOperand(2)) - Result = DAG.getNode(ISD::VACOPY, MVT::Other, Tmp1, Tmp2, Tmp3, - Node->getOperand(3), Node->getOperand(4)); + Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3, + Node->getOperand(3), Node->getOperand(4)); |