1//===-- X86ShuffleDecode.h - X86 shuffle decode logic -----------*-C++-*---===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Define several functions to decode x86 specific shuffle semantics into a
10// generic vector mask.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_TARGET_X86_UTILS_X86SHUFFLEDECODE_H
15#define LLVM_LIB_TARGET_X86_UTILS_X86SHUFFLEDECODE_H
16
17#include <cstdint>
18
19//===----------------------------------------------------------------------===//
20// Vector Mask Decoding
21//===----------------------------------------------------------------------===//
22
23namespace llvm {
24class APInt;
25template <typename T> class ArrayRef;
26template <typename T> class SmallVectorImpl;
27
28enum { SM_SentinelUndef = -1, SM_SentinelZero = -2 };
29
30/// Decode a 128-bit INSERTPS instruction as a v4f32 shuffle mask.
31void DecodeINSERTPSMask(unsigned Imm, SmallVectorImpl<int> &ShuffleMask,
32 bool SrcIsMem);
33
34// Insert the bottom Len elements from a second source into a vector starting at
35// element Idx.
36void DecodeInsertElementMask(unsigned NumElts, unsigned Idx, unsigned Len,
37 SmallVectorImpl<int> &ShuffleMask);
38
39/// Decode a MOVHLPS instruction as a v2f64/v4f32 shuffle mask.
40/// i.e. <3,1> or <6,7,2,3>
41void DecodeMOVHLPSMask(unsigned NElts, SmallVectorImpl<int> &ShuffleMask);
42
43/// Decode a MOVLHPS instruction as a v2f64/v4f32 shuffle mask.
44/// i.e. <0,2> or <0,1,4,5>
45void DecodeMOVLHPSMask(unsigned NElts, SmallVectorImpl<int> &ShuffleMask);
46
47void DecodeMOVSLDUPMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
48
49void DecodeMOVSHDUPMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
50
51void DecodeMOVDDUPMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
52
53void DecodePSLLDQMask(unsigned NumElts, unsigned Imm,
54 SmallVectorImpl<int> &ShuffleMask);
55
56void DecodePSRLDQMask(unsigned NumElts, unsigned Imm,
57 SmallVectorImpl<int> &ShuffleMask);
58
59void DecodePALIGNRMask(unsigned NumElts, unsigned Imm,
60 SmallVectorImpl<int> &ShuffleMask);
61
62void DecodeVALIGNMask(unsigned NumElts, unsigned Imm,
63 SmallVectorImpl<int> &ShuffleMask);
64
65/// Decodes the shuffle masks for pshufd/pshufw/vpermilpd/vpermilps.
66void DecodePSHUFMask(unsigned NumElts, unsigned ScalarBits, unsigned Imm,
67 SmallVectorImpl<int> &ShuffleMask);
68
69/// Decodes the shuffle masks for pshufhw.
70void DecodePSHUFHWMask(unsigned NumElts, unsigned Imm,
71 SmallVectorImpl<int> &ShuffleMask);
72
73/// Decodes the shuffle masks for pshuflw.
74void DecodePSHUFLWMask(unsigned NumElts, unsigned Imm,
75 SmallVectorImpl<int> &ShuffleMask);
76
77/// Decodes a PSWAPD 3DNow! instruction.
78void DecodePSWAPMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
79
80/// Decodes the shuffle masks for shufp*.
81void DecodeSHUFPMask(unsigned NumElts, unsigned ScalarBits, unsigned Imm,
82 SmallVectorImpl<int> &ShuffleMask);
83
84/// Decodes the shuffle masks for unpckhps/unpckhpd and punpckh*.
85void DecodeUNPCKHMask(unsigned NumElts, unsigned ScalarBits,
86 SmallVectorImpl<int> &ShuffleMask);
87
88/// Decodes the shuffle masks for unpcklps/unpcklpd and punpckl*.
89void DecodeUNPCKLMask(unsigned NumElts, unsigned ScalarBits,
90 SmallVectorImpl<int> &ShuffleMask);
91
92/// Decodes a broadcast of the first element of a vector.
93void DecodeVectorBroadcast(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
94
95/// Decodes a broadcast of a subvector to a larger vector type.
96void DecodeSubVectorBroadcast(unsigned DstNumElts, unsigned SrcNumElts,
97 SmallVectorImpl<int> &ShuffleMask);
98
99/// Decode a PSHUFB mask from a raw array of constants such as from
100/// BUILD_VECTOR.
101void DecodePSHUFBMask(ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
102 SmallVectorImpl<int> &ShuffleMask);
103
104/// Decode a BLEND immediate mask into a shuffle mask.
105void DecodeBLENDMask(unsigned NumElts, unsigned Imm,
106 SmallVectorImpl<int> &ShuffleMask);
107
108void DecodeVPERM2X128Mask(unsigned NumElts, unsigned Imm,
109 SmallVectorImpl<int> &ShuffleMask);
110
111/// Decode a shuffle packed values at 128-bit granularity
112/// (SHUFF32x4/SHUFF64x2/SHUFI32x4/SHUFI64x2)
113/// immediate mask into a shuffle mask.
114void decodeVSHUF64x2FamilyMask(unsigned NumElts, unsigned ScalarSize,
115 unsigned Imm, SmallVectorImpl<int> &ShuffleMask);
116
117/// Decodes the shuffle masks for VPERMQ/VPERMPD.
118void DecodeVPERMMask(unsigned NumElts, unsigned Imm,
119 SmallVectorImpl<int> &ShuffleMask);
120
121/// Decode a VPPERM mask from a raw array of constants such as from
122/// BUILD_VECTOR.
123/// This can only basic masks (permutes + zeros), not any of the other
124/// operations that VPPERM can perform.
125void DecodeVPPERMMask(ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
126 SmallVectorImpl<int> &ShuffleMask);
127
128/// Decode a zero extension instruction as a shuffle mask.
129void DecodeZeroExtendMask(unsigned SrcScalarBits, unsigned DstScalarBits,
130 unsigned NumDstElts, bool IsAnyExtend,
131 SmallVectorImpl<int> &ShuffleMask);
132
133/// Decode a move lower and zero upper instruction as a shuffle mask.
134void DecodeZeroMoveLowMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask);
135
136/// Decode a scalar float move instruction as a shuffle mask.
137void DecodeScalarMoveMask(unsigned NumElts, bool IsLoad,
138 SmallVectorImpl<int> &ShuffleMask);
139
140/// Decode a SSE4A EXTRQ instruction as a shuffle mask.
141void DecodeEXTRQIMask(unsigned NumElts, unsigned EltSize, int Len, int Idx,
142 SmallVectorImpl<int> &ShuffleMask);
143
144/// Decode a SSE4A INSERTQ instruction as a shuffle mask.
145void DecodeINSERTQIMask(unsigned NumElts, unsigned EltSize, int Len, int Idx,
146 SmallVectorImpl<int> &ShuffleMask);
147
148/// Decode a VPERMILPD/VPERMILPS variable mask from a raw array of constants.
149void DecodeVPERMILPMask(unsigned NumElts, unsigned ScalarBits,
150 ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
151 SmallVectorImpl<int> &ShuffleMask);
152
153/// Decode a VPERMIL2PD/VPERMIL2PS variable mask from a raw array of constants.
154void DecodeVPERMIL2PMask(unsigned NumElts, unsigned ScalarBits, unsigned M2Z,
155 ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
156 SmallVectorImpl<int> &ShuffleMask);
157
158/// Decode a VPERM W/D/Q/PS/PD mask from a raw array of constants.
159void DecodeVPERMVMask(ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
160 SmallVectorImpl<int> &ShuffleMask);
161
162/// Decode a VPERMT2 W/D/Q/PS/PD mask from a raw array of constants.
163void DecodeVPERMV3Mask(ArrayRef<uint64_t> RawMask, const APInt &UndefElts,
164 SmallVectorImpl<int> &ShuffleMask);
165} // llvm namespace
166
167#endif
168