Add template parameter for suffix to BinopXmm

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 131 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 };
+
   static const char *getWidthString(Type Ty);
   static const char *getFldString(Type Ty);
   static typename Traits::Cond::BrCond
   getOppositeCondition(typename Traits::Cond::BrCond Cond);
   void dump(const Cfg *Func) const override;
 
   // Shared emit routines for common forms of instructions.
-  static void emitTwoAddress(const char *Opcode, const Inst *Inst,
-                             const Cfg *Func);
+  void emitTwoAddress(const Cfg *Func, const char *Opcode,
+                      const char *Suffix = nullptr) const;

[John, 2015/12/17 21:07:51]

optional: Suffix = "", then you can just

Str << Opcode << Suffix;

in the implementation.

[sehr, 2015/12/17 23:06:05]

Done.

 
   static void
   emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
                   const Operand *Src,
                   const typename Traits::Assembler::GPREmitterShiftOp &Emitter);
 
   static X86TargetLowering *getTarget(const Cfg *Func) {
     return static_cast<X86TargetLowering *>(Func->getTarget());
   }
 
@@ skipping 450 matching lines @@
   InstX86BaseBinopGPRShift(const InstX86BaseBinopGPRShift &) = delete;
   InstX86BaseBinopGPRShift &
   operator=(const InstX86BaseBinopGPRShift &) = delete;
 
 public:
   using Base = InstX86BaseBinopGPRShift<Machine, K>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
-    this->emitTwoAddress(Opcode, this, Func);
+    this->emitTwoAddress(Func, Opcode);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = this->getDest()->getType();
     assert(this->getSrcSize() == 2);
     this->emitIASGPRShift(Func, Ty, this->getDest(), this->getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
@@ skipping 22 matching lines @@
   InstX86BaseBinopGPR() = delete;
   InstX86BaseBinopGPR(const InstX86BaseBinopGPR &) = delete;
   InstX86BaseBinopGPR &operator=(const InstX86BaseBinopGPR &) = delete;
 
 public:
   using Base = InstX86BaseBinopGPR<Machine, K>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
-    this->emitTwoAddress(Opcode, this, Func);
+    this->emitTwoAddress(Func, Opcode);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = this->getDest()->getType();
     assert(this->getSrcSize() == 2);
     emitIASRegOpTyGPR<Machine>(Func, Ty, this->getDest(), this->getSrc(1),
                                Emitter);
   }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
@@ skipping 23 matching lines @@
   InstX86BaseBinopRMW() = delete;
   InstX86BaseBinopRMW(const InstX86BaseBinopRMW &) = delete;
   InstX86BaseBinopRMW &operator=(const InstX86BaseBinopRMW &) = delete;
 
 public:
   using Base = InstX86BaseBinopRMW<Machine, K>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
-    this->emitTwoAddress(Opcode, this, Func);
+    this->emitTwoAddress(Func, Opcode);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = this->getSrc(0)->getType();
     assert(this->getSrcSize() == 2);
     emitIASAsAddrOpTyGPR<Machine>(Func, Ty, this->getSrc(0), this->getSrc(1),
                                   Emitter);
   }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
@@ skipping 13 matching lines @@
     this->addSource(DestSrc0);
     this->addSource(Src1);
   }
 
   static const char *Opcode;
   static const typename InstX86Base<
       Machine>::Traits::Assembler::GPREmitterAddrOp Emitter;
 };
 
 template <class Machine, typename InstX86Base<Machine>::InstKindX86 K,
