<div dir="ltr">Argh, yes, your workaround was pretty much the original intent - all of the unsupported cases should have fallen off into the final else. (I actually broke it in r281402, not in this commit.)<div>Thanks a lot for the test case!</div><div><br></div><div>Regarding running this only post-legalization, as I said on D24491, what worries me is cases like constructing a single <4 x i32> from two <2 x i32>-s. But maybe I'm just being paranoid.</div><div>What benefits do you see from running this only post-legalization? I don't think it'll allow us to simplify the code any, since we can get non-factor-of-2 mismatches even post-legalizer (In AVX-512 you have both 512-bit and 128-bit legal vectors).</div><div><br></div><div><br></div></div><div class="gmail_extra"><br><div class="gmail_quote">On Tue, Oct 11, 2016 at 6:03 AM, Andrea Di Biagio <span dir="ltr"><<a href="mailto:andrea.dibiagio@gmail.com" target="_blank">andrea.dibiagio@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div><div><div><div>Hi Michael,<br><br></div>It looks like your patch introduced a regression (see reproducible below):<br><br><br>;;;;;<br>target datalayout = "e-m:e-i64:64-f80:128-n8:16:<wbr>32:64-S128"<br>target triple = "x86_64-unknown-linux-gnu"<br><br>define <2 x double> @foo(<4 x double> %A) {<br>entry:<br>  %A.addr = alloca <4 x double>, align 32<br>  %B = alloca <8 x double>, align 64<br>  %C = alloca <8 x double>, align 64<br>  store <4 x double> %A, <4 x double>* %A.addr, align 32<br>  %0 = load <4 x double>, <4 x double>* %A.addr, align 32<br>  %1 = load <4 x double>, <4 x double>* %A.addr, align 32<br>  %shuffle = shufflevector <4 x double> %0, <4 x double> %1, <8 x i32> zeroinitializer<br>  store <8 x double> %shuffle, <8 x double>* %B, align 64<br>  %2 = load <8 x double>, <8 x double>* %B, align 64<br>  store <8 x double> %2, <8 x double>* %C, align 64<br>  %3 = load <8 x double>, <8 x double>* %C, align 64<br>  %4 = shufflevector <8 x double> %3, <8 x double> undef, <2 x i32> <i32 2, i32 0><br>  ret <2 x double> %4<br>}<br>;;;;<br><br></div><div>The problem is in DAGCombiner::<wbr>createBuildVecShuffle.<br></div><div>InVT2 is larger than InVT1, and the size of InVT1 is VT.getSizeInBits() * 2. Basically, it looks like we forgot to handle the case where InVT2 is larger than InVT1. In this particular case we have:<br></div><div>  VT = MVT::v2f64<br></div><div>  InVT1 = MVT::v4f64<br></div><div>  InVT2 = MVT::v8f64<br><br></div><div>I managed to workaround this issue by applying the patch below. As you know, this transform can run even if vector types are not legal. Therefore the probability of having mismatching types for InVT2 and InVT1 is higher. I still wonder if we should only enable this transform for the case were all the involved vector types are legal. in this particular (randomly generated) example, most of the node in the DAG will be be simplified before we even run the type legalizer. So, the buildvetor-shuffle canonicalization may be run prematurely in this particular case.<br><br></div><div>(see patch below).<br><br></div>Index: SelectionDAG/DAGCombiner.cpp<br>==============================<wbr>==============================<wbr>=======<br>--- SelectionDAG/DAGCombiner.cpp  <wbr>      (revision 283869)<br>+++ SelectionDAG/DAGCombiner.cpp  <wbr>      (working copy)<br>@@ -12933,7 +12933,12 @@<span class=""><br>           VecIn2 = DAG.getNode(ISD::INSERT_<wbr>SUBVECTOR, DL, InVT1,<br>                              <wbr>  DAG.getUNDEF(InVT1), VecIn2, ZeroIdx);<br>         ShuffleNumElems = NumElems * 2;<br></span>-      }<br>+      } else<br>+        // Conservatively bail out if VecIn2 is larger than VecIn1.<br>+        // TODO: We will be able to replace this case with a simple assert when<br>+        // we will teach reduceBuildVecToShuffle() how to sort input vectors by<br>+        // descending size.<br>+        return SDValue();<span class=""><br>     } else {<br>       // TODO: Support cases where the length mismatch isn't exactly by a<br>       // factor of 2.<br><br></span>====<br><br></div>I hope this helps,<br></div>Andrea<br></div><div class="HOEnZb"><div class="h5"><div class="gmail_extra"><br><div class="gmail_quote">On Thu, Oct 6, 2016 at 7:58 PM, Michael Kuperstein via llvm-commits <span dir="ltr"><<a href="mailto:llvm-commits@lists.llvm.org" target="_blank">llvm-commits@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: mkuper<br>
Date: Thu Oct  6 13:58:24 2016<br>
New Revision: 283480<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=283480&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-pr<wbr>oject?rev=283480&view=rev</a><br>
Log:<br>
[DAG] Generalize build_vector -> vector_shuffle combine for more than 2 inputs<br>
<br>
This generalizes the build_vector -> vector_shuffle combine to support any<br>
number of inputs. The idea is to create a binary tree of shuffles, where<br>
the first layer performs pairwise shuffles of the input vectors placing each<br>
input element into the correct lane, and the rest of the tree blends these<br>
shuffles together.<br>
<br>
This doesn't try to be smart and create any sort of "optimal" shuffles.<br>
The assumption is that even a "poor" shuffle sequence is better than extracting<br>
and inserting the elements one by one.<br>
<br>
Differential Revision: <a href="https://reviews.llvm.org/D24683" rel="noreferrer" target="_blank">https://reviews.llvm.org/D2468<wbr>3</a><br>
<br>
<br>
Modified:<br>
    llvm/trunk/lib/CodeGen/Selecti<wbr>onDAG/DAGCombiner.cpp<br>
    llvm/trunk/test/CodeGen/PowerP<wbr>C/pr27078.ll<br>
    llvm/trunk/test/CodeGen/X86/od<wbr>dshuffles.ll<br>
    llvm/trunk/test/CodeGen/X86/ve<wbr>ctor-trunc-math.ll<br>
    llvm/trunk/test/CodeGen/X86/ve<wbr>ctor-trunc.ll<br>
<br>
Modified: llvm/trunk/lib/CodeGen/Selecti<wbr>onDAG/DAGCombiner.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/DAGCombiner.cpp?rev=283480&r1=283479&r2=283480&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-pr<wbr>oject/llvm/trunk/lib/CodeGen/<wbr>SelectionDAG/DAGCombiner.cpp?<wbr>rev=283480&r1=283479&r2=<wbr>283480&view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- llvm/trunk/lib/CodeGen/Selecti<wbr>onDAG/DAGCombiner.cpp (original)<br>
+++ llvm/trunk/lib/CodeGen/Selecti<wbr>onDAG/DAGCombiner.cpp Thu Oct  6 13:58:24 2016<br>
@@ -379,6 +379,9 @@ namespace {<br>
     SDValue reduceBuildVecExtToExtBuildVec<wbr>(SDNode *N);<br>
     SDValue reduceBuildVecConvertToConvert<wbr>BuildVec(SDNode *N);<br>
     SDValue reduceBuildVecToShuffle(SDNode *N);<br>
+    SDValue createBuildVecShuffle(SDLoc DL, SDNode *N, ArrayRef<int> VectorMask,<br>
+                                  SDValue VecIn1, SDValue VecIn2,<br>
+                                  unsigned LeftIdx);<br>
<br>
     SDValue GetDemandedBits(SDValue V, const APInt &Mask);<br>
<br>
@@ -12874,138 +12877,40 @@ SDValue DAGCombiner::reduceBuildVecCon<wbr>ve<br>
   return DAG.getNode(Opcode, dl, VT, BV);<br>
 }<br>
<br>
-// If Vec holds a reference to a non-null node, return Vec.<br>
-// Otherwise, return either a zero or an undef node of the appropriate type.<br>
-static SDValue getRightHandValue(SelectionDAG &DAG, SDLoc DL, SDValue Vec,<br>
-                                 EVT VT, bool Zero) {<br>
-  if (Vec.getNode())<br>
-    return Vec;<br>
-<br>
-  if (Zero)<br>
-    return VT.isInteger() ? DAG.getConstant(0, DL, VT)<br>
-                          : DAG.getConstantFP(0.0, DL, VT);<br>
-<br>
-  return DAG.getUNDEF(VT);<br>
-}<br>
+SDValue DAGCombiner::createBuildVecShu<wbr>ffle(SDLoc DL, SDNode *N,<br>
+                                           ArrayRef<int> VectorMask,<br>
+                                           SDValue VecIn1, SDValue VecIn2,<br>
+                                           unsigned LeftIdx) {<br>
+  MVT IdxTy = TLI.getVectorIdxTy(DAG.getData<wbr>Layout());<br>
+  SDValue ZeroIdx = DAG.getConstant(0, DL, IdxTy);<br>
<br>
-// Check to see if this is a BUILD_VECTOR of a bunch of EXTRACT_VECTOR_ELT<br>
-// operations.  If so, and if the EXTRACT_VECTOR_ELT vector inputs come from<br>
-// at most two distinct vectors, turn this into a shuffle node.<br>
-// TODO: Support more than two inputs by constructing a tree of shuffles.<br>
-SDValue DAGCombiner::reduceBuildVecToS<wbr>huffle(SDNode *N) {<br>
-  SDLoc dl(N);<br>
   EVT VT = N->getValueType(0);<br>
-<br>
-  // Only type-legal BUILD_VECTOR nodes are converted to shuffle nodes.<br>
-  if (!isTypeLegal(VT))<br>
-    return SDValue();<br>
-<br>
-  // May only combine to shuffle after legalize if shuffle is legal.<br>
-  if (LegalOperations && !TLI.isOperationLegal(ISD::VEC<wbr>TOR_SHUFFLE, VT))<br>
-    return SDValue();<br>
-<br>
-  SDValue VecIn1, VecIn2;<br>
-  bool UsesZeroVector = false;<br>
-  unsigned NumElems = N->getNumOperands();<br>
-<br>
-  // Record, for each element of newly built vector, which input it uses.<br>
-  // 0 stands for the zero vector, 1 and 2 for the two input vectors, and -1<br>
-  // for undef.<br>
-  SmallVector<int, 8> VectorMask;<br>
-  for (unsigned i = 0; i != NumElems; ++i) {<br>
-    SDValue Op = N->getOperand(i);<br>
-<br>
-    if (Op.isUndef()) {<br>
-      VectorMask.push_back(-1);<br>
-      continue;<br>
-    }<br>
-<br>
-    // See if we can combine this into a blend with a zero vector.<br>
-    if (!VecIn2.getNode() && (isNullConstant(Op) || isNullFPConstant(Op))) {<br>
-      UsesZeroVector = true;<br>
-      VectorMask.push_back(0);<br>
-      continue;<br>
-    }<br>
-<br>
-    // Not an undef or zero. If the input is something other than an<br>
-    // EXTRACT_VECTOR_ELT with a constant index, bail out.<br>
-    if (Op.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||<br>
-        !isa<ConstantSDNode>(Op.getOpe<wbr>rand(1)))<br>
-      return SDValue();<br>
-<br>
-    // We only allow up to two distinct input vectors.<br>
-    SDValue ExtractedFromVec = Op.getOperand(0);<br>
-    if (ExtractedFromVec == VecIn1) {<br>
-      VectorMask.push_back(1);<br>
-      continue;<br>
-    }<br>
-    if (ExtractedFromVec == VecIn2) {<br>
-      VectorMask.push_back(2);<br>
-      continue;<br>
-    }<br>
-<br>
-    if (!VecIn1.getNode()) {<br>
-      VecIn1 = ExtractedFromVec;<br>
-      VectorMask.push_back(1);<br>
-    } else if (!VecIn2.getNode() && !UsesZeroVector) {<br>
-      VecIn2 = ExtractedFromVec;<br>
-      VectorMask.push_back(2);<br>
-    } else {<br>
-      return SDValue();<br>
-    }<br>
-  }<br>
-<br>
-  // If we didn't find at least one input vector, bail out.<br>
-  if (!VecIn1.getNode())<br>
-    return SDValue();<br>
-<br>
   EVT InVT1 = VecIn1.getValueType();<br>
   EVT InVT2 = VecIn2.getNode() ? VecIn2.getValueType() : InVT1;<br>
+<br>
   unsigned Vec2Offset = InVT1.getVectorNumElements();<br>
+  unsigned NumElems = VT.getVectorNumElements();<br>
   unsigned ShuffleNumElems = NumElems;<br>
<br>
-  MVT IdxTy = TLI.getVectorIdxTy(DAG.getData<wbr>Layout());<br>
-  SDValue ZeroIdx = DAG.getConstant(0, dl, IdxTy);<br>
-<br>
   // We can't generate a shuffle node with mismatched input and output types.<br>
-  // Try to make the types match.<br>
-  // TODO: Should this fire if InVT1/InVT2 are not legal types, or should<br>
-  // we let legalization run its course first?<br>
+  // Try to make the types match the type of the output.<br>
   if (InVT1 != VT || InVT2 != VT) {<br>
-    // Both inputs and the output must have the same base element type.<br>
-    EVT ElemType = VT.getVectorElementType();<br>
-    if (ElemType != InVT1.getVectorElementType() ||<br>
-        ElemType != InVT2.getVectorElementType())<br>
-      return SDValue();<br>
-<br>
-    // TODO: Canonicalize this so that if the vectors have different lengths,<br>
-    // VecIn1 is always longer.<br>
-<br>
-    // The element types match, now figure out the lengths.<br>
     if (InVT1.getSizeInBits() * 2 == VT.getSizeInBits() && InVT1 == InVT2) {<br>
       // If both input vectors are exactly half the size of the output, concat<br>
       // them. If we have only one (non-zero) input, concat it with undef.<br>
-      VecIn1 = DAG.getNode(ISD::CONCAT_VECTOR<wbr>S, dl, VT, VecIn1,<br>
-                           getRightHandValue(DAG, dl, VecIn2, InVT1, false));<br>
+      VecIn1 = DAG.getNode(ISD::CONCAT_VECTOR<wbr>S, DL, VT, VecIn1,<br>
+                           VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(InVT1));<br>
       VecIn2 = SDValue();<br>
-      // If we have one "real" input and are blending with zero, we need the<br>
-      // zero elements to come from the second input, not the undef part of the<br>
-      // first input.<br>
-      if (UsesZeroVector)<br>
-        Vec2Offset = NumElems;<br>
     } else if (InVT1.getSizeInBits() == VT.getSizeInBits() * 2) {<br>
       if (!TLI.isExtractSubvectorCheap(<wbr>VT, NumElems))<br>
         return SDValue();<br>
<br>
-      if (UsesZeroVector)<br>
-        return SDValue();<br>
-<br>
       if (!VecIn2.getNode()) {<br>
         // If we only have one input vector, and it's twice the size of the<br>
-        // output, split it in two.<br>
-        VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, dl, VT, VecIn1,<br>
-                             DAG.getConstant(NumElems, dl, IdxTy));<br>
-        VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, dl, VT, VecIn1, ZeroIdx);<br>
+        // output, split it in two.<br>
+        VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, DL, VT, VecIn1,<br>
+                             DAG.getConstant(NumElems, DL, IdxTy));<br>
+        VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, DL, VT, VecIn1, ZeroIdx);<br>
         // Since we now have shorter input vectors, adjust the offset of the<br>
         // second vector's start.<br>
         Vec2Offset = NumElems;<br>
@@ -13013,20 +12918,21 @@ SDValue DAGCombiner::reduceBuildVecToS<wbr>hu<br>
         // VecIn1 is wider than the output, and we have another, possibly<br>
         // smaller input. Pad the smaller input with undefs, shuffle at the<br>
         // input vector width, and extract the output.<br>
-<br>
         // The shuffle type is different than VT, so check legality again.<br>
         if (LegalOperations &&<br>
             !TLI.isOperationLegal(ISD::VE<wbr>CTOR_SHUFFLE, InVT1))<br>
           return SDValue();<br>
<br>
         if (InVT1 != InVT2)<br>
-          VecIn2 = DAG.getNode(ISD::INSERT_SUBVEC<wbr>TOR, dl, InVT1,<br>
+          VecIn2 = DAG.getNode(ISD::INSERT_SUBVEC<wbr>TOR, DL, InVT1,<br>
                                DAG.getUNDEF(InVT1), VecIn2, ZeroIdx);<br>
         ShuffleNumElems = NumElems * 2;<br>
       }<br>
     } else {<br>
       // TODO: Support cases where the length mismatch isn't exactly by a<br>
       // factor of 2.<br>
+      // TODO: Move this check upwards, so that if we have bad type<br>
+      // mismatches, we don't create any DAG nodes.<br>
       return SDValue();<br>
     }<br>
   }<br>
