Lines Matching defs:shuffle
7286 // check if an VEXT instruction can handle the shuffle mask when the
7287 // vector sources of the shuffle are the same.
7291 // Assume that the first shuffle index is not UNDEF. Fail if it is.
7297 // If this is a VEXT shuffle, the immediate value is the index of the first
7298 // element. The other shuffle indices must be the successive elements after
7321 // Assume that the first shuffle index is not UNDEF. Fail if it is.
7327 // If this is a VEXT shuffle, the immediate value is the index of the first
7328 // element. The other shuffle indices must be the successive elements after
7366 // Checks whether the shuffle mask represents a vector transpose (VTRN) by
7367 // checking that pairs of elements in the shuffle mask represent the same index
7369 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 4, 2, 6]
7378 // where v1/v2 and the shuffle masks have the same number of elements
7383 // where both results are returned in one vector and the shuffle mask has twice
7385 // want to check the low half and high half of the shuffle mask as if it were
7443 // Checks whether the shuffle mask represents a vector unzip (VUZP) by checking
7446 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 2, 4, 6]
7514 // Checks whether the shuffle mask represents a vector zip (VZIP) by checking
7517 // e.g. For v1,v2 of type v4i32 a valid shuffle mask is: [0, 4, 1, 5]
7585 /// Check if \p ShuffleMask is a NEON two-result shuffle (VZIP, VUZP, VTRN),
7675 // Test if the Trunc can be convertable to a VMOVN with this shuffle. We are
8154 if (SDValue shuffle = ReconstructShuffle(Op, DAG))
8155 return shuffle;
8199 // scalar_to_vector for the elements followed by a shuffle (provided the
8200 // shuffle is valid for the target) and materialization element by element
8218 // shuffle in combination with VEXTs.
8232 // be compatible with the shuffle we intend to construct. As a result
8254 // A shuffle can only come from building a vector from various
8294 // to construct a compatible shuffle either by concatenating it with UNDEF or
8314 // shuffle...
8358 // for the shuffle.
8369 // Final check before we try to actually produce a shuffle.
8375 // The stars all align, our next step is to produce the mask for the shuffle.
8394 // This source is expected to fill ResMultiplier lanes of the final shuffle,
8467 // Compute the index in the perfect shuffle table.
8509 /// GeneratePerfectShuffle - Given an entry in the perfect-shuffle table, emit
8510 /// the specified operations to build the shuffle.
8530 default: llvm_unreachable("Unknown shuffle opcode!");
8597 // into the bottom double word, through a new vector shuffle that will be
8653 // appropriate for the shuffle, i.e. v4i32 for a real v4i1 predicate.
8664 "No support for vector shuffle of boolean predicates");
8678 // shuffle in existence we have chosen the least painful strategy. This is
8681 // vector shuffle and convert the result back into a predicate vector. In
8683 // operating on bits. Just imagine trying to shuffle 8 arbitrary 2-bit
8690 "Expected identical vector type in expanded i1 shuffle!");
8692 // Do the shuffle!
8712 // Attempt to lower the vector shuffle using as many whole register movs as
8772 // The other parts need to be built with the old shuffle vector, cast to a
8945 // shuffle(concat(v1, undef), concat(v2, undef))
8947 // shuffle(concat(v1, v2), undef)
8954 // shuffle(concat(v1, v2), undef)
8966 }) && "Unexpected shuffle index into UNDEF operand!");
8973 "In-place shuffle of concat can only have one result!");
9005 // If the shuffle is not directly supported and it has 4 elements, use
9017 // Compute the index in the perfect shuffle table.
12679 // VUZP shuffle node.
15748 // shuffle(MVETrunc(x, y)) -> VMOVN(x, y)
15778 // The LLVM shufflevector instruction does not require the shuffle mask
15786 // shuffle(concat(v1, undef), concat(v2, undef)) ->
15787 // shuffle(concat(v1, v2), undef)
15809 // Translate the shuffle mask.
16598 // Optimize trunc store (of multiple scalars) to shuffle and store. First,
16626 // Create a type on which we perform the shuffle.
16638 // Can't shuffle using an illegal type.
16708 // Test if the Trunc will be convertable to a VMOVN with a shuffle, and if so
16712 // The shuffle may either be a single source (in which case N = NumElts/2) or
17401 // Looks for vaddv(shuffle) or vmlav(shuffle, shuffle), with a shuffle where all
17402 // the lanes are used. Due to the reduction being commutative the shuffle can be
17501 // Turn VQDMULH(shuffle, shuffle) -> shuffle(VQDMULH)
18673 // MVETrunc(shuffle, shuffle) -> VMOVN
18682 // Construct complete shuffle mask
18701 // For MVETrunc of a buildvector or shuffle, it can be beneficial to lower the
18847 // MVEEXT(shuffle) -> SIGN_EXTEND_INREG/ZERO_EXTEND_INREG
21572 /// %v0 = shuffle %wide.vec, undef, <0, 2, 4, 6> ; Extract even elements
21573 /// %v1 = shuffle %wide.vec, undef, <1, 3, 5, 7> ; Extract odd elements
21699 /// %i.vec = shuffle <8 x i32> %v0, <8 x i32> %v1,
21704 /// %sub.v0 = shuffle <8 x i32> %v0, <8 x i32> v1, <0, 1, 2, 3>
21705 /// %sub.v1 = shuffle <8 x i32> %v0, <8 x i32> v1, <4, 5, 6, 7>
21706 /// %sub.v2 = shuffle <8 x i32> %v0, <8 x i32> v1, <8, 9, 10, 11>
21713 /// %i.vec = shuffle <32 x i32> %v0, <32 x i32> %v1,
21718 /// %sub.v0 = shuffle <32 x i32> %v0, <32 x i32> v1, <4, 5, 6, 7>
21719 /// %sub.v1 = shuffle <32 x i32> %v0, <32 x i32> v1, <32, 33, 34, 35>
21720 /// %sub.v2 = shuffle <32 x i32> %v0, <32 x i32> v1, <16, 17, 18, 19>