Lines Matching refs:Shuffle
2788 // Xor/and/or are indifferent to the swizzle operation (shuffle of one value).
2790 // If both shuffles use the same mask, and both shuffle within a single
2793 // vector types from memory. In many cases this allows additional shuffle
2795 // There are other cases where moving the shuffle after the xor/and/or
2798 // or second operand, then it might still be profitable to move the shuffle
3703 // Do this only if the resulting shuffle is legal.
3714 // We construct two shuffle masks:
3715 // - Mask1 is a shuffle mask for a shuffle with N0 as the first operand
3717 // - Mask2 is a shuffle mask for a shuffle with N1 as the first operand
3720 // two ways to fold this node into a shuffle.
3728 // Both shuffle indexes are undef. Propagate Undef.
3747 // Fold this sequence only if the resulting shuffle is 'legal'.
7456 // bitcast(shuffle(bitcast(s0),bitcast(s1))) -> shuffle(s0,s1)
12276 // (vextract (v4f32 shuffle (load $addr), <1,u,u,u>), 0) -> (f32 load $addr)
12404 // turn into a single shuffle instruction.
12539 // at most two distinct vectors, turn this into a shuffle node.
12541 // Only type-legal BUILD_VECTOR nodes are converted to shuffle nodes.
12545 // May only combine to shuffle after legalize if shuffle is legal.
12586 // If everything is good, we can make a shuffle operation.
12623 // We can't generate a shuffle node with mismatched input and output types.
12761 // into a legal shuffle.
12776 // UNDEF nodes convert to UNDEF shuffle mask values.
12796 // UNDEF nodes convert to UNDEF shuffle mask values.
12820 // At most we can reference 2 inputs in the final shuffle.
13139 // Tries to turn a shuffle of two CONCAT_VECTORS into a single concat,
13140 // or turn a shuffle of a single concat into simpler shuffle then concat.
13154 // Special case: shuffle(concat(A,B)) can be more efficiently represented
13155 // as concat(shuffle(A,B),UNDEF) if the shuffle doesn't set any of the high
13210 assert(N0.getValueType() == VT && "Vector shuffle must be normalized in DAG");
13212 // Canonicalize shuffle undef, undef -> undef
13218 // Canonicalize shuffle v, v -> v, undef
13230 // Canonicalize shuffle undef, v -> v, undef. Commute the shuffle mask.
13309 // BUILD_VECTOR may not match the type of the shuffle.
13333 // Attempt to combine a shuffle of 2 inputs of 'scalar sources' -
13370 // If this shuffle only has a single input that is a bitcasted shuffle,
13401 // Determine which shuffle works with the smaller scalar type.
13412 // Scale the shuffle masks to the smaller scalar type.
13419 // Merge the shuffle masks.
13424 // Test for shuffle mask legality over both commutations.
13446 // shuffle(A, shuffle(A, B)) -> shuffle(shuffle(A,B), A)
13447 // shuffle(B, shuffle(A, B)) -> shuffle(shuffle(A,B), B)
13448 // shuffle(B, shuffle(A, Undef)) -> shuffle(shuffle(A, Undef), B)
13452 // The incoming shuffle must be of the same type as the result of the
13453 // current shuffle.
13455 "Shuffle types don't match");
13462 // Commute the operands of this shuffle so that next rule
13468 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(A, B, M2)
13469 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(A, C, M2)
13470 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(B, C, M2)
13472 // Only fold if this shuffle is the only user of the other shuffle.
13477 // The incoming shuffle must be of the same type as the result of the
13478 // current shuffle.
13480 "Shuffle types don't match");
13484 // Compute the combined shuffle mask for a shuffle with SV0 as the first
13496 // This shuffle index refers to the inner shuffle N0. Lookup the inner
13497 // shuffle mask to identify which vector is actually referenced.
13508 // This shuffle index references an element within N1.
13518 // Canonicalize the shuffle index. We don't know yet if CurrentVec
13519 // will be the first or second operand of the combined shuffle.
13529 // Bail out if we cannot convert the shuffle pair into a single shuffle.
13559 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(B, A, M2)
13560 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(C, A, M2)
13561 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(C, B, M2)
13565 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(A, B, M2)
13566 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(A, C, M2)
13567 // shuffle(shuffle(A, B, M0), C, M1) -> shuffle(B, C, M2)
13584 // FIXME: We could support implicit truncation if the shuffle can be
13683 // all zeros or all ones - suitable for shuffle masking.
13763 // Try to convert a constant mask AND into a shuffle clear mask.
13764 if (SDValue Shuffle = XformToShuffleWithZero(N))
13765 return Shuffle;
13768 // Fold (VBinOp (shuffle (A, Undef, Mask)), (shuffle (B, Undef, Mask)))
13769 // -> (shuffle (VBinOp (A, B)), Undef, Mask).