@@ -13038,27 +12944,18 @@ SDValue DAGCombiner::reduceBuildVecToS<wbr>hu<br>
   // total number of elements in the shuffle - if we are shuffling a wider<br>
   // vector, the high lanes should be set to undef.<br>
   for (unsigned i = 0; i != NumElems; ++i) {<br>
-    if (VectorMask[i] == -1)<br>
-      continue;<br>
-<br>
-    // If we are trying to blend with zero, we need to take a zero from the<br>
-    // correct position in the second input.<br>
-    if (VectorMask[i] == 0) {<br>
-      Mask[i] = Vec2Offset + i;<br>
+    if (VectorMask[i] <= 0)<br>
       continue;<br>
-    }<br>
<br>
     SDValue Extract = N->getOperand(i);<br>
     unsigned ExtIndex =<br>
         cast<ConstantSDNode>(Extract.<wbr>getOperand(1))->getZExtValue()<wbr>;<br>
<br>
-    if (VectorMask[i] == 1) {<br>
+    if (VectorMask[i] == (int)LeftIdx) {<br>
       Mask[i] = ExtIndex;<br>
-      continue;<br>
+    } else if (VectorMask[i] == (int)LeftIdx + 1) {<br>
+      Mask[i] = Vec2Offset + ExtIndex;<br>
     }<br>
-<br>
-    assert(VectorMask[i] == 2 && "Expected input to be from second vector");<br>
-    Mask[i] = Vec2Offset + ExtIndex;<br>
   }<br>
<br>
   // The type the input vectors may have changed above.<br>
@@ -13066,20 +12963,179 @@ SDValue DAGCombiner::reduceBuildVecToS<wbr>hu<br>
<br>
   // If we already have a VecIn2, it should have the same type as VecIn1.<br>
   // If we don't, get an undef/zero vector of the appropriate type.<br>
-  VecIn2 = getRightHandValue(DAG, dl, VecIn2, InVT1, UsesZeroVector);<br>
+  VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(InVT1);<br>
   assert(InVT1 == VecIn2.getValueType() && "Unexpected second input type.");<br>
<br>
-  // Return the new VECTOR_SHUFFLE node.<br>
-  SDValue Ops[2];<br>
-  Ops[0] = VecIn1;<br>
-  Ops[1] = VecIn2;<br>
-  SDValue Shuffle = DAG.getVectorShuffle(InVT1, dl, Ops[0], Ops[1], Mask);<br>
+  SDValue Shuffle = DAG.getVectorShuffle(InVT1, DL, VecIn1, VecIn2, Mask);<br>
   if (ShuffleNumElems > NumElems)<br>
-    Shuffle = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, dl, VT, Shuffle, ZeroIdx);<br>
+    Shuffle = DAG.getNode(ISD::EXTRACT_SUBVE<wbr>CTOR, DL, VT, Shuffle, ZeroIdx);<br>
<br>
   return Shuffle;<br>
 }<br>
