lib/Target/X86/Utils/X86ShuffleDecode.cpp

   1 //===-- X86ShuffleDecode.cpp - X86 shuffle decode logic -------------------===//\r
   2 //\r
   3 //                     The LLVM Compiler Infrastructure\r
   4 //\r
   5 // This file is distributed under the University of Illinois Open Source\r
   6 // License. See LICENSE.TXT for details.\r
   7 //\r
   8 //===----------------------------------------------------------------------===//\r
   9 //\r
  10 // Define several functions to decode x86 specific shuffle semantics into a\r
  11 // generic vector mask.\r
  12 //\r
  13 //===----------------------------------------------------------------------===//\r
  14 \r
  15 #include "X86ShuffleDecode.h"\r
  16 #include "llvm/IR/Constants.h"\r
  17 #include "llvm/CodeGen/MachineValueType.h"\r
  18 \r
  19 //===----------------------------------------------------------------------===//\r
  20 //  Vector Mask Decoding\r
  21 //===----------------------------------------------------------------------===//\r
  22 \r
  23 namespace llvm {\r
  24 \r
  25 void DecodeINSERTPSMask(unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
  26   // Defaults the copying the dest value.\r
  27   ShuffleMask.push_back(0);\r
  28   ShuffleMask.push_back(1);\r
  29   ShuffleMask.push_back(2);\r
  30   ShuffleMask.push_back(3);\r
  31 \r
  32   // Decode the immediate.\r
  33   unsigned ZMask = Imm & 15;\r
  34   unsigned CountD = (Imm >> 4) & 3;\r
  35   unsigned CountS = (Imm >> 6) & 3;\r
  36 \r
  37   // CountS selects which input element to use.\r
  38   unsigned InVal = 4+CountS;\r
  39   // CountD specifies which element of destination to update.\r
  40   ShuffleMask[CountD] = InVal;\r
  41   // ZMask zaps values, potentially overriding the CountD elt.\r
  42   if (ZMask & 1) ShuffleMask[0] = SM_SentinelZero;\r
  43   if (ZMask & 2) ShuffleMask[1] = SM_SentinelZero;\r
  44   if (ZMask & 4) ShuffleMask[2] = SM_SentinelZero;\r
  45   if (ZMask & 8) ShuffleMask[3] = SM_SentinelZero;\r
  46 }\r
  47 \r
  48 // <3,1> or <6,7,2,3>\r
  49 void DecodeMOVHLPSMask(unsigned NElts, SmallVectorImpl<int> &ShuffleMask) {\r
  50   for (unsigned i = NElts/2; i != NElts; ++i)\r
  51     ShuffleMask.push_back(NElts+i);\r
  52 \r
  53   for (unsigned i = NElts/2; i != NElts; ++i)\r
  54     ShuffleMask.push_back(i);\r
  55 }\r
  56 \r
  57 // <0,2> or <0,1,4,5>\r
  58 void DecodeMOVLHPSMask(unsigned NElts, SmallVectorImpl<int> &ShuffleMask) {\r
  59   for (unsigned i = 0; i != NElts/2; ++i)\r
  60     ShuffleMask.push_back(i);\r
  61 \r
  62   for (unsigned i = 0; i != NElts/2; ++i)\r
  63     ShuffleMask.push_back(NElts+i);\r
  64 }\r
  65 \r
  66 void DecodeMOVSLDUPMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
  67   unsigned NumElts = VT.getVectorNumElements();\r
  68   for (int i = 0, e = NumElts / 2; i < e; ++i) {\r
  69     ShuffleMask.push_back(2 * i);\r
  70     ShuffleMask.push_back(2 * i);\r
  71   }\r
  72 }\r
  73 \r
  74 void DecodeMOVSHDUPMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
  75   unsigned NumElts = VT.getVectorNumElements();\r
  76   for (int i = 0, e = NumElts / 2; i < e; ++i) {\r
  77     ShuffleMask.push_back(2 * i + 1);\r
  78     ShuffleMask.push_back(2 * i + 1);\r
  79   }\r
  80 }\r
  81 \r
  82 void DecodeMOVDDUPMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
  83   unsigned VectorSizeInBits = VT.getSizeInBits();\r
  84   unsigned ScalarSizeInBits = VT.getScalarSizeInBits();\r
  85   unsigned NumElts = VT.getVectorNumElements();\r
  86   unsigned NumLanes = VectorSizeInBits / 128;\r
  87   unsigned NumLaneElts = NumElts / NumLanes;\r
  88   unsigned NumLaneSubElts = 64 / ScalarSizeInBits;\r
  89 \r
  90   for (unsigned l = 0; l < NumElts; l += NumLaneElts)\r
  91     for (unsigned i = 0; i < NumLaneElts; i += NumLaneSubElts)\r
  92       for (unsigned s = 0; s != NumLaneSubElts; s++)\r
  93         ShuffleMask.push_back(l + s);\r
  94 }\r
  95 \r
  96 void DecodePSLLDQMask(MVT VT, unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
  97   unsigned VectorSizeInBits = VT.getSizeInBits();\r
  98   unsigned NumElts = VectorSizeInBits / 8;\r
  99   unsigned NumLanes = VectorSizeInBits / 128;\r
 100   unsigned NumLaneElts = NumElts / NumLanes;\r
 101 \r
 102   for (unsigned l = 0; l < NumElts; l += NumLaneElts)\r
 103     for (unsigned i = 0; i < NumLaneElts; ++i) {\r
 104       int M = SM_SentinelZero;\r
 105       if (i >= Imm) M = i - Imm + l;\r
 106       ShuffleMask.push_back(M);\r
 107     }\r
 108 }\r
 109 \r
 110 void DecodePSRLDQMask(MVT VT, unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
 111   unsigned VectorSizeInBits = VT.getSizeInBits();\r
 112   unsigned NumElts = VectorSizeInBits / 8;\r
 113   unsigned NumLanes = VectorSizeInBits / 128;\r
 114   unsigned NumLaneElts = NumElts / NumLanes;\r
 115 \r
 116   for (unsigned l = 0; l < NumElts; l += NumLaneElts)\r
 117     for (unsigned i = 0; i < NumLaneElts; ++i) {\r
 118       unsigned Base = i + Imm;\r
 119       int M = Base + l;\r
 120       if (Base >= NumLaneElts) M = SM_SentinelZero;\r
 121       ShuffleMask.push_back(M);\r
 122     }\r
 123 }\r
 124 \r
 125 void DecodePALIGNRMask(MVT VT, unsigned Imm,\r
 126                        SmallVectorImpl<int> &ShuffleMask) {\r
 127   unsigned NumElts = VT.getVectorNumElements();\r
 128   unsigned Offset = Imm * (VT.getVectorElementType().getSizeInBits() / 8);\r
 129 \r
 130   unsigned NumLanes = VT.getSizeInBits() / 128;\r
 131   unsigned NumLaneElts = NumElts / NumLanes;\r
 132 \r
 133   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {\r
 134     for (unsigned i = 0; i != NumLaneElts; ++i) {\r
 135       unsigned Base = i + Offset;\r
 136       // if i+offset is out of this lane then we actually need the other source\r
 137       if (Base >= NumLaneElts) Base += NumElts - NumLaneElts;\r
 138       ShuffleMask.push_back(Base + l);\r
 139     }\r
 140   }\r
 141 }\r
 142 \r
 143 /// DecodePSHUFMask - This decodes the shuffle masks for pshufd, and vpermilp*.\r
 144 /// VT indicates the type of the vector allowing it to handle different\r
 145 /// datatypes and vector widths.\r
 146 void DecodePSHUFMask(MVT VT, unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
 147   unsigned NumElts = VT.getVectorNumElements();\r
 148 \r
 149   unsigned NumLanes = VT.getSizeInBits() / 128;\r
 150   unsigned NumLaneElts = NumElts / NumLanes;\r
 151 \r
 152   unsigned NewImm = Imm;\r
 153   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {\r
 154     for (unsigned i = 0; i != NumLaneElts; ++i) {\r
 155       ShuffleMask.push_back(NewImm % NumLaneElts + l);\r
 156       NewImm /= NumLaneElts;\r
 157     }\r
 158     if (NumLaneElts == 4) NewImm = Imm; // reload imm\r
 159   }\r
 160 }\r
 161 \r
 162 void DecodePSHUFHWMask(MVT VT, unsigned Imm,\r
 163                        SmallVectorImpl<int> &ShuffleMask) {\r
 164   unsigned NumElts = VT.getVectorNumElements();\r
 165 \r
 166   for (unsigned l = 0; l != NumElts; l += 8) {\r
 167     unsigned NewImm = Imm;\r
 168     for (unsigned i = 0, e = 4; i != e; ++i) {\r
 169       ShuffleMask.push_back(l + i);\r
 170     }\r
 171     for (unsigned i = 4, e = 8; i != e; ++i) {\r
 172       ShuffleMask.push_back(l + 4 + (NewImm & 3));\r
 173       NewImm >>= 2;\r
 174     }\r
 175   }\r
 176 }\r
 177 \r
 178 void DecodePSHUFLWMask(MVT VT, unsigned Imm,\r
 179                        SmallVectorImpl<int> &ShuffleMask) {\r
 180   unsigned NumElts = VT.getVectorNumElements();\r
 181 \r
 182   for (unsigned l = 0; l != NumElts; l += 8) {\r
 183     unsigned NewImm = Imm;\r
 184     for (unsigned i = 0, e = 4; i != e; ++i) {\r
 185       ShuffleMask.push_back(l + (NewImm & 3));\r
 186       NewImm >>= 2;\r
 187     }\r
 188     for (unsigned i = 4, e = 8; i != e; ++i) {\r
 189       ShuffleMask.push_back(l + i);\r
 190     }\r
 191   }\r
 192 }\r
 193 \r
 194 /// DecodeSHUFPMask - This decodes the shuffle masks for shufp*. VT indicates\r
 195 /// the type of the vector allowing it to handle different datatypes and vector\r
 196 /// widths.\r
 197 void DecodeSHUFPMask(MVT VT, unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
 198   unsigned NumElts = VT.getVectorNumElements();\r
 199 \r
 200   unsigned NumLanes = VT.getSizeInBits() / 128;\r
 201   unsigned NumLaneElts = NumElts / NumLanes;\r
 202 \r
 203   unsigned NewImm = Imm;\r
 204   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {\r
 205     // each half of a lane comes from different source\r
 206     for (unsigned s = 0; s != NumElts*2; s += NumElts) {\r
 207       for (unsigned i = 0; i != NumLaneElts/2; ++i) {\r
 208         ShuffleMask.push_back(NewImm % NumLaneElts + s + l);\r
 209         NewImm /= NumLaneElts;\r
 210       }\r
 211     }\r
 212     if (NumLaneElts == 4) NewImm = Imm; // reload imm\r
 213   }\r
 214 }\r
 215 \r
 216 /// DecodeUNPCKHMask - This decodes the shuffle masks for unpckhps/unpckhpd\r
 217 /// and punpckh*. VT indicates the type of the vector allowing it to handle\r
 218 /// different datatypes and vector widths.\r
 219 void DecodeUNPCKHMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
 220   unsigned NumElts = VT.getVectorNumElements();\r
 221 \r
 222   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate\r
 223   // independently on 128-bit lanes.\r
 224   unsigned NumLanes = VT.getSizeInBits() / 128;\r
 225   if (NumLanes == 0 ) NumLanes = 1;  // Handle MMX\r
 226   unsigned NumLaneElts = NumElts / NumLanes;\r
 227 \r
 228   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {\r
 229     for (unsigned i = l + NumLaneElts/2, e = l + NumLaneElts; i != e; ++i) {\r
 230       ShuffleMask.push_back(i);          // Reads from dest/src1\r
 231       ShuffleMask.push_back(i+NumElts);  // Reads from src/src2\r
 232     }\r
 233   }\r
 234 }\r
 235 \r
 236 /// DecodeUNPCKLMask - This decodes the shuffle masks for unpcklps/unpcklpd\r
 237 /// and punpckl*. VT indicates the type of the vector allowing it to handle\r
 238 /// different datatypes and vector widths.\r
 239 void DecodeUNPCKLMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
 240   unsigned NumElts = VT.getVectorNumElements();\r
 241 \r
 242   // Handle 128 and 256-bit vector lengths. AVX defines UNPCK* to operate\r
 243   // independently on 128-bit lanes.\r
 244   unsigned NumLanes = VT.getSizeInBits() / 128;\r
 245   if (NumLanes == 0 ) NumLanes = 1;  // Handle MMX\r
 246   unsigned NumLaneElts = NumElts / NumLanes;\r
 247 \r
 248   for (unsigned l = 0; l != NumElts; l += NumLaneElts) {\r
 249     for (unsigned i = l, e = l + NumLaneElts/2; i != e; ++i) {\r
 250       ShuffleMask.push_back(i);          // Reads from dest/src1\r
 251       ShuffleMask.push_back(i+NumElts);  // Reads from src/src2\r
 252     }\r
 253   }\r
 254 }\r
 255 \r
 256 void DecodeVPERM2X128Mask(MVT VT, unsigned Imm,\r
 257                           SmallVectorImpl<int> &ShuffleMask) {\r
 258   if (Imm & 0x88)\r
 259     return; // Not a shuffle\r
 260 \r
 261   unsigned HalfSize = VT.getVectorNumElements()/2;\r
 262 \r
 263   for (unsigned l = 0; l != 2; ++l) {\r
 264     unsigned HalfBegin = ((Imm >> (l*4)) & 0x3) * HalfSize;\r
 265     for (unsigned i = HalfBegin, e = HalfBegin+HalfSize; i != e; ++i)\r
 266       ShuffleMask.push_back(i);\r
 267   }\r
 268 }\r
 269 \r
 270 void DecodePSHUFBMask(const Constant *C, SmallVectorImpl<int> &ShuffleMask) {\r
 271   Type *MaskTy = C->getType();\r
 272   // It is not an error for the PSHUFB mask to not be a vector of i8 because the\r
 273   // constant pool uniques constants by their bit representation.\r
 274   // e.g. the following take up the same space in the constant pool:\r
 275   //   i128 -170141183420855150465331762880109871104\r
 276   //\r
 277   //   <2 x i64> <i64 -9223372034707292160, i64 -9223372034707292160>\r
 278   //\r
 279   //   <4 x i32> <i32 -2147483648, i32 -2147483648,\r
 280   //              i32 -2147483648, i32 -2147483648>\r
 281 \r
 282   unsigned MaskTySize = MaskTy->getPrimitiveSizeInBits();\r
 283 \r
 284   if (MaskTySize != 128 && MaskTySize != 256) // FIXME: Add support for AVX-512.\r
 285     return;\r
 286 \r
 287   // This is a straightforward byte vector.\r
 288   if (MaskTy->isVectorTy() && MaskTy->getVectorElementType()->isIntegerTy(8)) {\r
 289     int NumElements = MaskTy->getVectorNumElements();\r
 290     ShuffleMask.reserve(NumElements);\r
 291 \r
 292     for (int i = 0; i < NumElements; ++i) {\r
 293       // For AVX vectors with 32 bytes the base of the shuffle is the 16-byte\r
 294       // lane of the vector we're inside.\r
 295       int Base = i < 16 ? 0 : 16;\r
 296       Constant *COp = C->getAggregateElement(i);\r
 297       if (!COp) {\r
 298         ShuffleMask.clear();\r
 299         return;\r
 300       } else if (isa<UndefValue>(COp)) {\r
 301         ShuffleMask.push_back(SM_SentinelUndef);\r
 302         continue;\r
 303       }\r
 304       uint64_t Element = cast<ConstantInt>(COp)->getZExtValue();\r
 305       // If the high bit (7) of the byte is set, the element is zeroed.\r
 306       if (Element & (1 << 7))\r
 307         ShuffleMask.push_back(SM_SentinelZero);\r
 308       else {\r
 309         // Only the least significant 4 bits of the byte are used.\r
 310         int Index = Base + (Element & 0xf);\r
 311         ShuffleMask.push_back(Index);\r
 312       }\r
 313     }\r
 314   }\r
 315   // TODO: Handle funny-looking vectors too.\r
 316 }\r
 317 \r
 318 void DecodePSHUFBMask(ArrayRef<uint64_t> RawMask,\r
 319                       SmallVectorImpl<int> &ShuffleMask) {\r
 320   for (int i = 0, e = RawMask.size(); i < e; ++i) {\r
 321     uint64_t M = RawMask[i];\r
 322     if (M == (uint64_t)SM_SentinelUndef) {\r
 323       ShuffleMask.push_back(M);\r
 324       continue;\r
 325     }\r
 326     // For AVX vectors with 32 bytes the base of the shuffle is the half of\r
 327     // the vector we're inside.\r
 328     int Base = i < 16 ? 0 : 16;\r
 329     // If the high bit (7) of the byte is set, the element is zeroed.\r
 330     if (M & (1 << 7))\r
 331       ShuffleMask.push_back(SM_SentinelZero);\r
 332     else {\r
 333       // Only the least significant 4 bits of the byte are used.\r
 334       int Index = Base + (M & 0xf);\r
 335       ShuffleMask.push_back(Index);\r
 336     }\r
 337   }\r
 338 }\r
 339 \r
 340 void DecodeBLENDMask(MVT VT, unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
 341   int ElementBits = VT.getScalarSizeInBits();\r
 342   int NumElements = VT.getVectorNumElements();\r
 343   for (int i = 0; i < NumElements; ++i) {\r
 344     // If there are more than 8 elements in the vector, then any immediate blend\r
 345     // mask applies to each 128-bit lane. There can never be more than\r
 346     // 8 elements in a 128-bit lane with an immediate blend.\r
 347     int Bit = NumElements > 8 ? i % (128 / ElementBits) : i;\r
 348     assert(Bit < 8 &&\r
 349            "Immediate blends only operate over 8 elements at a time!");\r
 350     ShuffleMask.push_back(((Imm >> Bit) & 1) ? NumElements + i : i);\r
 351   }\r
 352 }\r
 353 \r
 354 /// DecodeVPERMMask - this decodes the shuffle masks for VPERMQ/VPERMPD.\r
 355 /// No VT provided since it only works on 256-bit, 4 element vectors.\r
 356 void DecodeVPERMMask(unsigned Imm, SmallVectorImpl<int> &ShuffleMask) {\r
 357   for (unsigned i = 0; i != 4; ++i) {\r
 358     ShuffleMask.push_back((Imm >> (2*i)) & 3);\r
 359   }\r
 360 }\r
 361 \r
 362 void DecodeVPERMILPMask(const Constant *C, SmallVectorImpl<int> &ShuffleMask) {\r
 363   Type *MaskTy = C->getType();\r
 364   assert(MaskTy->isVectorTy() && "Expected a vector constant mask!");\r
 365   assert(MaskTy->getVectorElementType()->isIntegerTy() &&\r
 366          "Expected integer constant mask elements!");\r
 367   int ElementBits = MaskTy->getScalarSizeInBits();\r
 368   int NumElements = MaskTy->getVectorNumElements();\r
 369   assert((NumElements == 2 || NumElements == 4 || NumElements == 8) &&\r
 370          "Unexpected number of vector elements.");\r
 371   ShuffleMask.reserve(NumElements);\r
 372   if (auto *CDS = dyn_cast<ConstantDataSequential>(C)) {\r
 373     assert((unsigned)NumElements == CDS->getNumElements() &&\r
 374            "Constant mask has a different number of elements!");\r
 375 \r
 376     for (int i = 0; i < NumElements; ++i) {\r
 377       int Base = (i * ElementBits / 128) * (128 / ElementBits);\r
 378       uint64_t Element = CDS->getElementAsInteger(i);\r
 379       // Only the least significant 2 bits of the integer are used.\r
 380       int Index = Base + (Element & 0x3);\r
 381       ShuffleMask.push_back(Index);\r
 382     }\r
 383   } else if (auto *CV = dyn_cast<ConstantVector>(C)) {\r
 384     assert((unsigned)NumElements == C->getNumOperands() &&\r
 385            "Constant mask has a different number of elements!");\r
 386 \r
 387     for (int i = 0; i < NumElements; ++i) {\r
 388       int Base = (i * ElementBits / 128) * (128 / ElementBits);\r
 389       Constant *COp = CV->getOperand(i);\r
 390       if (isa<UndefValue>(COp)) {\r
 391         ShuffleMask.push_back(SM_SentinelUndef);\r
 392         continue;\r
 393       }\r
 394       uint64_t Element = cast<ConstantInt>(COp)->getZExtValue();\r
 395       // Only the least significant 2 bits of the integer are used.\r
 396       int Index = Base + (Element & 0x3);\r
 397       ShuffleMask.push_back(Index);\r
 398     }\r
 399   }\r
 400 }\r
 401 \r
 402 void DecodeZeroExtendMask(MVT SrcVT, MVT DstVT, SmallVectorImpl<int> &Mask) {\r
 403   unsigned NumDstElts = DstVT.getVectorNumElements();\r
 404   unsigned SrcScalarBits = SrcVT.getScalarSizeInBits();\r
 405   unsigned DstScalarBits = DstVT.getScalarSizeInBits();\r
 406   unsigned Scale = DstScalarBits / SrcScalarBits;\r
 407   assert(SrcScalarBits < DstScalarBits &&\r
 408          "Expected zero extension mask to increase scalar size");\r
 409   assert(SrcVT.getVectorNumElements() >= NumDstElts &&\r
 410          "Too many zero extension lanes");\r
 411 \r
 412   for (unsigned i = 0; i != NumDstElts; i++) {\r
 413     Mask.push_back(i);\r
 414     for (unsigned j = 1; j != Scale; j++)\r
 415       Mask.push_back(SM_SentinelZero);\r
 416   }\r
 417 }\r
 418 \r
 419 void DecodeZeroMoveLowMask(MVT VT, SmallVectorImpl<int> &ShuffleMask) {\r
 420   unsigned NumElts = VT.getVectorNumElements();\r
 421   ShuffleMask.push_back(0);\r
 422   for (unsigned i = 1; i < NumElts; i++)\r
 423     ShuffleMask.push_back(SM_SentinelZero);\r
 424 }\r
 425 \r
 426 void DecodeScalarMoveMask(MVT VT, bool IsLoad, SmallVectorImpl<int> &Mask) {\r
 427   // First element comes from the first element of second source.\r
 428   // Remaining elements: Load zero extends / Move copies from first source.\r
 429   unsigned NumElts = VT.getVectorNumElements();\r
 430   Mask.push_back(NumElts);\r
 431   for (unsigned i = 1; i < NumElts; i++)\r
 432     Mask.push_back(IsLoad ? SM_SentinelZero : i);\r
 433 }\r
 434 } // llvm namespace\r