Changes in directory llvm/lib/CodeGen/SelectionDAG:
SelectionDAGISel.cpp updated: 1.243 -> 1.244 --- Log message: Add support for calls that pass and return legal vectors. --- Diffs of the changes: (+60 -3) SelectionDAGISel.cpp | 63 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 files changed, 60 insertions(+), 3 deletions(-) Index: llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp diff -u llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.243 llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.244 --- llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.243 Tue May 16 17:53:20 2006 +++ llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp Tue May 16 18:39:44 2006 @@ -2470,6 +2470,7 @@ Ops.push_back(N); } else { assert(0 && "Don't support illegal by-val vector arguments yet!"); + abort(); } } break; @@ -2537,7 +2538,26 @@ assert(0 && "Cannot expand i64 -> i16 yet!"); } } else { - assert(0 && "Doesn't handle vectors yet!"); + // Otherwise, this is a vector type. We only support legal vectors + // right now. + const PackedType *PTy = cast<PackedType>(Args[i].second); + unsigned NumElems = PTy->getNumElements(); + const Type *EltTy = PTy->getElementType(); + + // Figure out if there is a Packed type corresponding to this Vector + // type. If so, convert to the packed type. + MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); + if (TVT != MVT::Other && isTypeLegal(TVT)) { + // Handle copies from generic vectors to registers. + MVT::ValueType PTyElementVT, PTyLegalElementVT; + unsigned NE = getPackedTypeBreakdown(PTy, PTyElementVT, + PTyLegalElementVT); + // Insert a VBIT_CONVERT of the MVT::Vector type to the packed type. + Ops.push_back(DAG.getNode(ISD::VBIT_CONVERT, TVT, Op)); + } else { + assert(0 && "Don't support illegal by-val vector call args yet!"); + abort(); + } } break; } @@ -2566,7 +2586,21 @@ for (unsigned i = 0; i != NumVals; ++i) RetTys.push_back(NVT); } else { - assert(0 && "Doesn't handle vectors yet!"); + // Otherwise, this is a vector type. We only support legal vectors + // right now. + const PackedType *PTy = cast<PackedType>(RetTy); + unsigned NumElems = PTy->getNumElements(); + const Type *EltTy = PTy->getElementType(); + + // Figure out if there is a Packed type corresponding to this Vector + // type. If so, convert to the packed type. + MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); + if (TVT != MVT::Other && isTypeLegal(TVT)) { + RetTys.push_back(TVT); + } else { + assert(0 && "Don't support illegal by-val vector call results yet!"); + abort(); + } } } } @@ -2587,7 +2621,30 @@ // If this value was promoted, truncate it down. if (ResVal.getValueType() != VT) { - if (MVT::isInteger(VT)) { + if (VT == MVT::Vector) { + // Insert a VBITCONVERT to convert from the packed result type to the + // MVT::Vector type. + unsigned NumElems = cast<PackedType>(RetTy)->getNumElements(); + const Type *EltTy = cast<PackedType>(RetTy)->getElementType(); + + // Figure out if there is a Packed type corresponding to this Vector + // type. If so, convert to the packed type. + MVT::ValueType TVT = MVT::getVectorType(getValueType(EltTy), NumElems); + if (TVT != MVT::Other && isTypeLegal(TVT)) { + // Handle copies from generic vectors to registers. + MVT::ValueType PTyElementVT, PTyLegalElementVT; + unsigned NE = getPackedTypeBreakdown(cast<PackedType>(RetTy), + PTyElementVT, + PTyLegalElementVT); + // Insert a VBIT_CONVERT of the FORMAL_ARGUMENTS to a + // "N x PTyElementVT" MVT::Vector type. + ResVal = DAG.getNode(ISD::VBIT_CONVERT, MVT::Vector, ResVal, + DAG.getConstant(NE, MVT::i32), + DAG.getValueType(PTyElementVT)); + } else { + abort(); + } + } else if (MVT::isInteger(VT)) { unsigned AssertOp = RetTy->isSigned() ? ISD::AssertSext : ISD::AssertZext; ResVal = DAG.getNode(AssertOp, ResVal.getValueType(), ResVal, _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits