Remove some patterns for matching vector_shuffle instructions since vector_shuffles...

[oota-llvm.git] / lib / Target / X86 / X86ISelDAGToDAG.cpp

diff --git a/lib/Target/X86/X86ISelDAGToDAG.cpp b/lib/Target/X86/X86ISelDAGToDAG.cpp
index 7499182c27585f9b9d5bdf2d1acd0187b2a79a6c..830cb65878e2d00b5ed9f6ce48d42016e9550747 100644 (file)
--- a/lib/Target/X86/X86ISelDAGToDAG.cpp
+++ b/lib/Target/X86/X86ISelDAGToDAG.cpp
@@ -725,6 +725,19 @@ bool X86DAGToDAGISel::MatchAddress(SDValue N, X86ISelAddressMode &AM) {
   return false;
 }
 
+// Insert a node into the DAG at least before the Pos node's position. This
+// will reposition the node as needed, and will assign it a node ID that is <=
+// the Pos node's ID. Note that this does *not* preserve the uniqueness of node
+// IDs! The selection DAG must no longer depend on their uniqueness when this
+// is used.
+static void InsertDAGNode(SelectionDAG &DAG, SDValue Pos, SDValue N) {
+  if (N.getNode()->getNodeId() == -1 ||
+      N.getNode()->getNodeId() > Pos.getNode()->getNodeId()) {
+    DAG.RepositionNode(Pos.getNode(), N.getNode());
+    N.getNode()->setNodeId(Pos.getNode()->getNodeId());
+  }
+}
+
 // Transform "(X >> (8-C1)) & C2" to "(X >> 8) & 0xff)" if safe. This
 // allows us to convert the shift and and into an h-register extract and
 // a scaled index. Returns false if the simplification is performed.
@@ -751,37 +764,17 @@ static bool FoldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N,
   SDValue ShlCount = DAG.getConstant(ScaleLog, MVT::i8);
   SDValue Shl = DAG.getNode(ISD::SHL, DL, VT, And, ShlCount);
 
-  // Insert the new nodes into the topological ordering.
-  if (Eight.getNode()->getNodeId() == -1 ||
-      Eight.getNode()->getNodeId() > X.getNode()->getNodeId()) {
-    DAG.RepositionNode(X.getNode(), Eight.getNode());
-    Eight.getNode()->setNodeId(X.getNode()->getNodeId());
-  }
-  if (NewMask.getNode()->getNodeId() == -1 ||
-      NewMask.getNode()->getNodeId() > X.getNode()->getNodeId()) {
-    DAG.RepositionNode(X.getNode(), NewMask.getNode());
-    NewMask.getNode()->setNodeId(X.getNode()->getNodeId());
-  }
-  if (Srl.getNode()->getNodeId() == -1 ||
-      Srl.getNode()->getNodeId() > Shift.getNode()->getNodeId()) {
-    DAG.RepositionNode(Shift.getNode(), Srl.getNode());
-    Srl.getNode()->setNodeId(Shift.getNode()->getNodeId());
-  }
-  if (And.getNode()->getNodeId() == -1 ||
-      And.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), And.getNode());
-    And.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
-  if (ShlCount.getNode()->getNodeId() == -1 ||
-      ShlCount.getNode()->getNodeId() > X.getNode()->getNodeId()) {
-    DAG.RepositionNode(X.getNode(), ShlCount.getNode());
-    ShlCount.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
-  if (Shl.getNode()->getNodeId() == -1 ||
-      Shl.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), Shl.getNode());
-    Shl.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
+  // Insert the new nodes into the topological ordering. We must do this in
+  // a valid topological ordering as nothing is going to go back and re-sort
+  // these nodes. We continually insert before 'N' in sequence as this is
+  // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
+  // hierarchy left to express.
+  InsertDAGNode(DAG, N, Eight);
+  InsertDAGNode(DAG, N, Srl);
+  InsertDAGNode(DAG, N, NewMask);
+  InsertDAGNode(DAG, N, And);
+  InsertDAGNode(DAG, N, ShlCount);
+  InsertDAGNode(DAG, N, Shl);
   DAG.ReplaceAllUsesWith(N, Shl);
   AM.IndexReg = And;
   AM.Scale = (1 << ScaleLog);
@@ -816,22 +809,14 @@ static bool FoldMaskedShiftToScaledMask(SelectionDAG &DAG, SDValue N,
   SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, NewMask);
   SDValue NewShift = DAG.getNode(ISD::SHL, DL, VT, NewAnd, Shift.getOperand(1));
 
-  // Insert the new nodes into the topological ordering.
-  if (NewMask.getNode()->getNodeId() == -1 ||
-      NewMask.getNode()->getNodeId() > X.getNode()->getNodeId()) {
-    DAG.RepositionNode(X.getNode(), NewMask.getNode());
-    NewMask.getNode()->setNodeId(X.getNode()->getNodeId());
-  }
-  if (NewAnd.getNode()->getNodeId() == -1 ||
-      NewAnd.getNode()->getNodeId() > Shift.getNode()->getNodeId()) {
-    DAG.RepositionNode(Shift.getNode(), NewAnd.getNode());
-    NewAnd.getNode()->setNodeId(Shift.getNode()->getNodeId());
-  }
-  if (NewShift.getNode()->getNodeId() == -1 ||
-      NewShift.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), NewShift.getNode());
-    NewShift.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
+  // Insert the new nodes into the topological ordering. We must do this in
+  // a valid topological ordering as nothing is going to go back and re-sort
+  // these nodes. We continually insert before 'N' in sequence as this is
+  // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
+  // hierarchy left to express.
+  InsertDAGNode(DAG, N, NewMask);
+  InsertDAGNode(DAG, N, NewAnd);
+  InsertDAGNode(DAG, N, NewShift);
   DAG.ReplaceAllUsesWith(N, NewShift);
 
   AM.Scale = 1 << ShiftAmt;
