Add support for 128 bit shifts and 32 bit shifts

[oota-llvm.git] / lib / CodeGen / SelectionDAG / LegalizeTypesGeneric.cpp

diff --git a/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp b/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
index 1b2ecef16d9f98e7f50a9c805ea702a56d7a130c..783cc9d213bca4ea4df50330dec116dee8aadce2 100644 (file)
--- a/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
@@ -28,8 +28,8 @@ using namespace llvm;
 // little/big-endian machines, followed by the Hi/Lo part.  This means that
 // they cannot be used as is on vectors, for which Lo is always stored first.
 
-void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N,
-                                             SDOperand &Lo, SDOperand &Hi) {
+void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N, SDOperand &Lo,
+                                             SDOperand &Hi) {
   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
   SDOperand InOp = N->getOperand(0);
   MVT InVT = InOp.getValueType();
@@ -54,7 +54,7 @@ void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N,
       Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo);
       Hi = DAG.getNode(ISD::BIT_CONVERT, NVT, Hi);
       return;
-    case Split:
+    case SplitVector:
       // Convert the split parts of the input if it was split in two.
       GetSplitVector(InOp, Lo, Hi);
       if (Lo.getValueType() == Hi.getValueType()) {
@@ -65,7 +65,7 @@ void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N,
         return;
       }
       break;
-    case Scalarize:
+    case ScalarizeVector:
       // Convert the element instead.
       SplitInteger(BitConvertToInteger(GetScalarizedVector(InOp)), Lo, Hi);
       Lo = DAG.getNode(ISD::BIT_CONVERT, NVT, Lo);
@@ -75,18 +75,32 @@ void DAGTypeLegalizer::ExpandRes_BIT_CONVERT(SDNode *N,
 
   // Lower the bit-convert to a store/load from the stack, then expand the load.
   SDOperand Op = CreateStackStoreLoad(InOp, N->getValueType(0));
-  ExpandRes_NON_EXTLOAD(Op.Val, Lo, Hi);
+  ExpandRes_NormalLoad(Op.Val, Lo, Hi);
 }
 
-void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N,
-                                            SDOperand &Lo, SDOperand &Hi) {
+void DAGTypeLegalizer::ExpandRes_BUILD_PAIR(SDNode *N, SDOperand &Lo,
+                                            SDOperand &Hi) {
   // Return the operands.
   Lo = N->getOperand(0);
   Hi = N->getOperand(1);
 }
 
-void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N,
-                                                    SDOperand &Lo,
+void DAGTypeLegalizer::ExpandRes_EXTRACT_ELEMENT(SDNode *N, SDOperand &Lo,
+                                                 SDOperand &Hi) {
+  GetExpandedOp(N->getOperand(0), Lo, Hi);
+  SDOperand Part = cast<ConstantSDNode>(N->getOperand(1))->getValue() ? Hi : Lo;
+
+  assert(Part.getValueType() == N->getValueType(0) &&
+         "Type twice as big as expanded type not itself expanded!");
+  MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
+
+  Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Part,
+                   DAG.getConstant(0, TLI.getPointerTy()));
+  Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, NVT, Part,
+                   DAG.getConstant(1, TLI.getPointerTy()));
+}
+
+void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDOperand &Lo,
                                                     SDOperand &Hi) {
   SDOperand OldVec = N->getOperand(0);
   unsigned OldElts = OldVec.getValueType().getVectorNumElements();
@@ -118,10 +132,9 @@ void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N,
     std::swap(Lo, Hi);
 }
 
-void DAGTypeLegalizer::ExpandRes_NON_EXTLOAD(SDNode *N, SDOperand &Lo,
-                                             SDOperand &Hi) {
-  assert(ISD::isNON_EXTLoad(N) && "This routine is not for extending loads!");
-  assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
+void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDOperand &Lo,
+                                            SDOperand &Hi) {
+  assert(ISD::isNormalLoad(N) && "This routine only for normal loads!");
 
   LoadSDNode *LD = cast<LoadSDNode>(N);
   MVT NVT = TLI.getTypeToTransformTo(LD->getValueType(0));
@@ -157,6 +170,7 @@ void DAGTypeLegalizer::ExpandRes_NON_EXTLOAD(SDNode *N, SDOperand &Lo,
   ReplaceValueWith(SDOperand(N, 1), Chain);
 }
 
+
 //===--------------------------------------------------------------------===//
 // Generic Operand Expansion.
 //===--------------------------------------------------------------------===//
@@ -222,9 +236,8 @@ SDOperand DAGTypeLegalizer::ExpandOp_EXTRACT_ELEMENT(SDNode *N) {
   return cast<ConstantSDNode>(N->getOperand(1))->getValue() ? Hi : Lo;
 }
 
-SDOperand DAGTypeLegalizer::ExpandOp_NON_TRUNCStore(SDNode *N, unsigned OpNo) {
-  assert(ISD::isNON_TRUNCStore(N) && "This routine not for truncating stores!");
-  assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
+SDOperand DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) {
+  assert(ISD::isNormalStore(N) && "This routine only for normal stores!");
   assert(OpNo == 1 && "Can only expand the stored value so far");
 
   StoreSDNode *St = cast<StoreSDNode>(N);