-          bool NeedsElementType>
+          bool NeedsElementType,
+          typename InstX86Base<Machine>::SseSuffix Suffix>
 class InstX86BaseBinopXmm : public InstX86Base<Machine> {
   InstX86BaseBinopXmm() = delete;
   InstX86BaseBinopXmm(const InstX86BaseBinopXmm &) = delete;
   InstX86BaseBinopXmm &operator=(const InstX86BaseBinopXmm &) = delete;
 
 public:
-  using Base = InstX86BaseBinopXmm<Machine, K, NeedsElementType>;
+  using Base = InstX86BaseBinopXmm<Machine, K, NeedsElementType, Suffix>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     this->validateVectorAddrMode();
-    this->emitTwoAddress(Opcode, this, Func);
+    switch (Suffix) {
+    case InstX86Base<Machine>::SseSuffix::None:
+      this->emitTwoAddress(Func, Opcode);
+      break;
+    case InstX86Base<Machine>::SseSuffix::Packed: {
+      const Type DestTy = this->getDest()->getType();
+      this->emitTwoAddress(
+          Func, this->Opcode,
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PdPsString);
+    } break;
+    case InstX86Base<Machine>::SseSuffix::Scalar: {
+      const Type DestTy = this->getDest()->getType();
+      this->emitTwoAddress(
+          Func, this->Opcode,
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].SdSsString);
+    } break;
+    case InstX86Base<Machine>::SseSuffix::Integral: {
+      const Type DestTy = this->getDest()->getType();
+      this->emitTwoAddress(
+          Func, this->Opcode,
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PackString);
+    } break;
+    }
   }
   void emitIAS(const Cfg *Func) const override {
     this->validateVectorAddrMode();
     Type Ty = this->getDest()->getType();
     if (NeedsElementType)
       Ty = typeElementType(Ty);
     assert(this->getSrcSize() == 2);
     emitIASRegOpTyXMM<Machine>(Func, Ty, this->getDest(), this->getSrc(1),
                                Emitter);
   }
@@ skipping 35 matching lines @@
   InstX86BaseBinopXmmShift &
   operator=(const InstX86BaseBinopXmmShift &) = delete;
 
 public:
   using Base = InstX86BaseBinopXmmShift<Machine, K, AllowAllTypes>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     this->validateVectorAddrMode();
-    this->emitTwoAddress(Opcode, this, Func);
+    // Shift operations are always integral, and hence always need a suffix.
+    const Type DestTy = this->getDest()->getType();
+    this->emitTwoAddress(
+        Func, this->Opcode,
+        InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PackString);
   }
   void emitIAS(const Cfg *Func) const override {
     this->validateVectorAddrMode();
     Type Ty = this->getDest()->getType();
     assert(AllowAllTypes || isVectorType(Ty));
     Type ElementTy = typeElementType(Ty);
     assert(this->getSrcSize() == 2);
     emitIASXmmShift<Machine>(Func, ElementTy, this->getDest(), this->getSrc(1),
                              Emitter);
   }
@@ skipping 415 matching lines @@
 private:
   InstX86AddRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::AddRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Addps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Addps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Addps>())
         InstX86Addps(Func, Dest, Source);
   }
 
 private:
   InstX86Addps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Adc
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Adc> {
 public:
   static InstX86Adc *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Adc>()) InstX86Adc(Func, Dest, Source);
   }
 
@@ skipping 18 matching lines @@
 private:
   InstX86AdcRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::AdcRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Addss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addss, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addss, false,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Addss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Addss>())
         InstX86Addss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Addss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addss, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Addss, false,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Padd
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Padd, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Padd, true,
+                                 InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Padd *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Padd>()) InstX86Padd(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Padd(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Padd, true>(
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Padd, true,
+                            InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Sub
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Sub> {
 public:
   static InstX86Sub *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Sub>()) InstX86Sub(Func, Dest, Source);
   }
@@ skipping 19 matching lines @@
 private:
   InstX86SubRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::SubRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Subps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Subps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Subps>())
         InstX86Subps(Func, Dest, Source);
   }
 
 private:
   InstX86Subps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Subss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subss, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subss, false,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Subss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Subss>())
         InstX86Subss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Subss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subss, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Subss, false,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Sbb
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Sbb> {
 public:
   static InstX86Sbb *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Sbb>()) InstX86Sbb(Func, Dest, Source);
   }
 
