Target/ARM/ARMISelLowering.cpp

6678 // check if an VEXT instruction can handle the shuffle mask when the
6679 // vector sources of the shuffle are the same.
6683   // Assume that the first shuffle index is not UNDEF.  Fail if it is.
6689   // If this is a VEXT shuffle, the immediate value is the index of the first
6690   // element.  The other shuffle indices must be the successive elements after
6713   // Assume that the first shuffle index is not UNDEF.  Fail if it is.
6719   // If this is a VEXT shuffle, the immediate value is the index of the first
6720   // element.  The other shuffle indices must be the successive elements after
6744 /// isVREVMask - Check if a vector shuffle corresponds to a VREV
6757   // If the first shuffle index is UNDEF, be optimistic.
6787 // Checks whether the shuffle mask represents a vector transpose (VTRN) by
6788 // checking that pairs of elements in the shuffle mask represent the same index
6790 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 4, 2, 6]
6799 // where v1/v2 and the shuffle masks have the same number of elements
6804 // where both results are returned in one vector and the shuffle mask has twice
6806 // want to check the low half and high half of the shuffle mask as if it were
6864 // Checks whether the shuffle mask represents a vector unzip (VUZP) by checking
6867 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 2, 4, 6]
6935 // Checks whether the shuffle mask represents a vector zip (VZIP) by checking
6938 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 4, 1, 5]
7006 /// Check if \p ShuffleMask is a NEON two-result shuffle (VZIP, VUZP, VTRN),
7327     SDValue shuffle = ReconstructShuffle(Op, DAG);
7328     if (shuffle != SDValue())
7329       return shuffle;
7368   // scalar_to_vector for the elements followed by a shuffle (provided the
7369   // shuffle is valid for the target) and materialization element by element
7387 // shuffle in combination with VEXTs.
7401     // be compatible with the shuffle we intend to construct. As a result
7423       // A shuffle can only come from building a vector from various
7463   // to construct a compatible shuffle either by concatenating it with UNDEF or
7481       // shuffle...
7525   // for the shuffle.
7536   // Final sanity check before we try to actually produce a shuffle.
7541   // The stars all align, our next step is to produce the mask for the shuffle.
7560     // This source is expected to fill ResMultiplier lanes of the final shuffle,
7633     // Compute the index in the perfect shuffle table.
7669 /// GeneratePerfectShuffle - Given an entry in the perfect-shuffle table, emit
7670 /// the specified operations to build the shuffle.
7690   default: llvm_unreachable("Unknown shuffle opcode!");
7811   // appropriate for the shuffle, i.e. v4i32 for a real v4i1 predicate.
7822          "No support for vector shuffle of boolean predicates");
7835   // shuffle in existence we have chosen the least painful strategy. This is
7838   // vector shuffle and convert the result back into a predicate vector. In
7840   // operating on bits. Just imagine trying to shuffle 8 arbitrary 2-bit
7845   // Do the shuffle!
7858   // Attempt to lower the vector shuffle using as many whole register movs as
7918   // The other parts need to be built with the old shuffle vector, cast to a
8037     //   shuffle(concat(v1, undef), concat(v2, undef))
8039     //   shuffle(concat(v1, v2), undef)
8046     //   shuffle(concat(v1, v2), undef)
8058       }) && "Unexpected shuffle index into UNDEF operand!");
8065                "In-place shuffle of concat can only have one result!");
8074   // If the shuffle is not directly supported and it has 4 elements, use
8086     // Compute the index in the perfect shuffle table.
11094   // VUZP shuffle node.
13019   // The LLVM shufflevector instruction does not require the shuffle mask
13027   //   shuffle(concat(v1, undef), concat(v2, undef)) ->
13028   //   shuffle(concat(v1, v2), undef)
13050   // Translate the shuffle mask.
13451 // Optimize trunc store (of multiple scalars) to shuffle and store.  First,
13479   // Create a type on which we perform the shuffle.
13491   // Can't shuffle using an illegal type.
15005   // All uses of the shuffle should be sunk to avoid duplicating it across gpr
17033 ///        %v0 = shuffle %wide.vec, undef, <0, 2, 4, 6>  ; Extract even elements
17034 ///        %v1 = shuffle %wide.vec, undef, <1, 3, 5, 7>  ; Extract odd elements
17171 ///        %i.vec = shuffle <8 x i32> %v0, <8 x i32> %v1,
17176 ///        %sub.v0 = shuffle <8 x i32> %v0, <8 x i32> v1, <0, 1, 2, 3>
17177 ///        %sub.v1 = shuffle <8 x i32> %v0, <8 x i32> v1, <4, 5, 6, 7>
17178 ///        %sub.v2 = shuffle <8 x i32> %v0, <8 x i32> v1, <8, 9, 10, 11>
17185 ///        %i.vec = shuffle <32 x i32> %v0, <32 x i32> %v1,
17190 ///        %sub.v0 = shuffle <32 x i32> %v0, <32 x i32> v1, <4, 5, 6, 7>
17191 ///        %sub.v1 = shuffle <32 x i32> %v0, <32 x i32> v1, <32, 33, 34, 35>
17192 ///        %sub.v2 = shuffle <32 x i32> %v0, <32 x i32> v1, <16, 17, 18, 19>