@@ -922,11 +907,7 @@ static bool FoldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
     assert(X.getValueType() != VT);
     // We looked through an ANY_EXTEND node, insert a ZERO_EXTEND.
     SDValue NewX = DAG.getNode(ISD::ZERO_EXTEND, X.getDebugLoc(), VT, X);
-    if (NewX.getNode()->getNodeId() == -1 ||
-        NewX.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-      DAG.RepositionNode(N.getNode(), NewX.getNode());
-      NewX.getNode()->setNodeId(N.getNode()->getNodeId());
-    }
+    InsertDAGNode(DAG, N, NewX);
     X = NewX;
   }
   DebugLoc DL = N.getDebugLoc();
@@ -934,26 +915,16 @@ static bool FoldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
   SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
   SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, MVT::i8);
   SDValue NewSHL = DAG.getNode(ISD::SHL, DL, VT, NewSRL, NewSHLAmt);
-  if (NewSRLAmt.getNode()->getNodeId() == -1 ||
-      NewSRLAmt.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), NewSRLAmt.getNode());
-    NewSRLAmt.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
-  if (NewSRL.getNode()->getNodeId() == -1 ||
-      NewSRL.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), NewSRL.getNode());
-    NewSRL.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
-  if (NewSHLAmt.getNode()->getNodeId() == -1 ||
-      NewSHLAmt.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), NewSHLAmt.getNode());
-    NewSHLAmt.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
-  if (NewSHL.getNode()->getNodeId() == -1 ||
-      NewSHL.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-    DAG.RepositionNode(N.getNode(), NewSHL.getNode());
-    NewSHL.getNode()->setNodeId(N.getNode()->getNodeId());
-  }
+
+  // Insert the new nodes into the topological ordering. We must do this in
+  // a valid topological ordering as nothing is going to go back and re-sort
+  // these nodes. We continually insert before 'N' in sequence as this is
+  // essentially a pre-flattened and pre-sorted sequence of nodes. There is no
+  // hierarchy left to express.
+  InsertDAGNode(DAG, N, NewSRLAmt);
+  InsertDAGNode(DAG, N, NewSRL);
+  InsertDAGNode(DAG, N, NewSHLAmt);
+  InsertDAGNode(DAG, N, NewSHL);
   DAG.ReplaceAllUsesWith(N, NewSHL);
 
   AM.Scale = 1 << AMShiftAmt;
@@ -1180,16 +1151,8 @@ bool X86DAGToDAGISel::MatchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
     AM.Scale = 1;
 
     // Insert the new nodes into the topological ordering.
-    if (Zero.getNode()->getNodeId() == -1 ||
-        Zero.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-      CurDAG->RepositionNode(N.getNode(), Zero.getNode());
-      Zero.getNode()->setNodeId(N.getNode()->getNodeId());
-    }
-    if (Neg.getNode()->getNodeId() == -1 ||
-        Neg.getNode()->getNodeId() > N.getNode()->getNodeId()) {
-      CurDAG->RepositionNode(N.getNode(), Neg.getNode());
-      Neg.getNode()->setNodeId(N.getNode()->getNodeId());
-    }
+    InsertDAGNode(*CurDAG, N, Zero);
+    InsertDAGNode(*CurDAG, N, Neg);
     return false;
   }
 
@@ -1255,23 +1218,21 @@ bool X86DAGToDAGISel::MatchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
     // addressing mode optimizations.
     if (X.getValueSizeInBits() > 64) break;
 
-    ConstantSDNode *C2 = dyn_cast<ConstantSDNode>(N.getOperand(1));
-    ConstantSDNode *C1 = dyn_cast<ConstantSDNode>(Shift.getOperand(1));
-    if (!C1 || !C2) break;
+    if (!isa<ConstantSDNode>(N.getOperand(1)))
+      break;
+    uint64_t Mask = N.getConstantOperandVal(1);
 
     // Try to fold the mask and shift into an extract and scale.
-    if (!FoldMaskAndShiftToExtract(*CurDAG, N, C2->getZExtValue(),
-                                   Shift, X, AM))
+    if (!FoldMaskAndShiftToExtract(*CurDAG, N, Mask, Shift, X, AM))
       return false;
 
     // Try to fold the mask and shift directly into the scale.
-    if (!FoldMaskAndShiftToScale(*CurDAG, N, C2->getZExtValue(), Shift, X, AM))
+    if (!FoldMaskAndShiftToScale(*CurDAG, N, Mask, Shift, X, AM))
       return false;
 
     // Try to swap the mask and shift to place shifts which can be done as
     // a scale on the outside of the mask.
-    if (!FoldMaskedShiftToScaledMask(*CurDAG, N, C2->getZExtValue(),
-                                     Shift, X, AM))
+    if (!FoldMaskedShiftToScaledMask(*CurDAG, N, Mask, Shift, X, AM))
       return false;
     break;
   }
@@ -2007,7 +1968,6 @@ SDNode *X86DAGToDAGISel::Select(SDNode *Node) {
     SDNode *New = CurDAG->getMachineNode(Op, dl, NVT, N0->getOperand(0),NewCst);
     return CurDAG->SelectNodeTo(Node, ShlOp, NVT, SDValue(New, 0),
                                 getI8Imm(ShlVal));
-    break;
   }
   case X86ISD::UMUL: {
     SDValue N0 = Node->getOperand(0);