<br>
+// Check to see if this is a BUILD_VECTOR of a bunch of EXTRACT_VECTOR_ELT<br>
+// operations. If the types of the vectors we're extracting from allow it,<br>
+// turn this into a vector_shuffle node.<br>
+SDValue DAGCombiner::reduceBuildVecToS<wbr>huffle(SDNode *N) {<br>
+  SDLoc dl(N);<br>
+  EVT VT = N->getValueType(0);<br>
+<br>
+  // Only type-legal BUILD_VECTOR nodes are converted to shuffle nodes.<br>
+  if (!isTypeLegal(VT))<br>
+    return SDValue();<br>
+<br>
+  // May only combine to shuffle after legalize if shuffle is legal.<br>
+  if (LegalOperations && !TLI.isOperationLegal(ISD::VEC<wbr>TOR_SHUFFLE, VT))<br>
+    return SDValue();<br>
+<br>
+  bool UsesZeroVector = false;<br>
+  unsigned NumElems = N->getNumOperands();<br>
+<br>
+  // Record, for each element of the newly built vector, which input vector<br>
+  // that element comes from. -1 stands for undef, 0 for the zero vector,<br>
+  // and positive values for the input vectors.<br>
+  // VectorMask maps each element to its vector number, and VecIn maps vector<br>
+  // numbers to their initial SDValues.<br>
+<br>
+  SmallVector<int, 8> VectorMask(NumElems, -1);<br>
+  SmallVector<SDValue, 8> VecIn;<br>
+  VecIn.push_back(SDValue());<br>
+<br>
+  for (unsigned i = 0; i != NumElems; ++i) {<br>
+    SDValue Op = N->getOperand(i);<br>
+<br>
+    if (Op.isUndef())<br>
+      continue;<br>
+<br>
+    // See if we can use a blend with a zero vector.<br>
+    // TODO: Should we generalize this to a blend with an arbitrary constant<br>
+    // vector?<br>
+    if (isNullConstant(Op) || isNullFPConstant(Op)) {<br>
+      UsesZeroVector = true;<br>
+      VectorMask[i] = 0;<br>
+      continue;<br>
+    }<br>
+<br>
+    // Not an undef or zero. If the input is something other than an<br>
+    // EXTRACT_VECTOR_ELT with a constant index, bail out.<br>
+    if (Op.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||<br>
+        !isa<ConstantSDNode>(Op.getOpe<wbr>rand(1)))<br>
+      return SDValue();<br>
+<br>
+    SDValue ExtractedFromVec = Op.getOperand(0);<br>
+<br>
+    // All inputs must have the same element type as the output.<br>
+    if (VT.getVectorElementType() !=<br>
+        ExtractedFromVec.getValueType(<wbr>).getVectorElementType())<br>
+      return SDValue();<br>
+<br>
+    // Have we seen this input vector before?<br>
+    // The vectors are expected to be tiny (usually 1 or 2 elements), so using<br>
+    // a map back from SDValues to numbers isn't worth it.<br>
+    unsigned Idx = std::distance(<br>
+        VecIn.begin(), std::find(VecIn.begin(), VecIn.end(), ExtractedFromVec));<br>
+    if (Idx == VecIn.size())<br>
+      VecIn.push_back(ExtractedFromV<wbr>ec);<br>
+<br>
+    VectorMask[i] = Idx;<br>
+  }<br>
+<br>
+  // If we didn't find at least one input vector, bail out.<br>
+  if (VecIn.size() < 2)<br>
+    return SDValue();<br>
+<br>
+  // TODO: We want to sort the vectors by descending length, so that adjacent<br>
+  // pairs have similar length, and the longer vector is always first in the<br>
+  // pair.<br>
+<br>
+  // TODO: Should this fire if some of the input vectors has illegal type (like<br>
+  // it does now), or should we let legalization run its course first?<br>
+<br>
+  // Shuffle phase:<br>
+  // Take pairs of vectors, and shuffle them so that the result has elements<br>
+  // from these vectors in the correct places.<br>
+  // For example, given:<br>
+  // t10: i32 = extract_vector_elt t1, Constant:i64<0><br>
+  // t11: i32 = extract_vector_elt t2, Constant:i64<0><br>
+  // t12: i32 = extract_vector_elt t3, Constant:i64<0><br>
+  // t13: i32 = extract_vector_elt t1, Constant:i64<1><br>
+  // t14: v4i32 = BUILD_VECTOR t10, t11, t12, t13<br>
+  // We will generate:<br>
+  // t20: v4i32 = vector_shuffle<0,4,u,1> t1, t2<br>
+  // t21: v4i32 = vector_shuffle<u,u,0,u> t3, undef<br>
+  SmallVector<SDValue, 4> Shuffles;<br>
+  for (unsigned In = 0, Len = (VecIn.size() / 2); In < Len; ++In) {<br>
+    unsigned LeftIdx = 2 * In + 1;<br>
+    SDValue VecLeft = VecIn[LeftIdx];<br>
+    SDValue VecRight =<br>
+        (LeftIdx + 1) < VecIn.size() ? VecIn[LeftIdx + 1] : SDValue();<br>
+<br>
+    if (SDValue Shuffle = createBuildVecShuffle(dl, N, VectorMask, VecLeft,<br>
+                                                VecRight, LeftIdx))<br>
+      Shuffles.push_back(Shuffle);<br>
+    else<br>
+      return SDValue();<br>
+  }<br>
+<br>
+  // If we need the zero vector as an "ingredient" in the blend tree, add it<br>
+  // to the list of shuffles.<br>
+  if (UsesZeroVector)<br>
+    Shuffles.push_back(VT.isIntege<wbr>r() ? DAG.getConstant(0, dl, VT)<br>
+                                      : DAG.getConstantFP(0.0, dl, VT));<br>
+<br>
+  // If we only have one shuffle, we're done.<br>
+  if (Shuffles.size() == 1)<br>
+    return Shuffles[0];<br>
+<br>
+  // Update the vector mask to point to the post-shuffle vectors.<br>
+  for (int &Vec : VectorMask)<br>
+    if (Vec == 0)<br>
+      Vec = Shuffles.size() - 1;<br>
+    else<br>
+      Vec = (Vec - 1) / 2;<br>
+<br>
+  // More than one shuffle. Generate a binary tree of blends, e.g. if from<br>
+  // the previous step we got the set of shuffles t10, t11, t12, t13, we will<br>
+  // generate:<br>
+  // t10: v8i32 = vector_shuffle<0,8,u,u,u,u,u,u<wbr>> t1, t2<br>
+  // t11: v8i32 = vector_shuffle<u,u,0,8,u,u,u,u<wbr>> t3, t4<br>
+  // t12: v8i32 = vector_shuffle<u,u,u,u,0,8,u,u<wbr>> t5, t6<br>
+  // t13: v8i32 = vector_shuffle<u,u,u,u,u,u,0,8<wbr>> t7, t8<br>
+  // t20: v8i32 = vector_shuffle<0,1,10,11,u,u,u<wbr>,u> t10, t11<br>
+  // t21: v8i32 = vector_shuffle<u,u,u,u,4,5,14,<wbr>15> t12, t13<br>
+  // t30: v8i32 = vector_shuffle<0,1,2,3,12,13,1<wbr>4,15> t20, t21<br>
+<br>
+  // Make sure the initial size of the shuffle list is even.<br>
+  if (Shuffles.size() % 2)<br>
+    Shuffles.push_back(DAG.getUNDE<wbr>F(VT));<br>
+<br>
+  for (unsigned CurSize = Shuffles.size(); CurSize > 1; CurSize /= 2) {<br>
+    if (CurSize % 2) {<br>
+      Shuffles[CurSize] = DAG.getUNDEF(VT);<br>
+      CurSize++;<br>
+    }<br>
+    for (unsigned In = 0, Len = CurSize / 2; In < Len; ++In) {<br>
+      int Left = 2 * In;<br>
+      int Right = 2 * In + 1;<br>
+      SmallVector<int, 8> Mask(NumElems, -1);<br>
+      for (unsigned i = 0; i != NumElems; ++i) {<br>
+        if (VectorMask[i] == Left) {<br>
+          Mask[i] = i;<br>
+          VectorMask[i] = In;<br>
+        } else if (VectorMask[i] == Right) {<br>
+          Mask[i] = i + NumElems;<br>
+          VectorMask[i] = In;<br>
+        }<br>
+      }<br>
+<br>
+      Shuffles[In] =<br>
+          DAG.getVectorShuffle(VT, dl, Shuffles[Left], Shuffles[Right], Mask);<br>
+    }<br>
+  }<br>
+<br>
+  return Shuffles[0];<br>
+}<br>
+<br>
 SDValue DAGCombiner::visitBUILD_VECTOR<wbr>(SDNode *N) {<br>
   EVT VT = N->getValueType(0);<br>
<br>
<br>
Modified: llvm/trunk/test/CodeGen/PowerP<wbr>C/pr27078.ll<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/PowerPC/pr27078.ll?rev=283480&r1=283479&r2=283480&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-pr<wbr>oject/llvm/trunk/test/CodeGen/<wbr>PowerPC/pr27078.ll?rev=283480&<wbr>r1=283479&r2=283480&view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- llvm/trunk/test/CodeGen/PowerP<wbr>C/pr27078.ll (original)<br>
+++ llvm/trunk/test/CodeGen/PowerP<wbr>C/pr27078.ll Thu Oct  6 13:58:24 2016<br>
@@ -9,12 +9,11 @@ define <4 x float> @bar(float* %p, float<br>
   %6 = shufflevector <12 x float> %5, <12 x float> undef, <4 x i32> <i32 0, i32 3, i32 6, i32 9><br>
   ret <4 x float>  %6<br>
<br>
-; CHECK: xxspltw<br>
-; CHECK-NEXT: xxspltw<br>
-; CHECK-NEXT: xxspltw<br>
+; CHECK: vsldoi<br>
 ; CHECK-NEXT: vmrghw<br>
-; CHECK-NEXT: vmrghw<br>
-; CHECK-NEXT: xxswapd<br>
+; CHECK-NEXT: vmrglw<br>
+; CHECK-NEXT: vsldoi<br>
+; CHECK-NEXT: vsldoi<br>
 ; CHECK-NEXT: vsldoi<br>
 ; CHECK-NEXT: blr<br>
 }<br>
<br>
Modified: llvm/trunk/test/CodeGen/X86/od<wbr>dshuffles.ll<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/X86/oddshuffles.ll?rev=283480&r1=283479&r2=283480&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-pr<wbr>oject/llvm/trunk/test/CodeGen/<wbr>X86/oddshuffles.ll?rev=283480&<wbr>r1=283479&r2=283480&view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- llvm/trunk/test/CodeGen/X86/od<wbr>dshuffles.ll (original)<br>
+++ llvm/trunk/test/CodeGen/X86/od<wbr>dshuffles.ll Thu Oct  6 13:58:24 2016<br>
@@ -495,54 +495,45 @@ define void @v12i16(<8 x i16> %a, <8 x i<br>
 define void @v12i32(<8 x i32> %a, <8 x i32> %b, <12 x i32>* %p) nounwind {<br>
 ; SSE2-LABEL: v12i32:<br>
 ; SSE2:       # BB#0:<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm0[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm1[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm1[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm1[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm0[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm0[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm2[1,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm2[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm1[0],xmm7[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm2[2,3,0,1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm6[0],xmm1[1],xmm6[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm7[0],xmm1[1],xmm7[1<wbr>]<br>
-; SSE2-NEXT:    movdqa %xmm1, 32(%rdi)<br>
-; SSE2-NEXT:    movdqa %xmm5, 16(%rdi)<br>
-; SSE2-NEXT:    movdqa %xmm0, (%rdi)<br>
+; SSE2-NEXT:    movdqa %xmm0, %xmm3<br>
+; SSE2-NEXT:    punpckldq {{.*#+}} xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1<wbr>]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm3[0,1,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm2[0,1,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[2,0],xmm3[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[0,1],xmm4[0,2]<br>
+; SSE2-NEXT:    movdqa %xmm2, %xmm4<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[1,0],xmm1[1,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[2,0],xmm1[2,2]<br>
+; SSE2-NEXT:    punpckhdq {{.*#+}} xmm2 = xmm2[2],xmm0[2],xmm2[3],xmm0[3<wbr>]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[2,0],xmm4[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[0,1],xmm0[0,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm2[0,3,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[2,2,3,3]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm1 = xmm1[2,0],xmm0[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[0,1],xmm1[0,2]<br>
+; SSE2-NEXT:    movaps %xmm0, 32(%rdi)<br>
+; SSE2-NEXT:    movaps %xmm4, 16(%rdi)<br>
+; SSE2-NEXT:    movaps %xmm3, (%rdi)<br>
 ; SSE2-NEXT:    retq<br>
 ;<br>
 ; SSE42-LABEL: v12i32:<br>
 ; SSE42:       # BB#0:<br>
-; SSE42-NEXT:    movd %xmm1, %eax<br>
-; SSE42-NEXT:    pextrd $1, %xmm0, %ecx<br>
-; SSE42-NEXT:    pextrd $2, %xmm0, %edx<br>
-; SSE42-NEXT:    pextrd $3, %xmm0, %esi<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm0<br>
-; SSE42-NEXT:    movd %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm0<br>
-; SSE42-NEXT:    pinsrd $3, %ecx, %xmm0<br>
-; SSE42-NEXT:    pextrd $1, %xmm2, %eax<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm1[1,1,2,3]<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm3<br>
-; SSE42-NEXT:    pinsrd $2, %edx, %xmm3<br>
-; SSE42-NEXT:    pextrd $2, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm3<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm2[2,3,0,1]<br>
-; SSE42-NEXT:    pinsrd $1, %esi, %xmm4<br>
-; SSE42-NEXT:    pextrd $3, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrd $3, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm4<br>
-; SSE42-NEXT:    movdqa %xmm4, 32(%rdi)<br>
-; SSE42-NEXT:    movdqa %xmm3, 16(%rdi)<br>
-; SSE42-NEXT:    movdqa %xmm0, (%rdi)<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm1[0,0,1,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm0[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0,1],xmm3[2,3],xmm4[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm2[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm4[0,1,2,3],xmm3[4,5],xmm4[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm1[1,1,2,2]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0,1],xmm2[2,3],xmm4[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0,1,2,3],xmm0[4,5],xmm4[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[2,3,0,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[2,3,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm2 = xmm2[0,1],xmm0[2,3],xmm2[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm1[2,2,3,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm0 = xmm2[0,1,2,3],xmm0[4,5],xmm2[6<wbr>,7]<br>
+; SSE42-NEXT:    movdqa %xmm0, 32(%rdi)<br>
+; SSE42-NEXT:    movdqa %xmm4, 16(%rdi)<br>
+; SSE42-NEXT:    movdqa %xmm3, (%rdi)<br>
 ; SSE42-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: v12i32:<br>
@@ -850,135 +841,84 @@ define void @interleave_24i8_in(<24 x i8<br>
 define void @interleave_24i16_out(<24 x i16>* %p, <8 x i16>* %q1, <8 x i16>* %q2, <8 x i16>* %q3) nounwind {<br>
 ; SSE2-LABEL: interleave_24i16_out:<br>
 ; SSE2:       # BB#0:<br>
-; SSE2-NEXT:    movdqu (%rdi), %xmm2<br>
-; SSE2-NEXT:    movdqu 16(%rdi), %xmm0<br>
-; SSE2-NEXT:    movdqu 32(%rdi), %xmm1<br>
-; SSE2-NEXT:    pextrw $5, %xmm1, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm3<br>
-; SSE2-NEXT:    pextrw $1, %xmm0, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm4<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1<wbr>],xmm4[2],xmm3[2],xmm4[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $7, %xmm0, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm5<br>
-; SSE2-NEXT:    pextrw $3, %xmm2, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm3<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1<wbr>],xmm3[2],xmm5[2],xmm3[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1<wbr>],xmm3[2],xmm4[2],xmm3[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $2, %xmm1, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm5<br>
-; SSE2-NEXT:    pextrw $6, %xmm2, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm4<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1<wbr>],xmm4[2],xmm5[2],xmm4[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $4, %xmm0, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm5<br>
-; SSE2-NEXT:    pextrw $6, %xmm1, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm7<br>
-; SSE2-NEXT:    pextrw $2, %xmm0, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm6<br>
-; SSE2-NEXT:    pextrw $4, %xmm2, %r8d<br>
-; SSE2-NEXT:    pextrw $7, %xmm2, %r9d<br>
-; SSE2-NEXT:    pextrw $1, %xmm2, %r10d<br>
-; SSE2-NEXT:    pextrw $5, %xmm2, %r11d<br>
-; SSE2-NEXT:    pextrw $2, %xmm2, %eax<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm5[0],xmm2[1],xmm5[1<wbr>],xmm2[2],xmm5[2],xmm2[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1<wbr>],xmm2[2],xmm4[2],xmm2[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    movd %r8d, %xmm4<br>
-; SSE2-NEXT:    pextrw $3, %xmm1, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm5<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1<wbr>],xmm2[2],xmm3[2],xmm2[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm6 = xmm6[0],xmm7[0],xmm6[1],xmm7[1<wbr>],xmm6[2],xmm7[2],xmm6[3],xmm7<wbr>[3]<br>
-; SSE2-NEXT:    movd %r9d, %xmm3<br>
-; SSE2-NEXT:    pextrw $5, %xmm0, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm7<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1<wbr>],xmm4[2],xmm1[2],xmm4[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm6[0],xmm4[1],xmm6[1<wbr>],xmm4[2],xmm6[2],xmm4[3],xmm6<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1<wbr>],xmm3[2],xmm5[2],xmm3[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    movd %r10d, %xmm5<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm7[0],xmm5[1],xmm7[1<wbr>],xmm5[2],xmm7[2],xmm5[3],xmm7<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1<wbr>],xmm5[2],xmm3[2],xmm5[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $7, %xmm1, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm3<br>
-; SSE2-NEXT:    pextrw $3, %xmm0, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm6<br>
-; SSE2-NEXT:    pextrw $1, %xmm1, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm7<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1<wbr>],xmm5[2],xmm4[2],xmm5[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm6 = xmm6[0],xmm3[0],xmm6[1],xmm3[1<wbr>],xmm6[2],xmm3[2],xmm6[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    movd %r11d, %xmm3<br>
-; SSE2-NEXT:    pextrw $4, %xmm1, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm1<br>
-; SSE2-NEXT:    pextrw $6, %xmm0, %edi<br>
-; SSE2-NEXT:    movd %edi, %xmm4<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm7[0],xmm3[1],xmm7[1<wbr>],xmm3[2],xmm7[2],xmm3[3],xmm7<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm6[0],xmm3[1],xmm6[1<wbr>],xmm3[2],xmm6[2],xmm3[3],xmm6<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    movd %eax, %xmm1<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1<wbr>],xmm1[2],xmm4[2],xmm1[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1<wbr>],xmm1[2],xmm0[2],xmm1[3],xmm0<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    movdqu %xmm2, (%rsi)<br>
-; SSE2-NEXT:    movdqu %xmm5, (%rdx)<br>
-; SSE2-NEXT:    movdqu %xmm1, (%rcx)<br>
+; SSE2-NEXT:    movdqu (%rdi), %xmm3<br>
+; SSE2-NEXT:    movdqu 16(%rdi), %xmm2<br>
+; SSE2-NEXT:    movdqu 32(%rdi), %xmm8<br>
+; SSE2-NEXT:    movdqa {{.*#+}} xmm1 = [65535,0,65535,65535,0,65535,6<wbr>5535,0]<br>
+; SSE2-NEXT:    movdqa %xmm3, %xmm4<br>
+; SSE2-NEXT:    pand %xmm1, %xmm4<br>
+; SSE2-NEXT:    pandn %xmm2, %xmm1<br>
+; SSE2-NEXT:    por %xmm4, %xmm1<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[0,2,1,3]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm1 = xmm1[0,1,2,3,6,5,6,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[0,2,1,3]<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm1 = xmm1[0,3,2,1,4,5,6,7]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm1 = xmm1[0,1,2,3,4,7,6,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm8[0,1,2,1]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm4 = xmm4[0,1,2,3,4,5,6,5]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[3,0],xmm1[2,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm1 = xmm1[0,1],xmm4[2,0]<br>
+; SSE2-NEXT:    movdqa {{.*#+}} xmm4 = [65535,65535,0,65535,65535,0,6<wbr>5535,65535]<br>
+; SSE2-NEXT:    movdqa %xmm4, %xmm5<br>
+; SSE2-NEXT:    pandn %xmm2, %xmm5<br>
+; SSE2-NEXT:    movdqa %xmm3, %xmm6<br>
+; SSE2-NEXT:    pand %xmm4, %xmm6<br>
+; SSE2-NEXT:    por %xmm5, %xmm6<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm5 = xmm6[2,1,2,3,4,5,6,7]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm5 = xmm5[0,1,2,3,4,5,4,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm5[0,3,2,3]<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm5 = xmm5[1,2,3,0,4,5,6,7]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm5 = xmm5[0,1,2,3,5,5,6,7]<br>
+; SSE2-NEXT:    movdqa {{.*#+}} xmm6 = [65535,65535,65535,65535,65535<wbr>,0,0,0]<br>
+; SSE2-NEXT:    pand %xmm6, %xmm5<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm7 = xmm8[0,3,2,3,4,5,6,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm7[0,1,0,3]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm7 = xmm7[0,1,2,3,4,4,5,6]<br>
+; SSE2-NEXT:    movdqa %xmm6, %xmm0<br>
+; SSE2-NEXT:    pandn %xmm7, %xmm0<br>
+; SSE2-NEXT:    por %xmm5, %xmm0<br>
+; SSE2-NEXT:    pand %xmm4, %xmm2<br>
+; SSE2-NEXT:    pandn %xmm3, %xmm4<br>
+; SSE2-NEXT:    por %xmm2, %xmm4<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm4[3,1,2,0]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm2 = xmm2[0,1,2,3,6,5,6,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[2,1,0,3]<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm2 = xmm2[2,1,0,3,4,5,6,7]<br>
+; SSE2-NEXT:    pand %xmm6, %xmm2<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm3 = xmm8[0,1,2,3,4,7,6,7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm3[0,1,2,0]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm3 = xmm3[0,1,2,3,4,7,4,5]<br>
+; SSE2-NEXT:    pandn %xmm3, %xmm6<br>
+; SSE2-NEXT:    por %xmm2, %xmm6<br>
+; SSE2-NEXT:    movups %xmm1, (%rsi)<br>
+; SSE2-NEXT:    movdqu %xmm0, (%rdx)<br>
+; SSE2-NEXT:    movdqu %xmm6, (%rcx)<br>
 ; SSE2-NEXT:    retq<br>
 ;<br>
 ; SSE42-LABEL: interleave_24i16_out:<br>
 ; SSE42:       # BB#0:<br>
-; SSE42-NEXT:    pushq %rbp<br>
-; SSE42-NEXT:    pushq %rbx<br>
-; SSE42-NEXT:    movdqu (%rdi), %xmm2<br>
+; SSE42-NEXT:    movdqu (%rdi), %xmm0<br>
 ; SSE42-NEXT:    movdqu 16(%rdi), %xmm1<br>
-; SSE42-NEXT:    movdqu 32(%rdi), %xmm0<br>
-; SSE42-NEXT:    pextrw $3, %xmm2, %r8d<br>
-; SSE42-NEXT:    pextrw $6, %xmm2, %r9d<br>
-; SSE42-NEXT:    pextrw $4, %xmm2, %r10d<br>
-; SSE42-NEXT:    pextrw $1, %xmm2, %r11d<br>
-; SSE42-NEXT:    pextrw $7, %xmm2, %ebp<br>
-; SSE42-NEXT:    pextrw $5, %xmm2, %edi<br>
-; SSE42-NEXT:    pextrw $2, %xmm2, %ebx<br>
-; SSE42-NEXT:    pinsrw $1, %r8d, %xmm2<br>
-; SSE42-NEXT:    pinsrw $2, %r9d, %xmm2<br>
-; SSE42-NEXT:    pextrw $1, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $3, %eax, %xmm2<br>
-; SSE42-NEXT:    pextrw $4, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm2<br>
-; SSE42-NEXT:    pextrw $7, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm2<br>
-; SSE42-NEXT:    pextrw $2, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $6, %eax, %xmm2<br>
-; SSE42-NEXT:    pextrw $5, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm2<br>
-; SSE42-NEXT:    movd %r11d, %xmm3<br>
-; SSE42-NEXT:    pinsrw $1, %r10d, %xmm3<br>
-; SSE42-NEXT:    pinsrw $2, %ebp, %xmm3<br>
-; SSE42-NEXT:    pextrw $2, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $3, %eax, %xmm3<br>
-; SSE42-NEXT:    pextrw $5, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm3<br>
-; SSE42-NEXT:    movd %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm3<br>
-; SSE42-NEXT:    pextrw $3, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $6, %eax, %xmm3<br>
-; SSE42-NEXT:    pextrw $6, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm3<br>
-; SSE42-NEXT:    movd %ebx, %xmm4<br>
-; SSE42-NEXT:    pinsrw $1, %edi, %xmm4<br>
-; SSE42-NEXT:    movd %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $2, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $3, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $3, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $6, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $1, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $4, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $6, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $7, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm4<br>
-; SSE42-NEXT:    movdqu %xmm2, (%rsi)<br>
-; SSE42-NEXT:    movdqu %xmm3, (%rdx)<br>
-; SSE42-NEXT:    movdqu %xmm4, (%rcx)<br>
-; SSE42-NEXT:    popq %rbx<br>
-; SSE42-NEXT:    popq %rbp<br>
+; SSE42-NEXT:    movdqu 32(%rdi), %xmm2<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm2[0,1,2,1]<br>
+; SSE42-NEXT:    pshufhw {{.*#+}} xmm3 = xmm3[0,1,2,3,4,5,6,5]<br>
+; SSE42-NEXT:    movdqa %xmm0, %xmm4<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0],xmm1[1],xmm4[2,3],xmm1<wbr>[4],xmm4[5,6],xmm1[7]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm4 = xmm4[0,1,6,7,12,13,2,3,8,9,14,<wbr>15,12,13,14,15]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0,1,2,3,4,5],xmm3[6,7]<br>
+; SSE42-NEXT:    movdqa %xmm2, %xmm3<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm3 = xmm3[0,1,6,7,4,5,6,7,0,1,0,1,6<wbr>,7,12,13]<br>
+; SSE42-NEXT:    movdqa %xmm0, %xmm5<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm5 = xmm5[0,1],xmm1[2],xmm5[3,4],xm<wbr>m1[5],xmm5[6,7]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm5 = xmm5[2,3,8,9,14,15,4,5,10,11,1<wbr>0,11,8,9,14,15]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm5 = xmm5[0,1,2,3,4],xmm3[5,6,7]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm2 = xmm2[0,1,2,3,4,5,6,7,8,9,2,3,8<wbr>,9,14,15]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm1 = xmm1[0,1],xmm0[2],xmm1[3,4],xm<wbr>m0[5],xmm1[6,7]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm1 = xmm1[4,5,10,11,0,1,6,7,12,13,1<wbr>4,15,0,1,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm1 = xmm1[0,1,2,3,4],xmm2[5,6,7]<br>
+; SSE42-NEXT:    movdqu %xmm4, (%rsi)<br>
+; SSE42-NEXT:    movdqu %xmm5, (%rdx)<br>
+; SSE42-NEXT:    movdqu %xmm1, (%rcx)<br>
 ; SSE42-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: interleave_24i16_out:<br>
@@ -1039,143 +979,66 @@ define void @interleave_24i16_out(<24 x<br>
 define void @interleave_24i16_in(<24 x i16>* %p, <8 x i16>* %q1, <8 x i16>* %q2, <8 x i16>* %q3) nounwind {<br>
 ; SSE2-LABEL: interleave_24i16_in:<br>
 ; SSE2:       # BB#0:<br>
-; SSE2-NEXT:    pushq %rbp<br>
-; SSE2-NEXT:    pushq %r15<br>
-; SSE2-NEXT:    pushq %r14<br>
-; SSE2-NEXT:    pushq %r13<br>
-; SSE2-NEXT:    pushq %r12<br>
-; SSE2-NEXT:    pushq %rbx<br>
-; SSE2-NEXT:    movdqu (%rsi), %xmm0<br>
+; SSE2-NEXT:    movdqu (%rsi), %xmm3<br>
 ; SSE2-NEXT:    movdqu (%rdx), %xmm2<br>
 ; SSE2-NEXT:    movdqu (%rcx), %xmm1<br>
-; SSE2-NEXT:    pextrw $2, %xmm2, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm4<br>
-; SSE2-NEXT:    pextrw $1, %xmm0, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm3<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1<wbr>],xmm3[2],xmm4[2],xmm3[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $1, %xmm1, %eax<br>
-; SSE2-NEXT:    movd %eax, %xmm4<br>
-; SSE2-NEXT:    pextrw $1, %xmm2, %r8d<br>
-; SSE2-NEXT:    pextrw $4, %xmm2, %r9d<br>
-; SSE2-NEXT:    pextrw $3, %xmm2, %r10d<br>
-; SSE2-NEXT:    pextrw $6, %xmm2, %r11d<br>
-; SSE2-NEXT:    pextrw $7, %xmm2, %r14d<br>
-; SSE2-NEXT:    pextrw $5, %xmm2, %r15d<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1<wbr>],xmm2[2],xmm4[2],xmm2[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1<wbr>],xmm2[2],xmm3[2],xmm2[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    pextrw $2, %xmm0, %edx<br>
-; SSE2-NEXT:    movd %edx, %xmm3<br>
-; SSE2-NEXT:    pextrw $3, %xmm1, %edx<br>
-; SSE2-NEXT:    pextrw $4, %xmm1, %esi<br>
-; SSE2-NEXT:    pextrw $2, %xmm1, %ebx<br>
-; SSE2-NEXT:    pextrw $7, %xmm1, %ebp<br>
-; SSE2-NEXT:    pextrw $5, %xmm1, %r13d<br>
-; SSE2-NEXT:    pextrw $6, %xmm1, %r12d<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    movd %r8d, %xmm3<br>
-; SSE2-NEXT:    pextrw $5, %xmm0, %ecx<br>
-; SSE2-NEXT:    movd %ecx, %xmm4<br>
-; SSE2-NEXT:    movd %edx, %xmm5<br>
-; SSE2-NEXT:    movd %r9d, %xmm6<br>
-; SSE2-NEXT:    pextrw $3, %xmm0, %ecx<br>
-; SSE2-NEXT:    movd %ecx, %xmm7<br>
-; SSE2-NEXT:    pextrw $4, %xmm0, %ecx<br>
-; SSE2-NEXT:    pextrw $7, %xmm0, %edx<br>
-; SSE2-NEXT:    pextrw $6, %xmm0, %eax<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1<wbr>],xmm0[2],xmm3[2],xmm0[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    movd %esi, %xmm3<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    movd %r10d, %xmm1<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1<wbr>],xmm0[2],xmm2[2],xmm0[3],xmm2<wbr>[3]<br>
-; SSE2-NEXT:    movd %ecx, %xmm2<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1<wbr>],xmm5[2],xmm4[2],xmm5[3],xmm4<wbr>[3]<br>
-; SSE2-NEXT:    movd %ebx, %xmm4<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm7 = xmm7[0],xmm6[0],xmm7[1],xmm6[1<wbr>],xmm7[2],xmm6[2],xmm7[3],xmm6<wbr>[3]<br>
-; SSE2-NEXT:    movd %ebp, %xmm6<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1<wbr>],xmm7[2],xmm5[2],xmm7[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    movd %r11d, %xmm5<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    movd %edx, %xmm3<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1<wbr>],xmm4[2],xmm2[2],xmm4[3],xmm2<wbr>[3]<br>
-; SSE2-NEXT:    movd %r13d, %xmm2<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1<wbr>],xmm4[2],xmm1[2],xmm4[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    movd %r14d, %xmm1<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1<wbr>],xmm4[2],xmm7[2],xmm4[3],xmm7<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm6[0],xmm5[1],xmm6[1<wbr>],xmm5[2],xmm6[2],xmm5[3],xmm6<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1<wbr>],xmm2[2],xmm3[2],xmm2[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm5[0],xmm2[1],xmm5[1<wbr>],xmm2[2],xmm5[2],xmm2[3],xmm5<wbr>[3]<br>
-; SSE2-NEXT:    movd %eax, %xmm3<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1<wbr>],xmm3[2],xmm1[2],xmm3[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    movd %r12d, %xmm1<br>
-; SSE2-NEXT:    movd %r15d, %xmm5<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1<wbr>],xmm5[2],xmm1[2],xmm5[3],xmm1<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1<wbr>],xmm5[2],xmm3[2],xmm5[3],xmm3<wbr>[3]<br>
-; SSE2-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1<wbr>],xmm5[2],xmm2[2],xmm5[3],xmm2<wbr>[3]<br>
-; SSE2-NEXT:    movdqu %xmm5, 32(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm4, 16(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm0, (%rdi)<br>
-; SSE2-NEXT:    popq %rbx<br>
-; SSE2-NEXT:    popq %r12<br>
-; SSE2-NEXT:    popq %r13<br>
-; SSE2-NEXT:    popq %r14<br>
-; SSE2-NEXT:    popq %r15<br>
-; SSE2-NEXT:    popq %rbp<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm1[0,0,0,3]<br>
+; SSE2-NEXT:    movdqa {{.*#+}} xmm0 = [65535,65535,0,65535,65535,0,6<wbr>5535,65535]<br>
+; SSE2-NEXT:    movdqa %xmm0, %xmm5<br>
+; SSE2-NEXT:    pandn %xmm4, %xmm5<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm3[0,3,3,3]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm3[1,1,2,2]<br>
+; SSE2-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1<wbr>],xmm3[2],xmm2[2],xmm3[3],xmm2<wbr>[3]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm3[0,1,2,1]<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm3 = xmm3[0,1,2,2,4,5,6,7]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm3 = xmm3[0,1,2,3,7,5,4,5]<br>
+; SSE2-NEXT:    pand %xmm0, %xmm3<br>
+; SSE2-NEXT:    por %xmm5, %xmm3<br>
+; SSE2-NEXT:    movdqa %xmm0, %xmm5<br>
+; SSE2-NEXT:    pandn %xmm4, %xmm5<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm4 = xmm2[0,1,3,3,4,5,6,7]<br>
+; SSE2-NEXT:    punpckhwd {{.*#+}} xmm2 = xmm2[4],xmm1[4],xmm2[5],xmm1[5<wbr>],xmm2[6],xmm1[6],xmm2[7],xmm1<wbr>[7]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[2,1,2,3]<br>
+; SSE2-NEXT:    pshuflw {{.*#+}} xmm2 = xmm2[2,3,2,0,4,5,6,7]<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm2 = xmm2[0,1,2,3,5,5,6,7]<br>
+; SSE2-NEXT:    pand %xmm0, %xmm2<br>
+; SSE2-NEXT:    por %xmm5, %xmm2<br>
+; SSE2-NEXT:    movdqa {{.*#+}} xmm5 = [65535,0,65535,65535,0,65535,6<wbr>5535,0]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[1,1,2,2]<br>
+; SSE2-NEXT:    pand %xmm5, %xmm1<br>
+; SSE2-NEXT:    pandn %xmm6, %xmm5<br>
+; SSE2-NEXT:    por %xmm1, %xmm5<br>
+; SSE2-NEXT:    pand %xmm0, %xmm5<br>
+; SSE2-NEXT:    pshufhw {{.*#+}} xmm1 = xmm4[0,1,2,3,4,4,6,7]<br>
+; SSE2-NEXT:    pandn %xmm1, %xmm0<br>
+; SSE2-NEXT:    por %xmm5, %xmm0<br>
+; SSE2-NEXT:    movdqu %xmm0, 16(%rdi)<br>
+; SSE2-NEXT:    movdqu %xmm2, 32(%rdi)<br>
+; SSE2-NEXT:    movdqu %xmm3, (%rdi)<br>
 ; SSE2-NEXT:    retq<br>
 ;<br>
 ; SSE42-LABEL: interleave_24i16_in:<br>
 ; SSE42:       # BB#0:<br>
-; SSE42-NEXT:    movdqu (%rsi), %xmm3<br>
-; SSE42-NEXT:    movdqu (%rdx), %xmm0<br>
+; SSE42-NEXT:    movdqu (%rsi), %xmm0<br>
+; SSE42-NEXT:    movdqu (%rdx), %xmm1<br>
 ; SSE42-NEXT:    movdqu (%rcx), %xmm2<br>
-; SSE42-NEXT:    pextrw $3, %xmm3, %eax<br>
-; SSE42-NEXT:    pextrw $2, %xmm2, %ecx<br>
-; SSE42-NEXT:    movd %ecx, %xmm1<br>
-; SSE42-NEXT:    pinsrw $1, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $3, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $2, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $3, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $3, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $4, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $4, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $4, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $6, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $5, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrw $5, %xmm2, %eax<br>
-; SSE42-NEXT:    pextrw $5, %xmm0, %ecx<br>
-; SSE42-NEXT:    movd %ecx, %xmm4<br>
-; SSE42-NEXT:    pinsrw $1, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $6, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrw $2, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $6, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $3, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $6, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $7, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $7, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $6, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrw $7, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm4<br>
-; SSE42-NEXT:    movd %xmm0, %eax<br>
-; SSE42-NEXT:    pextrw $1, %xmm3, %ecx<br>
-; SSE42-NEXT:    pextrw $2, %xmm3, %edx<br>
-; SSE42-NEXT:    pinsrw $1, %eax, %xmm3<br>
-; SSE42-NEXT:    movd %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $2, %eax, %xmm3<br>
-; SSE42-NEXT:    pinsrw $3, %ecx, %xmm3<br>
-; SSE42-NEXT:    pextrw $1, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $4, %eax, %xmm3<br>
-; SSE42-NEXT:    pextrw $1, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrw $5, %eax, %xmm3<br>
-; SSE42-NEXT:    pinsrw $6, %edx, %xmm3<br>
-; SSE42-NEXT:    pextrw $2, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrw $7, %eax, %xmm3<br>
-; SSE42-NEXT:    movdqu %xmm3, (%rdi)<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm0[1,1,2,2]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm0[0,3,3,3]<br>
+; SSE42-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm0 = xmm0[0,1,2,3,4,5,4,5,6,7,10,11<wbr>,8,9,10,11]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm2[0,0,0,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm5 = xmm0[0,1],xmm5[2],xmm0[3,4],xm<wbr>m5[5],xmm0[6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm2[1,1,2,2]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm0 = xmm0[0],xmm3[1],xmm0[2,3],xmm3<wbr>[4],xmm0[5,6],xmm3[7]<br>
+; SSE42-NEXT:    pshuflw {{.*#+}} xmm3 = xmm1[0,1,3,3,4,5,6,7]<br>
+; SSE42-NEXT:    pshufhw {{.*#+}} xmm3 = xmm3[0,1,2,3,4,4,6,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm0[0,1],xmm3[2],xmm0[3,4],xm<wbr>m3[5],xmm0[6,7]<br>
+; SSE42-NEXT:    punpckhwd {{.*#+}} xmm1 = xmm1[4],xmm2[4],xmm1[5],xmm2[5<wbr>],xmm1[6],xmm2[6],xmm1[7],xmm2<wbr>[7]<br>
+; SSE42-NEXT:    pshufb {{.*#+}} xmm1 = xmm1[4,5,6,7,4,5,8,9,10,11,10,<wbr>11,12,13,14,15]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm1[0,1],xmm4[2],xmm1[3,4],xm<wbr>m4[5],xmm1[6,7]<br>
 ; SSE42-NEXT:    movdqu %xmm4, 32(%rdi)<br>
-; SSE42-NEXT:    movdqu %xmm1, 16(%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm3, 16(%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm5, (%rdi)<br>
 ; SSE42-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: interleave_24i16_in:<br>
@@ -1238,164 +1101,125 @@ define void @interleave_24i16_in(<24 x i<br>
 define void @interleave_24i32_out(<24 x i32>* %p, <8 x i32>* %q1, <8 x i32>* %q2, <8 x i32>* %q3) nounwind {<br>
 ; SSE2-LABEL: interleave_24i32_out:<br>
 ; SSE2:       # BB#0:<br>
+; SSE2-NEXT:    movdqu 80(%rdi), %xmm8<br>
 ; SSE2-NEXT:    movdqu 64(%rdi), %xmm10<br>
-; SSE2-NEXT:    movdqu 80(%rdi), %xmm9<br>
-; SSE2-NEXT:    movdqu (%rdi), %xmm5<br>
-; SSE2-NEXT:    movdqu 16(%rdi), %xmm12<br>
-; SSE2-NEXT:    movdqu 32(%rdi), %xmm11<br>
-; SSE2-NEXT:    movdqu 48(%rdi), %xmm4<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm11[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm5[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm6[0],xmm7[1],xmm6[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm12[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm13 = xmm5[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm5[2,3,0,1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm8[0],xmm5[1],xmm8[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm7[0],xmm5[1],xmm7[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm9[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm4[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm7[0],xmm1[1],xmm7[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm10[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm4[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm4[2,3,0,1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm4 = xmm4[0],xmm8[0],xmm4[1],xmm8[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm11[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm12[3,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm12[1,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm12 = xmm12[0],xmm8[0],xmm12[1],xmm8<wbr>[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm13 = xmm13[0],xmm3[0],xmm13[1],xmm3<wbr>[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm13 = xmm13[0],xmm12[0],xmm13[1],xmm<wbr>12[1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm12 = xmm9[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm10[3,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm10[1,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm10 = xmm10[0],xmm12[0],xmm10[1],xmm<wbr>12[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm8[0],xmm2[1],xmm8[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm10[0],xmm2[1],xmm10<wbr>[1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm11[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm6[0],xmm1[1],xmm6[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm11[0],xmm0[1],xmm11<wbr>[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm9[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm9[0],xmm7[1],xmm9[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm3[0],xmm7[1],xmm3[1<wbr>]<br>
-; SSE2-NEXT:    movdqu %xmm4, 16(%rsi)<br>
-; SSE2-NEXT:    movdqu %xmm5, (%rsi)<br>
-; SSE2-NEXT:    movdqu %xmm2, 16(%rdx)<br>
-; SSE2-NEXT:    movdqu %xmm13, (%rdx)<br>
-; SSE2-NEXT:    movdqu %xmm7, 16(%rcx)<br>
-; SSE2-NEXT:    movdqu %xmm0, (%rcx)<br>
+; SSE2-NEXT:    movdqu (%rdi), %xmm0<br>
+; SSE2-NEXT:    movdqu 16(%rdi), %xmm7<br>
+; SSE2-NEXT:    movdqu 32(%rdi), %xmm9<br>
+; SSE2-NEXT:    movdqu 48(%rdi), %xmm2<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm0[0,1,0,3]<br>
+; SSE2-NEXT:    punpckhqdq {{.*#+}} xmm3 = xmm3[1],xmm7[1]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm9[0,1,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm6 = xmm6[3,0],xmm3[2,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[0,1],xmm6[2,0]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm2[0,1,0,3]<br>
+; SSE2-NEXT:    punpckhqdq {{.*#+}} xmm6 = xmm6[1],xmm10[1]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm8[0,1,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm1 = xmm1[3,0],xmm6[2,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm6 = xmm6[0,1],xmm1[2,0]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm0[2,3,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[1,0],xmm7[0,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[0,2],xmm7[3,3]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm9[0,1,2,2]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm5 = xmm5[3,0],xmm0[2,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[0,1],xmm5[2,0]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm2[2,3,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm2 = xmm2[1,0],xmm10[0,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm2 = xmm2[0,2],xmm10[3,3]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm8[0,1,2,2]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm4 = xmm4[3,0],xmm2[2,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm2 = xmm2[0,1],xmm4[2,0]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm7[1,1,2,3]<br>
+; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1<wbr>]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm4 = xmm9[0,1,0,3]<br>
+; SSE2-NEXT:    movsd {{.*#+}} xmm4 = xmm1[0],xmm4[1]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm10[1,1,2,3]<br>
+; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1<wbr>]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm8[0,1,0,3]<br>
+; SSE2-NEXT:    movsd {{.*#+}} xmm1 = xmm5[0],xmm1[1]<br>
+; SSE2-NEXT:    movups %xmm6, 16(%rsi)<br>
+; SSE2-NEXT:    movups %xmm3, (%rsi)<br>
+; SSE2-NEXT:    movups %xmm2, 16(%rdx)<br>
+; SSE2-NEXT:    movups %xmm0, (%rdx)<br>
+; SSE2-NEXT:    movupd %xmm1, 16(%rcx)<br>
+; SSE2-NEXT:    movupd %xmm4, (%rcx)<br>
 ; SSE2-NEXT:    retq<br>
 ;<br>
 ; SSE42-LABEL: interleave_24i32_out:<br>
 ; SSE42:       # BB#0:<br>
 ; SSE42-NEXT:    movdqu 80(%rdi), %xmm8<br>
-; SSE42-NEXT:    movdqu 64(%rdi), %xmm9<br>
-; SSE42-NEXT:    movdqu (%rdi), %xmm6<br>
-; SSE42-NEXT:    movdqu 16(%rdi), %xmm3<br>
+; SSE42-NEXT:    movdqu 64(%rdi), %xmm1<br>
+; SSE42-NEXT:    movdqu (%rdi), %xmm5<br>
+; SSE42-NEXT:    movdqu 16(%rdi), %xmm6<br>
 ; SSE42-NEXT:    movdqu 32(%rdi), %xmm2<br>
 ; SSE42-NEXT:    movdqu 48(%rdi), %xmm4<br>
-; SSE42-NEXT:    pextrd $3, %xmm6, %eax<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[1,1,2,3]<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm6[2,3,0,1]<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm6<br>
-; SSE42-NEXT:    pextrd $2, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm6<br>
-; SSE42-NEXT:    pextrd $1, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm6<br>
-; SSE42-NEXT:    pextrd $3, %xmm4, %eax<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm4[1,1,2,3]<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm1 = xmm4[2,3,0,1]<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrd $2, %xmm9, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm4<br>
-; SSE42-NEXT:    pextrd $1, %xmm8, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm4<br>
-; SSE42-NEXT:    movd %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm5<br>
-; SSE42-NEXT:    pextrd $3, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm5<br>
-; SSE42-NEXT:    pextrd $2, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm5<br>
-; SSE42-NEXT:    movd %xmm9, %eax<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm0<br>
-; SSE42-NEXT:    pextrd $3, %xmm9, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm0<br>
-; SSE42-NEXT:    pextrd $2, %xmm8, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm0<br>
-; SSE42-NEXT:    pextrd $1, %xmm3, %eax<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm7<br>
-; SSE42-NEXT:    movd %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm7<br>
-; SSE42-NEXT:    pextrd $3, %xmm2, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm7<br>
-; SSE42-NEXT:    pextrd $1, %xmm9, %eax<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm1<br>
-; SSE42-NEXT:    movd %xmm8, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm1<br>
-; SSE42-NEXT:    pextrd $3, %xmm8, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm1<br>
-; SSE42-NEXT:    movdqu %xmm4, 16(%rsi)<br>
-; SSE42-NEXT:    movdqu %xmm6, (%rsi)<br>
-; SSE42-NEXT:    movdqu %xmm0, 16(%rdx)<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm5[0,3,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1,2,3],xmm6[4,5,6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm2[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm7[0,1,2,3,4,5],xmm3[6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm4[0,3,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1,2,3],xmm1[4,5,6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm8[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm0 = xmm7[0,1,2,3,4,5],xmm0[6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm9 = xmm2[0,1,2,2]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm5[2,3,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1],xmm6[2,3],xmm7[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm6 = xmm6[0,1],xmm5[2,3],xmm6[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[1,0,3,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm5 = xmm5[0,1,2,3,4,5],xmm9[6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm6 = xmm4[2,3,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm6 = xmm6[0,1],xmm1[2,3],xmm6[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm1 = xmm1[0,1],xmm4[2,3],xmm1[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[1,0,3,3]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm8[0,1,2,2]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm1[0,1,2,3,4,5],xmm4[6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm1 = xmm2[0,1,0,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm1 = xmm7[0,1,2,3],xmm1[4,5,6,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm2 = xmm8[0,1,0,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm2 = xmm6[0,1,2,3],xmm2[4,5,6,7]<br>
+; SSE42-NEXT:    movdqu %xmm0, 16(%rsi)<br>
+; SSE42-NEXT:    movdqu %xmm3, (%rsi)<br>
+; SSE42-NEXT:    movdqu %xmm4, 16(%rdx)<br>
 ; SSE42-NEXT:    movdqu %xmm5, (%rdx)<br>
-; SSE42-NEXT:    movdqu %xmm1, 16(%rcx)<br>
-; SSE42-NEXT:    movdqu %xmm7, (%rcx)<br>
+; SSE42-NEXT:    movdqu %xmm2, 16(%rcx)<br>
+; SSE42-NEXT:    movdqu %xmm1, (%rcx)<br>
 ; SSE42-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: interleave_24i32_out:<br>
 ; AVX1:       # BB#0:<br>
-; AVX1-NEXT:    vmovdqu (%rdi), %ymm1<br>
-; AVX1-NEXT:    vmovups 32(%rdi), %ymm0<br>
-; AVX1-NEXT:    vmovdqu 64(%rdi), %ymm2<br>
-; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm3<br>
-; AVX1-NEXT:    vpextrd $3, %xmm3, %eax<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm3, %xmm4<br>
-; AVX1-NEXT:    vpextrd $2, %xmm2, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm4, %xmm5<br>
-; AVX1-NEXT:    vextractf128 $1, %ymm2, %xmm4<br>
-; AVX1-NEXT:    vpextrd $1, %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm5, %xmm5<br>
-; AVX1-NEXT:    vpextrd $3, %xmm1, %eax<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm1, %xmm6<br>
-; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm7<br>
-; AVX1-NEXT:    vpextrd $2, %xmm7, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vpextrd $1, %xmm0, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vinsertf128 $1, %xmm5, %ymm6, %ymm8<br>
-; AVX1-NEXT:    vmovd %xmm2, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm6 = xmm3[1,1,2,3]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vpextrd $3, %xmm2, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vpextrd $2, %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vmovd %xmm7, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm5 = xmm1[1,1,2,3]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm5, %xmm5<br>
-; AVX1-NEXT:    vpextrd $3, %xmm7, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm5, %xmm5<br>
-; AVX1-NEXT:    vpextrd $2, %xmm0, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm5, %xmm5<br>
+; AVX1-NEXT:    vmovups (%rdi), %ymm0<br>
+; AVX1-NEXT:    vmovups 32(%rdi), %ymm1<br>
+; AVX1-NEXT:    vmovups 64(%rdi), %ymm2<br>
+; AVX1-NEXT:    vextractf128 $1, %ymm2, %xmm3<br>
+; AVX1-NEXT:    vinsertps {{.*#+}} xmm4 = zero,zero,xmm2[2],xmm3[1]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm4, %ymm0, %ymm4<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm5 = ymm0[0],ymm1[1],ymm0[2,3],ymm1<wbr>[4],ymm0[5,6],ymm1[7]<br>
+; AVX1-NEXT:    vextractf128 $1, %ymm5, %xmm6<br>
+; AVX1-NEXT:    vblendps {{.*#+}} xmm5 = xmm5[0,1],xmm6[2],xmm5[3]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} xmm5 = xmm5[0,3,2,1]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} xmm6 = xmm6[0,3,2,3]<br>
 ; AVX1-NEXT:    vinsertf128 $1, %xmm6, %ymm5, %ymm5<br>
-; AVX1-NEXT:    vpextrd $1, %xmm2, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm2 = xmm3[2,3,0,1]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vmovd %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $3, %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $1, %xmm7, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm1 = xmm1[2,3,0,1]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm1, %xmm1<br>
-; AVX1-NEXT:    vmovd %xmm0, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm1, %xmm1<br>
-; AVX1-NEXT:    vpextrd $3, %xmm0, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm1, %xmm0<br>
-; AVX1-NEXT:    vinsertf128 $1, %xmm2, %ymm0, %ymm0<br>
-; AVX1-NEXT:    vmovups %ymm8, (%rsi)<br>
+; AVX1-NEXT:    vblendpd {{.*#+}} ymm4 = ymm5[0,1,2],ymm4[3]<br>
+; AVX1-NEXT:    vblendps {{.*#+}} xmm5 = xmm2[0,1],xmm3[2],xmm2[3]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} xmm5 = xmm5[0,0,3,2]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm5, %ymm0, %ymm5<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm6 = ymm0[0,1],ymm1[2],ymm0[3,4],ym<wbr>m1[5],ymm0[6,7]<br>
+; AVX1-NEXT:    vextractf128 $1, %ymm6, %xmm7<br>
+; AVX1-NEXT:    vblendps {{.*#+}} xmm6 = xmm7[0],xmm6[1,2],xmm7[3]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} xmm6 = xmm6[1,0,3,2]<br>
+; AVX1-NEXT:    vmovshdup {{.*#+}} xmm7 = xmm7[1,1,3,3]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm7, %ymm6, %ymm6<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm5 = ymm6[0,1,2,3,4],ymm5[5,6,7]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm2 = xmm2[0,1],xmm3[0,3]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm2, %ymm0, %ymm2<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm0 = ymm1[0,1],ymm0[2],ymm1[3,4],ym<wbr>m0[5],ymm1[6,7]<br>
+; AVX1-NEXT:    vextractf128 $1, %ymm0, %xmm1<br>
+; AVX1-NEXT:    vblendps {{.*#+}} xmm0 = xmm0[0],xmm1[1],xmm0[2,3]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} xmm0 = xmm0[2,1,0,3]<br>
+; AVX1-NEXT:    vpermilpd {{.*#+}} xmm1 = xmm1[1,0]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm0 = ymm0[0,1,2,3,4],ymm2[5,6,7]<br>
+; AVX1-NEXT:    vmovupd %ymm4, (%rsi)<br>
 ; AVX1-NEXT:    vmovups %ymm5, (%rdx)<br>
 ; AVX1-NEXT:    vmovups %ymm0, (%rcx)<br>
 ; AVX1-NEXT:    vzeroupper<br>
@@ -1403,57 +1227,29 @@ define void @interleave_24i32_out(<24 x<br>
 ;<br>
 ; AVX2-LABEL: interleave_24i32_out:<br>
 ; AVX2:       # BB#0:<br>
-; AVX2-NEXT:    vmovdqu (%rdi), %ymm1<br>
-; AVX2-NEXT:    vmovdqu 32(%rdi), %ymm0<br>
+; AVX2-NEXT:    vmovdqu (%rdi), %ymm0<br>
+; AVX2-NEXT:    vmovdqu 32(%rdi), %ymm1<br>
 ; AVX2-NEXT:    vmovdqu 64(%rdi), %ymm2<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm0, %xmm3<br>
-; AVX2-NEXT:    vpextrd $3, %xmm3, %eax<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm3, %xmm4<br>
-; AVX2-NEXT:    vpextrd $2, %xmm2, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm4, %xmm5<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm2, %xmm4<br>
-; AVX2-NEXT:    vpextrd $1, %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm5, %xmm5<br>
-; AVX2-NEXT:    vpextrd $3, %xmm1, %eax<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm1, %xmm6<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm1, %xmm7<br>
-; AVX2-NEXT:    vpextrd $2, %xmm7, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vpextrd $1, %xmm0, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm5, %ymm6, %ymm8<br>
-; AVX2-NEXT:    vmovd %xmm2, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm6 = xmm3[1,1,2,3]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vpextrd $3, %xmm2, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vpextrd $2, %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vmovd %xmm7, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm5 = xmm1[1,1,2,3]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm5, %xmm5<br>
-; AVX2-NEXT:    vpextrd $3, %xmm7, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm5, %xmm5<br>
-; AVX2-NEXT:    vpextrd $2, %xmm0, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm5, %xmm5<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm6, %ymm5, %ymm5<br>
-; AVX2-NEXT:    vpextrd $1, %xmm2, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm2 = xmm3[2,3,0,1]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vmovd %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $3, %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $1, %xmm7, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm1 = xmm1[2,3,0,1]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm1, %xmm1<br>
-; AVX2-NEXT:    vmovd %xmm0, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm1, %xmm1<br>
-; AVX2-NEXT:    vpextrd $3, %xmm0, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm1, %xmm0<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm2, %ymm0, %ymm0<br>
-; AVX2-NEXT:    vmovdqu %ymm8, (%rsi)<br>
-; AVX2-NEXT:    vmovdqu %ymm5, (%rdx)<br>
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm3 = <u,u,u,u,u,u,2,5><br>
+; AVX2-NEXT:    vpermd %ymm2, %ymm3, %ymm3<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm4 = ymm0[0],ymm1[1],ymm0[2,3],ymm1<wbr>[4],ymm0[5,6],ymm1[7]<br>
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm5 = <0,3,6,1,4,7,u,u><br>
+; AVX2-NEXT:    vpermd %ymm4, %ymm5, %ymm4<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm3 = ymm4[0,1,2,3,4,5],ymm3[6,7]<br>
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm4 = <u,u,u,u,u,0,3,6><br>
+; AVX2-NEXT:    vpermd %ymm2, %ymm4, %ymm4<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm5 = ymm0[0,1],ymm1[2],ymm0[3,4],ym<wbr>m1[5],ymm0[6,7]<br>
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm6 = <1,4,7,2,5,u,u,u><br>
+; AVX2-NEXT:    vpermd %ymm5, %ymm6, %ymm5<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm4 = ymm5[0,1,2,3,4],ymm4[5,6,7]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm0 = ymm1[0,1],ymm0[2],ymm1[3,4],ym<wbr>m0[5],ymm1[6,7]<br>
+; AVX2-NEXT:    vmovdqa {{.*#+}} ymm1 = <2,5,0,3,6,u,u,u><br>
+; AVX2-NEXT:    vpermd %ymm0, %ymm1, %ymm0<br>
+; AVX2-NEXT:    vpshufd {{.*#+}} ymm1 = ymm2[0,1,0,3,4,5,4,7]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm1 = ymm1[0,1,0,3]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm0 = ymm0[0,1,2,3,4],ymm1[5,6,7]<br>
+; AVX2-NEXT:    vmovdqu %ymm3, (%rsi)<br>
+; AVX2-NEXT:    vmovdqu %ymm4, (%rdx)<br>
 ; AVX2-NEXT:    vmovdqu %ymm0, (%rcx)<br>
 ; AVX2-NEXT:    vzeroupper<br>
 ; AVX2-NEXT:    retq<br>
@@ -1470,223 +1266,153 @@ define void @interleave_24i32_out(<24 x<br>
 define void @interleave_24i32_in(<24 x i32>* %p, <8 x i32>* %q1, <8 x i32>* %q2, <8 x i32>* %q3) nounwind {<br>
 ; SSE2-LABEL: interleave_24i32_in:<br>
 ; SSE2:       # BB#0:<br>
-; SSE2-NEXT:    movdqu (%rsi), %xmm4<br>
-; SSE2-NEXT:    movdqu 16(%rsi), %xmm1<br>
-; SSE2-NEXT:    movdqu (%rdx), %xmm5<br>
-; SSE2-NEXT:    movdqu 16(%rdx), %xmm2<br>
-; SSE2-NEXT:    movdqu (%rcx), %xmm6<br>
-; SSE2-NEXT:    movdqu 16(%rcx), %xmm11<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm4[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm9 = xmm5[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm5[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm10 = xmm5[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm8[0],xmm5[1],xmm8[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm4[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm4[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm4 = xmm4[0],xmm6[0],xmm4[1],xmm6[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[1,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm9[0],xmm5[1],xmm9[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm3 = xmm3[0],xmm7[0],xmm3[1],xmm7[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm5[0],xmm0[1],xmm5[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[2,3,0,1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm10[0],xmm5[1],xmm10<wbr>[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm1[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm8 = xmm2[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm2[1,1,2,3]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm9 = xmm2[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm1[2,3,0,1]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm1[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm11[0],xmm1[1],xmm11<wbr>[1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm11[1,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm8[0],xmm2[1],xmm8[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm0[0],xmm7[1],xmm0[1<wbr>]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm7 = xmm7[0],xmm2[0],xmm7[1],xmm2[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm11[3,1,2,3]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm6 = xmm6[0],xmm0[0],xmm6[1],xmm0[1<wbr>]<br>
-; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm11[2,3,0,1]<br>
-; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm9[0],xmm0[1],xmm9[1<wbr>]<br>
+; SSE2-NEXT:    movdqu (%rsi), %xmm5<br>
+; SSE2-NEXT:    movdqu 16(%rsi), %xmm2<br>
+; SSE2-NEXT:    movdqu (%rdx), %xmm6<br>
+; SSE2-NEXT:    movdqu 16(%rdx), %xmm1<br>
+; SSE2-NEXT:    movdqu (%rcx), %xmm7<br>
+; SSE2-NEXT:    movdqu 16(%rcx), %xmm4<br>
+; SSE2-NEXT:    movdqa %xmm5, %xmm0<br>
 ; SSE2-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm6[0],xmm0[1],xmm6[1<wbr>]<br>
-; SSE2-NEXT:    movdqu %xmm0, 80(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm7, 64(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm1, 48(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm5, 32(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm3, 16(%rdi)<br>
-; SSE2-NEXT:    movdqu %xmm4, (%rdi)<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,1,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm3 = xmm7[0,1,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[2,0],xmm0[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm0 = xmm0[0,1],xmm3[0,2]<br>
+; SSE2-NEXT:    movdqa %xmm7, %xmm3<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[1,0],xmm6[1,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[2,0],xmm6[2,2]<br>
+; SSE2-NEXT:    punpckhdq {{.*#+}} xmm7 = xmm7[2],xmm5[2],xmm7[3],xmm5[3<wbr>]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm5 = xmm5[2,0],xmm3[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm3 = xmm3[0,1],xmm5[0,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm5 = xmm7[0,3,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm6[2,2,3,3]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm6 = xmm6[2,0],xmm5[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm5 = xmm5[0,1],xmm6[0,2]<br>
+; SSE2-NEXT:    movdqa %xmm2, %xmm6<br>
+; SSE2-NEXT:    punpckldq {{.*#+}} xmm6 = xmm6[0],xmm1[0],xmm6[1],xmm1[1<wbr>]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm6 = xmm6[0,1,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm7 = xmm4[0,1,0,1]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm7 = xmm7[2,0],xmm6[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm6 = xmm6[0,1],xmm7[0,2]<br>
+; SSE2-NEXT:    movdqa %xmm4, %xmm7<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm7 = xmm7[1,0],xmm1[1,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm7 = xmm7[2,0],xmm1[2,2]<br>
+; SSE2-NEXT:    punpckhdq {{.*#+}} xmm4 = xmm4[2],xmm2[2],xmm4[3],xmm2[3<wbr>]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm2 = xmm2[2,0],xmm7[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm7 = xmm7[0,1],xmm2[0,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm2 = xmm4[0,3,2,2]<br>
+; SSE2-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[2,2,3,3]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm1 = xmm1[2,0],xmm2[3,0]<br>
+; SSE2-NEXT:    shufps {{.*#+}} xmm2 = xmm2[0,1],xmm1[0,2]<br>
+; SSE2-NEXT:    movups %xmm2, 80(%rdi)<br>
+; SSE2-NEXT:    movups %xmm7, 64(%rdi)<br>
+; SSE2-NEXT:    movups %xmm6, 48(%rdi)<br>
+; SSE2-NEXT:    movups %xmm5, 32(%rdi)<br>
+; SSE2-NEXT:    movups %xmm3, 16(%rdi)<br>
+; SSE2-NEXT:    movups %xmm0, (%rdi)<br>
 ; SSE2-NEXT:    retq<br>
 ;<br>
 ; SSE42-LABEL: interleave_24i32_in:<br>
 ; SSE42:       # BB#0:<br>
-; SSE42-NEXT:    movdqu (%rsi), %xmm3<br>
+; SSE42-NEXT:    movdqu (%rsi), %xmm5<br>
 ; SSE42-NEXT:    movdqu 16(%rsi), %xmm2<br>
 ; SSE42-NEXT:    movdqu (%rdx), %xmm6<br>
-; SSE42-NEXT:    movdqu 16(%rdx), %xmm0<br>
+; SSE42-NEXT:    movdqu 16(%rdx), %xmm1<br>
 ; SSE42-NEXT:    movdqu (%rcx), %xmm7<br>
-; SSE42-NEXT:    movdqu 16(%rcx), %xmm1<br>
-; SSE42-NEXT:    movd %xmm6, %eax<br>
-; SSE42-NEXT:    pextrd $1, %xmm3, %ecx<br>
-; SSE42-NEXT:    pextrd $2, %xmm3, %edx<br>
-; SSE42-NEXT:    pextrd $3, %xmm3, %esi<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm3<br>
-; SSE42-NEXT:    movd %xmm7, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm3<br>
-; SSE42-NEXT:    pinsrd $3, %ecx, %xmm3<br>
-; SSE42-NEXT:    pextrd $1, %xmm7, %eax<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm6[1,1,2,3]<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm4<br>
-; SSE42-NEXT:    pinsrd $2, %edx, %xmm4<br>
-; SSE42-NEXT:    pextrd $2, %xmm6, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm4<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm7[2,3,0,1]<br>
-; SSE42-NEXT:    pinsrd $1, %esi, %xmm5<br>
-; SSE42-NEXT:    pextrd $3, %xmm6, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm5<br>
-; SSE42-NEXT:    pextrd $3, %xmm7, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm5<br>
-; SSE42-NEXT:    movd %xmm0, %eax<br>
-; SSE42-NEXT:    pextrd $1, %xmm2, %ecx<br>
-; SSE42-NEXT:    pextrd $2, %xmm2, %edx<br>
-; SSE42-NEXT:    pextrd $3, %xmm2, %esi<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm2<br>
-; SSE42-NEXT:    movd %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm2<br>
-; SSE42-NEXT:    pinsrd $3, %ecx, %xmm2<br>
-; SSE42-NEXT:    pextrd $1, %xmm1, %eax<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm6 = xmm0[1,1,2,3]<br>
-; SSE42-NEXT:    pinsrd $1, %eax, %xmm6<br>
-; SSE42-NEXT:    pinsrd $2, %edx, %xmm6<br>
-; SSE42-NEXT:    pextrd $2, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm6<br>
-; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm1[2,3,0,1]<br>
-; SSE42-NEXT:    pinsrd $1, %esi, %xmm7<br>
-; SSE42-NEXT:    pextrd $3, %xmm0, %eax<br>
-; SSE42-NEXT:    pinsrd $2, %eax, %xmm7<br>
-; SSE42-NEXT:    pextrd $3, %xmm1, %eax<br>
-; SSE42-NEXT:    pinsrd $3, %eax, %xmm7<br>
-; SSE42-NEXT:    movdqu %xmm7, 80(%rdi)<br>
-; SSE42-NEXT:    movdqu %xmm6, 64(%rdi)<br>
-; SSE42-NEXT:    movdqu %xmm2, 48(%rdi)<br>
+; SSE42-NEXT:    movdqu 16(%rcx), %xmm4<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm6[0,0,1,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm5[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm3[0,1],xmm0[2,3],xmm3[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm0 = xmm7[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm0 = xmm3[0,1,2,3],xmm0[4,5],xmm3[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm3 = xmm6[1,1,2,2]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm3[0,1],xmm7[2,3],xmm3[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm3 = xmm3[0,1,2,3],xmm5[4,5],xmm3[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm5[2,3,0,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm7[2,3,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1],xmm5[2,3],xmm7[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm5 = xmm6[2,2,3,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm5 = xmm7[0,1,2,3],xmm5[4,5],xmm7[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm6 = xmm1[0,0,1,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm2[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1],xmm6[2,3],xmm7[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm6 = xmm4[0,1,0,1]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm6 = xmm7[0,1,2,3],xmm6[4,5],xmm7[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm7 = xmm1[1,1,2,2]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1],xmm4[2,3],xmm7[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm7 = xmm7[0,1,2,3],xmm2[4,5],xmm7[6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[2,3,0,1]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm4 = xmm4[2,3,2,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm4 = xmm4[0,1],xmm2[2,3],xmm4[4,5,6<wbr>,7]<br>
+; SSE42-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[2,2,3,3]<br>
+; SSE42-NEXT:    pblendw {{.*#+}} xmm1 = xmm4[0,1,2,3],xmm1[4,5],xmm4[6<wbr>,7]<br>
+; SSE42-NEXT:    movdqu %xmm1, 80(%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm7, 64(%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm6, 48(%rdi)<br>
 ; SSE42-NEXT:    movdqu %xmm5, 32(%rdi)<br>
-; SSE42-NEXT:    movdqu %xmm4, 16(%rdi)<br>
-; SSE42-NEXT:    movdqu %xmm3, (%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm3, 16(%rdi)<br>
+; SSE42-NEXT:    movdqu %xmm0, (%rdi)<br>
 ; SSE42-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: interleave_24i32_in:<br>
 ; AVX1:       # BB#0:<br>
-; AVX1-NEXT:    vmovdqu (%rsi), %ymm2<br>
-; AVX1-NEXT:    vmovdqu (%rdx), %ymm3<br>
-; AVX1-NEXT:    vmovdqu (%rcx), %ymm1<br>
-; AVX1-NEXT:    vpextrd $1, %xmm1, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm0 = xmm3[1,1,2,3]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm0, %xmm0<br>
-; AVX1-NEXT:    vpextrd $2, %xmm2, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm0, %xmm0<br>
-; AVX1-NEXT:    vpextrd $2, %xmm3, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm0, %xmm0<br>
-; AVX1-NEXT:    vmovd %xmm3, %eax<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm4<br>
-; AVX1-NEXT:    vmovd %xmm1, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm4, %xmm4<br>
-; AVX1-NEXT:    vpextrd $1, %xmm2, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm4, %xmm4<br>
-; AVX1-NEXT:    vinsertf128 $1, %xmm0, %ymm4, %ymm0<br>
+; AVX1-NEXT:    vmovups (%rsi), %ymm0<br>
+; AVX1-NEXT:    vmovups (%rdx), %ymm1<br>
+; AVX1-NEXT:    vmovupd (%rcx), %ymm2<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm3 = xmm0[2,0],xmm1[2,0]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm3 = xmm1[1,1],xmm3[0,2]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm4 = xmm1[0,0],xmm0[0,0]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm4 = xmm4[2,0],xmm0[2,1]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm3, %ymm4, %ymm3<br>
+; AVX1-NEXT:    vmovddup {{.*#+}} xmm4 = xmm2[0,0]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm4, %ymm4, %ymm4<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm3 = ymm3[0,1],ymm4[2],ymm3[3,4],ym<wbr>m4[5],ymm3[6,7]<br>
 ; AVX1-NEXT:    vextractf128 $1, %ymm2, %xmm4<br>
-; AVX1-NEXT:    vextractf128 $1, %ymm3, %xmm5<br>
-; AVX1-NEXT:    vmovd %xmm5, %eax<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm4, %xmm6<br>
-; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm7<br>
-; AVX1-NEXT:    vmovd %xmm7, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vpextrd $1, %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX1-NEXT:    vpextrd $3, %xmm2, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm2 = xmm1[2,3,0,1]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $3, %xmm3, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $3, %xmm1, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm1<br>
-; AVX1-NEXT:    vinsertf128 $1, %xmm6, %ymm1, %ymm1<br>
-; AVX1-NEXT:    vpextrd $3, %xmm4, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm2 = xmm7[2,3,0,1]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $3, %xmm5, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $3, %xmm7, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm2<br>
-; AVX1-NEXT:    vpextrd $1, %xmm7, %eax<br>
-; AVX1-NEXT:    vpshufd {{.*#+}} xmm3 = xmm5[1,1,2,3]<br>
-; AVX1-NEXT:    vpinsrd $1, %eax, %xmm3, %xmm3<br>
-; AVX1-NEXT:    vpextrd $2, %xmm4, %eax<br>
-; AVX1-NEXT:    vpinsrd $2, %eax, %xmm3, %xmm3<br>
-; AVX1-NEXT:    vpextrd $2, %xmm5, %eax<br>
-; AVX1-NEXT:    vpinsrd $3, %eax, %xmm3, %xmm3<br>
-; AVX1-NEXT:    vinsertf128 $1, %xmm2, %ymm3, %ymm2<br>
-; AVX1-NEXT:    vmovups %ymm2, 64(%rdi)<br>
-; AVX1-NEXT:    vmovups %ymm1, 32(%rdi)<br>
-; AVX1-NEXT:    vmovups %ymm0, (%rdi)<br>
+; AVX1-NEXT:    vextractf128 $1, %ymm1, %xmm5<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm6 = xmm5[3,0],xmm4[3,0]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm6 = xmm4[2,1],xmm6[0,2]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm4 = xmm4[1,0],xmm5[1,0]<br>
+; AVX1-NEXT:    vshufps {{.*#+}} xmm4 = xmm4[2,0],xmm5[2,2]<br>
+; AVX1-NEXT:    vinsertf128 $1, %xmm6, %ymm4, %ymm4<br>
+; AVX1-NEXT:    vpermilpd {{.*#+}} ymm5 = ymm0[1,1,3,3]<br>
+; AVX1-NEXT:    vperm2f128 {{.*#+}} ymm5 = ymm5[2,3,2,3]<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm4 = ymm4[0,1],ymm5[2],ymm4[3,4],ym<wbr>m5[5],ymm4[6,7]<br>
+; AVX1-NEXT:    vpermilpd {{.*#+}} ymm0 = ymm0[1,0,2,2]<br>
+; AVX1-NEXT:    vpermilpd {{.*#+}} ymm2 = ymm2[1,1,2,2]<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm0 = ymm2[0],ymm0[1],ymm2[2,3],ymm0<wbr>[4],ymm2[5,6],ymm0[7]<br>
+; AVX1-NEXT:    vpermilps {{.*#+}} ymm1 = ymm1[0,0,3,3,4,4,7,7]<br>
+; AVX1-NEXT:    vblendps {{.*#+}} ymm0 = ymm0[0,1],ymm1[2],ymm0[3,4],ym<wbr>m1[5],ymm0[6,7]<br>
+; AVX1-NEXT:    vmovups %ymm0, 32(%rdi)<br>
+; AVX1-NEXT:    vmovups %ymm4, 64(%rdi)<br>
+; AVX1-NEXT:    vmovups %ymm3, (%rdi)<br>
 ; AVX1-NEXT:    vzeroupper<br>
 ; AVX1-NEXT:    retq<br>
 ;<br>
 ; AVX2-LABEL: interleave_24i32_in:<br>
 ; AVX2:       # BB#0:<br>
-; AVX2-NEXT:    vmovdqu (%rsi), %ymm2<br>
-; AVX2-NEXT:    vmovdqu (%rdx), %ymm3<br>
-; AVX2-NEXT:    vmovdqu (%rcx), %ymm1<br>
-; AVX2-NEXT:    vpextrd $1, %xmm1, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm0 = xmm3[1,1,2,3]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm0, %xmm0<br>
-; AVX2-NEXT:    vpextrd $2, %xmm2, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm0, %xmm0<br>
-; AVX2-NEXT:    vpextrd $2, %xmm3, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm0, %xmm0<br>
-; AVX2-NEXT:    vmovd %xmm3, %eax<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm4<br>
-; AVX2-NEXT:    vmovd %xmm1, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm4, %xmm4<br>
-; AVX2-NEXT:    vpextrd $1, %xmm2, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm4, %xmm4<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm0, %ymm4, %ymm0<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm2, %xmm4<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm3, %xmm5<br>
-; AVX2-NEXT:    vmovd %xmm5, %eax<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm4, %xmm6<br>
-; AVX2-NEXT:    vextracti128 $1, %ymm1, %xmm7<br>
-; AVX2-NEXT:    vmovd %xmm7, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vpextrd $1, %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm6, %xmm6<br>
-; AVX2-NEXT:    vpextrd $3, %xmm2, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm2 = xmm1[2,3,0,1]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $3, %xmm3, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $3, %xmm1, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm1<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm6, %ymm1, %ymm1<br>
-; AVX2-NEXT:    vpextrd $3, %xmm4, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm2 = xmm7[2,3,0,1]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $3, %xmm5, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $3, %xmm7, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm2, %xmm2<br>
-; AVX2-NEXT:    vpextrd $1, %xmm7, %eax<br>
-; AVX2-NEXT:    vpshufd {{.*#+}} xmm3 = xmm5[1,1,2,3]<br>
-; AVX2-NEXT:    vpinsrd $1, %eax, %xmm3, %xmm3<br>
-; AVX2-NEXT:    vpextrd $2, %xmm4, %eax<br>
-; AVX2-NEXT:    vpinsrd $2, %eax, %xmm3, %xmm3<br>
-; AVX2-NEXT:    vpextrd $2, %xmm5, %eax<br>
-; AVX2-NEXT:    vpinsrd $3, %eax, %xmm3, %xmm3<br>
-; AVX2-NEXT:    vinserti128 $1, %xmm2, %ymm3, %ymm2<br>
-; AVX2-NEXT:    vmovdqu %ymm2, 64(%rdi)<br>
-; AVX2-NEXT:    vmovdqu %ymm1, 32(%rdi)<br>
-; AVX2-NEXT:    vmovdqu %ymm0, (%rdi)<br>
+; AVX2-NEXT:    vmovdqu (%rsi), %ymm0<br>
+; AVX2-NEXT:    vmovdqu (%rdx), %ymm1<br>
+; AVX2-NEXT:    vmovdqu (%rcx), %ymm2<br>
+; AVX2-NEXT:    vpshufd {{.*#+}} xmm3 = xmm1[1,0,2,2]<br>
+; AVX2-NEXT:    vperm2i128 {{.*#+}} ymm3 = ymm3[0,1,0,1]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm4 = ymm0[0,0,2,1]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm3 = ymm4[0],ymm3[1],ymm4[2,3],ymm3<wbr>[4],ymm4[5,6],ymm3[7]<br>
+; AVX2-NEXT:    vpbroadcastq %xmm2, %ymm4<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm3 = ymm3[0,1],ymm4[2],ymm3[3,4],ym<wbr>m4[5],ymm3[6,7]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm4 = ymm2[2,1,3,3]<br>
+; AVX2-NEXT:    vpshufd {{.*#+}} ymm5 = ymm1[1,2,3,3,5,6,7,7]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm5 = ymm5[2,2,2,3]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm4 = ymm5[0],ymm4[1],ymm5[2,3],ymm4<wbr>[4],ymm5[5,6],ymm4[7]<br>
+; AVX2-NEXT:    vpbroadcastq 24(%rsi), %ymm5<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm4 = ymm4[0,1],ymm5[2],ymm4[3,4],ym<wbr>m5[5],ymm4[6,7]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm0 = ymm0[1,1,2,2]<br>
+; AVX2-NEXT:    vpermq {{.*#+}} ymm2 = ymm2[1,1,2,2]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm0 = ymm2[0],ymm0[1],ymm2[2,3],ymm0<wbr>[4],ymm2[5,6],ymm0[7]<br>
+; AVX2-NEXT:    vpshufd {{.*#+}} ymm1 = ymm1[0,0,3,3,4,4,7,7]<br>
+; AVX2-NEXT:    vpblendd {{.*#+}} ymm0 = ymm0[0,1],ymm1[2],ymm0[3,4],ym<wbr>m1[5],ymm0[6,7]<br>
+; AVX2-NEXT:    vmovdqu %ymm0, 32(%rdi)<br>
+; AVX2-NEXT:    vmovdqu %ymm4, 64(%rdi)<br>
+; AVX2-NEXT:    vmovdqu %ymm3, (%rdi)<br>
 ; AVX2-NEXT:    vzeroupper<br>
 ; AVX2-NEXT:    retq<br>
   %s1 = load <8 x i32>, <8 x i32>* %q1, align 4<br>
<br>
Modified: llvm/trunk/test/CodeGen/X86/ve<wbr>ctor-trunc-math.ll<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/X86/vector-trunc-math.ll?rev=283480&r1=283479&r2=283480&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-pr<wbr>oject/llvm/trunk/test/CodeGen/<wbr>X86/vector-trunc-math.ll?rev=<wbr>283480&r1=283479&r2=283480&<wbr>view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- llvm/trunk/test/CodeGen/X86/ve<wbr>ctor-trunc-math.ll (original)<br>
+++ llvm/trunk/test/CodeGen/X86/ve<wbr>ctor-trunc-math.ll Thu Oct  6 13:58:24 2016<br>
@@ -54,25 +54,22 @@ define <4 x i32> @trunc_add_v4i64_4i32(<<br>
 define <8 x i16> @trunc_add_v8i64_8i16(<8 x i64> %a0, <8 x i64> %a1) nounwind {<br>
 ; SSE-LABEL: trunc_add_v8i64_8i16:<br>
 ; SSE:       # BB#0:<br>
-; SSE-NEXT:    paddq %xmm6, %xmm2<br>
 ; SSE-NEXT:    paddq %xmm4, %xmm0<br>
-; SSE-NEXT:    paddq %xmm7, %xmm3<br>
 ; SSE-NEXT:    paddq %xmm5, %xmm1<br>
-; SSE-NEXT:    pextrw $4, %xmm1, %eax<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE-NEXT:    pextrw $4, %xmm0, %ecx<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1<wbr>],xmm0[2],xmm2[2],xmm0[3],xmm2<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
-; SSE-NEXT:    pextrw $4, %xmm3, %edx<br>
-; SSE-NEXT:    movd %edx, %xmm1<br>
-; SSE-NEXT:    movd %eax, %xmm3<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1<wbr>],xmm3[2],xmm1[2],xmm3[3],xmm1<wbr>[3]<br>
-; SSE-NEXT:    pextrw $4, %xmm2, %eax<br>
-; SSE-NEXT:    movd %eax, %xmm1<br>
-; SSE-NEXT:    movd %ecx, %xmm2<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1<wbr>],xmm2[2],xmm1[2],xmm2[3],xmm1<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1<wbr>],xmm2[2],xmm3[2],xmm2[3],xmm3<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1<wbr>],xmm0[2],xmm2[2],xmm0[3],xmm2<wbr>[3]<br>
+; SSE-NEXT:    paddq %xmm6, %xmm2<br>
+; SSE-NEXT:    paddq %xmm7, %xmm3<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm3 = xmm3[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm3 = xmm3[0,1,0,2,4,5,6,7]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm2 = xmm2[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm2 = xmm2[0,1,0,2,4,5,6,7]<br>
+; SSE-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1<wbr>]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm1 = xmm1[0,2,2,3,4,5,6,7]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]<br>
+; SSE-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>]<br>
+; SSE-NEXT:    movsd {{.*#+}} xmm2 = xmm0[0],xmm2[1]<br>
+; SSE-NEXT:    movapd %xmm2, %xmm0<br>
 ; SSE-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: trunc_add_v8i64_8i16:<br>
@@ -445,29 +442,24 @@ define <4 x i32> @trunc_add_const_v4i64_<br>
 define <8 x i16> @trunc_add_const_v16i64_v16i16<wbr>(<8 x i64> %a0) nounwind {<br>
 ; SSE-LABEL: trunc_add_const_v16i64_v16i16:<br>
 ; SSE:       # BB#0:<br>
-; SSE-NEXT:    movdqa %xmm0, %xmm4<br>
 ; SSE-NEXT:    movl $1, %eax<br>
-; SSE-NEXT:    movd %rax, %xmm0<br>
-; SSE-NEXT:    pslldq {{.*#+}} xmm0 = zero,zero,zero,zero,zero,zero,<wbr>zero,zero,xmm0[0,1,2,3,4,5,6,7<wbr>]<br>
-; SSE-NEXT:    paddq %xmm4, %xmm0<br>
+; SSE-NEXT:    movd %rax, %xmm4<br>
+; SSE-NEXT:    pslldq {{.*#+}} xmm4 = zero,zero,zero,zero,zero,zero,<wbr>zero,zero,xmm4[0,1,2,3,4,5,6,7<wbr>]<br>
+; SSE-NEXT:    paddq %xmm0, %xmm4<br>
+; SSE-NEXT:    paddq {{.*}}(%rip), %xmm1<br>
 ; SSE-NEXT:    paddq {{.*}}(%rip), %xmm2<br>
 ; SSE-NEXT:    paddq {{.*}}(%rip), %xmm3<br>
-; SSE-NEXT:    paddq {{.*}}(%rip), %xmm1<br>
-; SSE-NEXT:    pextrw $4, %xmm1, %eax<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE-NEXT:    pextrw $4, %xmm0, %ecx<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1<wbr>],xmm0[2],xmm2[2],xmm0[3],xmm2<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
-; SSE-NEXT:    pextrw $4, %xmm3, %edx<br>
-; SSE-NEXT:    movd %edx, %xmm1<br>
-; SSE-NEXT:    movd %eax, %xmm3<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1<wbr>],xmm3[2],xmm1[2],xmm3[3],xmm1<wbr>[3]<br>
-; SSE-NEXT:    movd %ecx, %xmm1<br>
-; SSE-NEXT:    pextrw $4, %xmm2, %eax<br>
-; SSE-NEXT:    movd %eax, %xmm2<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1<wbr>],xmm1[2],xmm2[2],xmm1[3],xmm2<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1<wbr>],xmm0[2],xmm1[2],xmm0[3],xmm1<wbr>[3]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm3[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm3 = xmm0[0,1,0,2,4,5,6,7]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm0 = xmm2[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm0 = xmm0[0,1,0,2,4,5,6,7]<br>
+; SSE-NEXT:    punpckldq {{.*#+}} xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1<wbr>]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm2 = xmm4[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm2 = xmm2[0,2,2,3,4,5,6,7]<br>
+; SSE-NEXT:    pshufd {{.*#+}} xmm1 = xmm1[0,2,2,3]<br>
+; SSE-NEXT:    pshuflw {{.*#+}} xmm1 = xmm1[0,2,2,3,4,5,6,7]<br>
+; SSE-NEXT:    punpckldq {{.*#+}} xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1<wbr>]<br>
+; SSE-NEXT:    movsd {{.*#+}} xmm0 = xmm2[0],xmm0[1]<br>
 ; SSE-NEXT:    retq<br>
 ;<br>
 ; AVX1-LABEL: trunc_add_const_v16i64_v16i16:<br>
@@ -834,25 +826,22 @@ define <4 x i32> @trunc_sub_v4i64_4i32(<<br>
 define <8 x i16> @trunc_sub_v8i64_8i16(<8 x i64> %a0, <8 x i64> %a1) nounwind {<br>
 ; SSE-LABEL: trunc_sub_v8i64_8i16:<br>
 ; SSE:       # BB#0:<br>
-; SSE-NEXT:    psubq %xmm6, %xmm2<br>
 ; SSE-NEXT:    psubq %xmm4, %xmm0<br>
-; SSE-NEXT:    psubq %xmm7, %xmm3<br>
 ; SSE-NEXT:    psubq %xmm5, %xmm1<br>
-; SSE-NEXT:    pextrw $4, %xmm1, %eax<br>
-; SSE-NEXT:    punpcklwd {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1<wbr>],xmm1[2],xmm3[2],xmm1[3],xmm3<wbr>[3]<br>
-; </blockquote></div></div></div></div>...<br><br>[Message clipped]  </blockquote></div><br></div>