Subzero. X86. Lowers shufflevector using xmm instructions.

src/IceInstX86Base.h

 //===- subzero/src/IceInstX86Base.h - Generic x86 instructions -*- C++ -*--===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 125 matching lines @@
       Pblendvb,
       Pcmpeq,
       Pcmpgt,
       Pextr,
       Pinsr,
       Pmull,
       Pmuludq,
       Pop,
       Por,
       Pshufd,
+      Punpckl,
       Psll,
       Psra,
       Psrl,
       Psub,
       Push,
       Pxor,
       Ret,
       Rol,
       Sar,
       Sbb,
@@ skipping 20 matching lines @@
       Xor,
       Xorps,
       XorRMW,
 
       /// Intel Architecture Code Analyzer markers. These are not executable so
       /// must only be used for analysis.
       IacaStart,
       IacaEnd
     };
 
-    enum SseSuffix { None, Packed, Scalar, Integral };
+    enum SseSuffix { None, Packed, Unpack, Scalar, Integral };
 
     static const char *getWidthString(Type Ty);
     static const char *getFldString(Type Ty);
     static BrCond getOppositeCondition(BrCond Cond);
     void dump(const Cfg *Func) const override;
 
     // Shared emit routines for common forms of instructions.
     void emitTwoAddress(const Cfg *Func, const char *Opcode,
                         const char *Suffix = "") const;
 
@@ skipping 637 matching lines @@
       const Type DestTy = ArithmeticTypeOverride == IceType_void
                               ? this->getDest()->getType()
                               : ArithmeticTypeOverride;
       const char *SuffixString = "";
       switch (Suffix) {
       case InstX86Base::SseSuffix::None:
         break;
       case InstX86Base::SseSuffix::Packed:
         SuffixString = Traits::TypeAttributes[DestTy].PdPsString;
         break;
+      case InstX86Base::SseSuffix::Unpack:
+        SuffixString = Traits::TypeAttributes[DestTy].UnpackString;
+        break;
       case InstX86Base::SseSuffix::Scalar:
         SuffixString = Traits::TypeAttributes[DestTy].SdSsString;
         break;
       case InstX86Base::SseSuffix::Integral:
         SuffixString = Traits::TypeAttributes[DestTy].PackString;
         break;
       }
       this->emitTwoAddress(Func, Opcode, SuffixString);
     }
     void emitIAS(const Cfg *Func) const override {
@@ skipping 1978 matching lines @@
     void emit(const Cfg *Func) const override;
     void emitIAS(const Cfg *Func) const override;
     void dump(const Cfg *Func) const override;
     static bool classof(const Inst *Instr) {
       return InstX86Base::isClassof(Instr, InstX86Base::IacaEnd);
     }
 
   private:
     InstX86IacaEnd(Cfg *Func);
   };
+
+  class InstX86Punpckl
+      : public InstX86BaseBinopXmm<InstX86Base::Punpckl, false,
+                                   InstX86Base::SseSuffix::Unpack> {
+  public:
+    static InstX86Punpckl *create(Cfg *Func, Variable *Dest, Operand *Source) {
+      return new (Func->allocate<InstX86Punpckl>())
+          InstX86Punpckl(Func, Dest, Source);
+    }
+
+  private:
+    InstX86Punpckl(Cfg *Func, Variable *Dest, Operand *Source)
+        : InstX86BaseBinopXmm<InstX86Base::Punpckl, false,
+                              InstX86Base::SseSuffix::Unpack>(Func, Dest,
+                                                              Source) {}
+  };
+
 }; // struct InstImpl
 
 /// struct Insts is a template that can be used to instantiate all the X86
 /// instructions for a target with a simple
 ///
 /// using Insts = ::Ice::X86NAMESPACE::Insts<TraitsType>;
 template <typename TraitsType> struct Insts {
   using GetIP = typename InstImpl<TraitsType>::InstX86GetIP;
   using FakeRMW = typename InstImpl<TraitsType>::InstX86FakeRMW;
   using Label = typename InstImpl<TraitsType>::InstX86Label;
@@ skipping 101 matching lines @@
                               typename InstImpl<TraitsType>::InstX86Fstp>::type;
   using Pop = typename InstImpl<TraitsType>::InstX86Pop;
   using Push = typename InstImpl<TraitsType>::InstX86Push;
   using Ret = typename InstImpl<TraitsType>::InstX86Ret;
   using Setcc = typename InstImpl<TraitsType>::InstX86Setcc;
   using Xadd = typename InstImpl<TraitsType>::InstX86Xadd;
   using Xchg = typename InstImpl<TraitsType>::InstX86Xchg;
 
   using IacaStart = typename InstImpl<TraitsType>::InstX86IacaStart;
   using IacaEnd = typename InstImpl<TraitsType>::InstX86IacaEnd;
+
+  using Punpckl = typename InstImpl<TraitsType>::InstX86Punpckl;
 };
 
 /// X86 Instructions have static data (particularly, opcodes and instruction
 /// emitters). Each X86 target needs to define all of these, so this macro is
 /// provided so that, if something changes, then all X86 targets will be updated
 /// automatically.
 #define X86INSTS_DEFINE_STATIC_DATA(X86NAMESPACE, TraitsType)                  \
   namespace Ice {                                                              \
   namespace X86NAMESPACE {                                                     \
   /* In-place ops */                                                           \
@@ skipping 209 matching lines @@
   template <>                                                                  \
   const char *InstImpl<TraitsType>::InstX86Pblendvb::Base::Opcode =            \
       "pblendvb";                                                              \
   /* Three address ops */                                                      \
   template <>                                                                  \
   template <>                                                                  \
   const char *InstImpl<TraitsType>::InstX86Pextr::Base::Opcode = "pextr";      \
   template <>                                                                  \
   template <>                                                                  \
   const char *InstImpl<TraitsType>::InstX86Pshufd::Base::Opcode = "pshufd";    \
+  template <>                                                                  \
+  template <>                                                                  \
+  const char *InstImpl<TraitsType>::InstX86Punpckl::Base::Opcode = "punpckl";  \
   /* Inplace GPR ops */                                                        \
   template <>                                                                  \
   template <>                                                                  \
   const InstImpl<TraitsType>::Assembler::GPREmitterOneOp                       \
       InstImpl<TraitsType>::InstX86Bswap::Base::Emitter = {                    \
           &InstImpl<TraitsType>::Assembler::bswap,                             \
           nullptr /* only a reg form exists */                                 \
   };                                                                           \
   template <>                                                                  \
   template <>                                                                  \
@@ skipping 341 matching lines @@
           &InstImpl<TraitsType>::Assembler::psra,                              \
           &InstImpl<TraitsType>::Assembler::psra,                              \
           &InstImpl<TraitsType>::Assembler::psra};                             \
   template <>                                                                  \
   template <>                                                                  \
   const InstImpl<TraitsType>::Assembler::XmmEmitterShiftOp                     \
       InstImpl<TraitsType>::InstX86Psrl::Base::Emitter = {                     \
           &InstImpl<TraitsType>::Assembler::psrl,                              \
           &InstImpl<TraitsType>::Assembler::psrl,                              \
           &InstImpl<TraitsType>::Assembler::psrl};                             \
+  template <>                                                                  \
+  template <>                                                                  \
+  const InstImpl<TraitsType>::Assembler::XmmEmitterRegOp                       \
+      InstImpl<TraitsType>::InstX86Punpckl::Base::Emitter = {                  \
+          &InstImpl<TraitsType>::Assembler::punpckldq,                         \
+          &InstImpl<TraitsType>::Assembler::punpckldq};                        \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H