From a52554e58e82a1e43ddf41ac96706b7c817b5dcc Mon Sep 17 00:00:00 2001 From: Duncan Sands Date: Mon, 27 Apr 2009 19:33:03 +0000 Subject: [PATCH] Now that PR2957 is resolved, remove a bunch of no-longer needed workarounds. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@70234 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 4 +- lib/CodeGen/SelectionDAG/LegalizeTypes.cpp | 18 +------ lib/CodeGen/SelectionDAG/LegalizeTypes.h | 10 +--- lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp | 62 ------------------------ 4 files changed, 4 insertions(+), 90 deletions(-) diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index be7a794c86..0b019fdeee 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -489,10 +489,8 @@ void SelectionDAGLegalize::HandleOp(SDValue Op) { // If the type legalizer was run then we should never see any illegal result // types here except for target constants (the type legalizer does not touch // those) or for build vector used as a mask for a vector shuffle. - // FIXME: We can removed the BUILD_VECTOR case when we fix PR2957. assert((TypesNeedLegalizing || getTypeAction(VT) == Legal || - IsLegalizingCallArgs || Op.getOpcode() == ISD::TargetConstant || - Op.getOpcode() == ISD::BUILD_VECTOR) && + IsLegalizingCallArgs || Op.getOpcode() == ISD::TargetConstant) && "Illegal type introduced after type legalization?"); switch (getTypeAction(VT)) { default: assert(0 && "Bad type action!"); diff --git a/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp index 632524fd96..dc0f7957d7 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeTypes.cpp @@ -116,11 +116,8 @@ void DAGTypeLegalizer::PerformExpensiveChecks() { cerr << "Unprocessed value in a map!"; Failed = true; } - } else if (isTypeLegal(Res.getValueType()) || IgnoreNodeResults(I)) { - // FIXME: Because of PR2957, the build vector can be placed on this - // list but if the associated vector shuffle is split, the build vector - // can also be split so we allow this to go through for now. - if (Mapped > 1 && Res.getOpcode() != ISD::BUILD_VECTOR) { + } else if (isTypeLegal(Res.getValueType())) { + if (Mapped > 1) { cerr << "Value with legal type was transformed!"; Failed = true; } @@ -266,13 +263,6 @@ ScanOperands: if (IgnoreNodeResults(N->getOperand(i).getNode())) continue; - if (N->getOpcode() == ISD::VECTOR_SHUFFLE && i == 2) { - // The shuffle mask doesn't need to be a legal vector type. - // FIXME: We can remove this once we fix PR2957. - SetIgnoredNodeResult(N->getOperand(2).getNode()); - continue; - } - MVT OpVT = N->getOperand(i).getValueType(); switch (getTypeAction(OpVT)) { default: @@ -842,10 +832,6 @@ void DAGTypeLegalizer::SetWidenedVector(SDValue Op, SDValue Result) { OpEntry = Result; } -// Set to ignore result -void DAGTypeLegalizer::SetIgnoredNodeResult(SDNode* N) { - IgnoredNodesResultsSet.insert(N); -} //===----------------------------------------------------------------------===// // Utilities. diff --git a/lib/CodeGen/SelectionDAG/LegalizeTypes.h b/lib/CodeGen/SelectionDAG/LegalizeTypes.h index 24fb44cc32..330b5e7a65 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeTypes.h +++ b/lib/CodeGen/SelectionDAG/LegalizeTypes.h @@ -114,16 +114,10 @@ private: } /// IgnoreNodeResults - Pretend all of this node's results are legal. - /// FIXME: Remove once PR2957 is done. bool IgnoreNodeResults(SDNode *N) const { - return N->getOpcode() == ISD::TargetConstant || - IgnoredNodesResultsSet.count(N); + return N->getOpcode() == ISD::TargetConstant; } - /// IgnoredNode - Set of nodes whose result don't need to be legal. - /// FIXME: Remove once PR2957 is done. - DenseSet IgnoredNodesResultsSet; - /// PromotedIntegers - For integer nodes that are below legal width, this map /// indicates what promoted value to use. DenseMap PromotedIntegers; @@ -202,7 +196,6 @@ private: SDValue PromoteTargetBoolean(SDValue Bool, MVT VT); void ReplaceValueWith(SDValue From, SDValue To); void ReplaceValueWithHelper(SDValue From, SDValue To); - void SetIgnoredNodeResult(SDNode* N); void SplitInteger(SDValue Op, SDValue &Lo, SDValue &Hi); void SplitInteger(SDValue Op, MVT LoVT, MVT HiVT, SDValue &Lo, SDValue &Hi); @@ -577,7 +570,6 @@ private: SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N); SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N); SDValue SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo); - SDValue SplitVecOp_VECTOR_SHUFFLE(SDNode *N, unsigned OpNo); //===--------------------------------------------------------------------===// // Vector Widening Support: LegalizeVectorTypes.cpp diff --git a/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp index fac4d990e1..f35db83d8b 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp @@ -910,7 +910,6 @@ bool DAGTypeLegalizer::SplitVectorOperand(SDNode *N, unsigned OpNo) { case ISD::EXTRACT_VECTOR_ELT:Res = SplitVecOp_EXTRACT_VECTOR_ELT(N); break; case ISD::STORE: Res = SplitVecOp_STORE(cast(N), OpNo); break; - case ISD::VECTOR_SHUFFLE: Res = SplitVecOp_VECTOR_SHUFFLE(N, OpNo);break; case ISD::CTTZ: case ISD::CTLZ: @@ -1073,67 +1072,6 @@ SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) { return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi); } -SDValue DAGTypeLegalizer::SplitVecOp_VECTOR_SHUFFLE(SDNode *N, unsigned OpNo) { - assert(OpNo == 2 && "Shuffle source type differs from result type?"); - SDValue Mask = N->getOperand(2); - DebugLoc dl = N->getDebugLoc(); - unsigned MaskLength = Mask.getValueType().getVectorNumElements(); - unsigned LargestMaskEntryPlusOne = 2 * MaskLength; - unsigned MinimumBitWidth = Log2_32_Ceil(LargestMaskEntryPlusOne); - - // Look for a legal vector type to place the mask values in. - // Note that there may not be *any* legal vector-of-integer - // type for which the element type is legal! - for (MVT::SimpleValueType EltVT = MVT::FIRST_INTEGER_VALUETYPE; - EltVT <= MVT::LAST_INTEGER_VALUETYPE; - // Integer values types are consecutively numbered. Exploit this. - EltVT = MVT::SimpleValueType(EltVT + 1)) { - - // Is the element type big enough to hold the values? - if (MVT(EltVT).getSizeInBits() < MinimumBitWidth) - // Nope. - continue; - - // Is the vector type legal? - MVT VecVT = MVT::getVectorVT(EltVT, MaskLength); - if (!isTypeLegal(VecVT)) - // Nope. - continue; - - // If the element type is not legal, find a larger legal type to use for - // the BUILD_VECTOR operands. This is an ugly hack, but seems to work! - // FIXME: The real solution is to change VECTOR_SHUFFLE into a variadic - // node where the shuffle mask is a list of integer operands, #2 .. #2+n. - for (MVT::SimpleValueType OpVT = EltVT; OpVT <= MVT::LAST_INTEGER_VALUETYPE; - // Integer values types are consecutively numbered. Exploit this. - OpVT = MVT::SimpleValueType(OpVT + 1)) { - if (!isTypeLegal(OpVT)) - continue; - - // Success! Rebuild the vector using the legal types. - SmallVector Ops(MaskLength); - for (unsigned i = 0; i < MaskLength; ++i) { - SDValue Arg = Mask.getOperand(i); - if (Arg.getOpcode() == ISD::UNDEF) { - Ops[i] = DAG.getUNDEF(OpVT); - } else { - uint64_t Idx = cast(Arg)->getZExtValue(); - Ops[i] = DAG.getConstant(Idx, OpVT); - } - } - return DAG.UpdateNodeOperands(SDValue(N,0), - N->getOperand(0), N->getOperand(1), - DAG.getNode(ISD::BUILD_VECTOR, dl, - VecVT, &Ops[0], Ops.size())); - } - - // Continuing is pointless - failure is certain. - break; - } - assert(false && "Failed to find an appropriate mask type!"); - return SDValue(N, 0); -} - //===----------------------------------------------------------------------===// // Result Vector Widening -- 2.11.4.GIT