@@ skipping 18 matching lines @@
 private:
   InstX86SbbRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::SbbRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Psub
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Psub, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Psub, true,
+                                 InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Psub *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Psub>()) InstX86Psub(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Psub(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Psub, true>(
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Psub, true,
+                            InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86And
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::And> {
 public:
   static InstX86And *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86And>()) InstX86And(Func, Dest, Source);
   }
 
 private:
   InstX86And(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::And>(Func, Dest,
                                                                 Source) {}
 };
 
 template <class Machine>
 class InstX86Andnps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andnps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andnps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Andnps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Andnps>())
         InstX86Andnps(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Andnps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andnps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andnps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Andps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Andps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Andps>())
         InstX86Andps(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Andps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86AndRMW
     : public InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::AndRMW> {
 public:
   static InstX86AndRMW *
   create(Cfg *Func,
          typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
          Operand *Src1) {
     return new (Func->allocate<InstX86AndRMW>())
         InstX86AndRMW(Func, DestSrc0, Src1);
   }
 
 private:
   InstX86AndRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::AndRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Pand
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pand, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pand, false,
+                                 InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86Pand *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Pand>()) InstX86Pand(Func, Dest, Source);
   }
 
 private:
   InstX86Pand(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pand, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pand, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Pandn
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pandn, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pandn, false,
+                                 InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86Pandn *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Pandn>())
         InstX86Pandn(Func, Dest, Source);
   }
 
 private:
   InstX86Pandn(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pandn, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pandn, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Maxss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Maxss, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Maxss, true,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Maxss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Maxss>())
         InstX86Maxss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Maxss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Maxss, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Maxss, true,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Minss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Minss, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Minss, true,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Minss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Minss>())
         InstX86Minss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Minss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Minss, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Minss, true,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Or
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Or> {
 public:
   static InstX86Or *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Or>()) InstX86Or(Func, Dest, Source);
   }
 
 private:
   InstX86Or(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Or>(Func, Dest,
                                                                Source) {}
 };
 
 template <class Machine>
 class InstX86Orps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Orps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Orps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Orps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Orps>()) InstX86Orps(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Orps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Orps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Orps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86OrRMW
     : public InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::OrRMW> {
 public:
   static InstX86OrRMW *
   create(Cfg *Func,
          typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
          Operand *Src1) {
     return new (Func->allocate<InstX86OrRMW>())
         InstX86OrRMW(Func, DestSrc0, Src1);
   }
 
 private:
   InstX86OrRMW(Cfg *Func,
                typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::OrRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Por
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Por, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Por, false,
+                                 InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86Por *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Por>()) InstX86Por(Func, Dest, Source);
   }
 
 private:
   InstX86Por(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Por, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Por, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Xor
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Xor> {
 public:
   static InstX86Xor *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Xor>()) InstX86Xor(Func, Dest, Source);
   }
 
 private:
   InstX86Xor(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Xor>(Func, Dest,
                                                                 Source) {}
 };
 
 template <class Machine>
 class InstX86Xorps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Xorps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Xorps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Xorps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Xorps>())
         InstX86Xorps(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Xorps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Xorps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Xorps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86XorRMW
     : public InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::XorRMW> {
 public:
   static InstX86XorRMW *
   create(Cfg *Func,
          typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
          Operand *Src1) {
     return new (Func->allocate<InstX86XorRMW>())
         InstX86XorRMW(Func, DestSrc0, Src1);
   }
 
 private:
   InstX86XorRMW(Cfg *Func,
                 typename InstX86Base<Machine>::Traits::X86OperandMem *DestSrc0,
                 Operand *Src1)
       : InstX86BaseBinopRMW<Machine, InstX86Base<Machine>::XorRMW>(
             Func, DestSrc0, Src1) {}
 };
 
 template <class Machine>
 class InstX86Pxor
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pxor, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pxor, false,
+                                 InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86Pxor *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Pxor>()) InstX86Pxor(Func, Dest, Source);
   }
 
 private:
   InstX86Pxor(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pxor, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pxor, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Imul
     : public InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Imul> {
 public:
   static InstX86Imul *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Imul>()) InstX86Imul(Func, Dest, Source);
   }
 
