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