@@ skipping 20 matching lines @@
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86ImulImm(Cfg *Func, Variable *Dest, Operand *Source0, Operand *Source1)
       : InstX86BaseThreeAddressop<Machine, InstX86Base<Machine>::ImulImm>(
             Func, Dest, Source0, Source1) {}
 };
 
 template <class Machine>
 class InstX86Mulps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Mulps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Mulps>())
         InstX86Mulps(Func, Dest, Source);
   }
 
 private:
   InstX86Mulps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Mulss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulss, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulss, false,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Mulss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Mulss>())
         InstX86Mulss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Mulss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulss, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Mulss, false,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Pmull
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmull, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmull, true,
+                                 InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Pmull *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    bool TypesAreValid =
+        Dest->getType() == IceType_v4i32 || Dest->getType() == IceType_v8i16;
+    auto *Target = InstX86Base<Machine>::getTarget(Func);
+    bool InstructionSetIsValid =
+        Dest->getType() == IceType_v8i16 ||
+        Target->getInstructionSet() >= InstX86Base<Machine>::Traits::SSE4_1;
+    (void)TypesAreValid;
+    (void)InstructionSetIsValid;
+    assert(TypesAreValid);
+    assert(InstructionSetIsValid);
     return new (Func->allocate<InstX86Pmull>())
         InstX86Pmull(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
-
 private:
   InstX86Pmull(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmull, true>(
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmull, true,
+                            InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Pmuludq
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmuludq,
-                                 false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmuludq, false,
+                                 InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86Pmuludq *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    assert(Dest->getType() == IceType_v4i32 &&
+           Source->getType() == IceType_v4i32);
     return new (Func->allocate<InstX86Pmuludq>())
         InstX86Pmuludq(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Pmuludq(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmuludq, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmuludq, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Divps
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divps, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divps, true,
+                                 InstX86Base<Machine>::SseSuffix::Packed> {
 public:
   static InstX86Divps *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Divps>())
         InstX86Divps(Func, Dest, Source);
   }
 
 private:
   InstX86Divps(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divps, true>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divps, true,
+                            InstX86Base<Machine>::SseSuffix::Packed>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Divss
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divss, false> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divss, false,
+                                 InstX86Base<Machine>::SseSuffix::Scalar> {
 public:
   static InstX86Divss *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Divss>())
         InstX86Divss(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Divss(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divss, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Divss, false,
+                            InstX86Base<Machine>::SseSuffix::Scalar>(Func, Dest,
+                                                                     Source) {}
 };
 
 template <class Machine>
 class InstX86Rol
     : public InstX86BaseBinopGPRShift<Machine, InstX86Base<Machine>::Rol> {
 public:
   static InstX86Rol *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Rol>()) InstX86Rol(Func, Dest, Source);
   }
 
@@ skipping 15 matching lines @@
   InstX86Shl(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPRShift<Machine, InstX86Base<Machine>::Shl>(Func, Dest,
                                                                      Source) {}
 };
 
 template <class Machine>
 class InstX86Psll
     : public InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psll> {
 public:
   static InstX86Psll *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    assert(Dest->getType() == IceType_v8i16 ||
+           Dest->getType() == IceType_v8i1 ||
+           Dest->getType() == IceType_v4i32 || Dest->getType() == IceType_v4i1);
     return new (Func->allocate<InstX86Psll>()) InstX86Psll(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Psll(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psll>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Psrl
     : public InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psrl,
                                       true> {
 public:
   static InstX86Psrl *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Psrl>()) InstX86Psrl(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Psrl(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psrl, true>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Shr
     : public InstX86BaseBinopGPRShift<Machine, InstX86Base<Machine>::Shr> {
 public:
@@ skipping 19 matching lines @@
   InstX86Sar(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPRShift<Machine, InstX86Base<Machine>::Sar>(Func, Dest,
                                                                      Source) {}
 };
 
 template <class Machine>
 class InstX86Psra
     : public InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psra> {
 public:
   static InstX86Psra *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    assert(Dest->getType() == IceType_v8i16 ||
+           Dest->getType() == IceType_v8i1 ||
+           Dest->getType() == IceType_v4i32 || Dest->getType() == IceType_v4i1);
     return new (Func->allocate<InstX86Psra>()) InstX86Psra(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Psra(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmmShift<Machine, InstX86Base<Machine>::Psra>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Pcmpeq
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true,
+                                 InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Pcmpeq *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Pcmpeq>())
         InstX86Pcmpeq(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Pcmpeq(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true>(
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true,
+                            InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
 class InstX86Pcmpgt
-    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true> {
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true,
+                                 InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Pcmpgt *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86Pcmpgt>())
         InstX86Pcmpgt(Func, Dest, Source);
   }
 
-  void emit(const Cfg *Func) const override;
-
 private:
   InstX86Pcmpgt(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true>(
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true,
+                            InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
 
 /// movss is only a binary operation when the source and dest operands are both
 /// registers (the high bits of dest are left untouched). In other cases, it
 /// behaves like a copy (mov-like) operation (and the high bits of dest are
 /// cleared). InstX86Movss will assert that both its source and dest operands
 /// are registers, so the lowering code should use _mov instead of _movss in
 /// cases where a copy operation is intended.
 template <class Machine>
 class InstX86MovssRegs
     : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::MovssRegs,
-                                 false> {
+                                 false, InstX86Base<Machine>::SseSuffix::None> {
 public:
   static InstX86MovssRegs *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX86MovssRegs>())
         InstX86MovssRegs(Func, Dest, Source);
   }
 
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86MovssRegs(Cfg *Func, Variable *Dest, Operand *Source)
-      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::MovssRegs, false>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::MovssRegs, false,
+                            InstX86Base<Machine>::SseSuffix::None>(Func, Dest,
+                                                                   Source) {}
 };
 
 template <class Machine>
 class InstX86Idiv
     : public InstX86BaseTernop<Machine, InstX86Base<Machine>::Idiv> {
 public:
   static InstX86Idiv *create(Cfg *Func, Variable *Dest, Operand *Source1,
                              Operand *Source2) {
     return new (Func->allocate<InstX86Idiv>())
         InstX86Idiv(Func, Dest, Source1, Source2);
@@ skipping 44 matching lines @@
       : InstX86BaseTernop<Machine, InstX86Base<Machine>::Insertps>(
             Func, Dest, Source1, Source2) {}
 };
 
 template <class Machine>
 class InstX86Pinsr
     : public InstX86BaseTernop<Machine, InstX86Base<Machine>::Pinsr> {
 public:
   static InstX86Pinsr *create(Cfg *Func, Variable *Dest, Operand *Source1,
                               Operand *Source2) {
+    // pinsrb and pinsrd are SSE4.1 instructions.
+    assert(Dest->getType() == IceType_v8i16 ||
+           Dest->getType() == IceType_v8i1 ||
+           InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+               InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Pinsr>())
         InstX86Pinsr(Func, Dest, Source1, Source2);
   }
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86Pinsr(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
       : InstX86BaseTernop<Machine, InstX86Base<Machine>::Pinsr>(
@@ skipping 17 matching lines @@
       : InstX86BaseTernop<Machine, InstX86Base<Machine>::Shufps>(
             Func, Dest, Source1, Source2) {}
 };
 
 template <class Machine>
 class InstX86Blendvps
     : public InstX86BaseTernop<Machine, InstX86Base<Machine>::Blendvps> {
 public:
   static InstX86Blendvps *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                  Operand *Source2) {
+    assert(InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+           InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Blendvps>())
         InstX86Blendvps(Func, Dest, Source1, Source2);
   }
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Fund) const override;
 
 private:
   InstX86Blendvps(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
       : InstX86BaseTernop<Machine, InstX86Base<Machine>::Blendvps>(
             Func, Dest, Source1, Source2) {}
 };
 
 template <class Machine>
 class InstX86Pblendvb
     : public InstX86BaseTernop<Machine, InstX86Base<Machine>::Pblendvb> {
 public:
   static InstX86Pblendvb *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                  Operand *Source2) {
+    assert(InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+           InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Pblendvb>())
         InstX86Pblendvb(Func, Dest, Source1, Source2);
   }
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86Pblendvb(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
       : InstX86BaseTernop<Machine, InstX86Base<Machine>::Pblendvb>(
             Func, Dest, Source1, Source2) {}
 };
 
 template <class Machine>
 class InstX86Pextr
     : public InstX86BaseThreeAddressop<Machine, InstX86Base<Machine>::Pextr> {
 public:
   static InstX86Pextr *create(Cfg *Func, Variable *Dest, Operand *Source0,
                               Operand *Source1) {
+    assert(Source0->getType() == IceType_v8i16 ||
+           Source0->getType() == IceType_v8i1 ||
+           InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+               InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Pextr>())
         InstX86Pextr(Func, Dest, Source0, Source1);
   }
 
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86Pextr(Cfg *Func, Variable *Dest, Operand *Source0, Operand *Source1)
       : InstX86BaseThreeAddressop<Machine, InstX86Base<Machine>::Pextr>(
@@ skipping 1206 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H