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 };
+
   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);
 
@@ skipping 580 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(Opcode, this, Func);
+      break;
+    case InstX86Base<Machine>::SseSuffix::Packed: {
+      char buf[30];

[John, 2015/12/17 14:06:36]

I know these routines don't make to the final binary, so this is totally
optional:

maybe refactor emitTwoAddress() to take the suffix as a second string argument.

while at it, refactor emitTwoAddress() so that it is no longer static (a static
method taking "this" as a parameters at every single call site is not really
static :))

If you want, I can send a patch with these changes.

[sehr, 2015/12/17 21:03:31]

Done.  And added another case for the Integral SSE instructions.

+      Type DestTy = this->getDest()->getType();
+      snprintf(buf, llvm::array_lengthof(buf), "%s%s", this->Opcode,
+               InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PdPsString);
+      this->emitTwoAddress(buf, this, Func);
+    } break;
+    case InstX86Base<Machine>::SseSuffix::Scalar: {
+      char buf[30];
+      Type DestTy = this->getDest()->getType();
+      snprintf(buf, llvm::array_lengthof(buf), "%s%s", this->Opcode,
+               InstX86Base<Machine>::Traits::TypeAttributes[DestTy].SdSsString);
+      this->emitTwoAddress(buf, this, Func);
+    } 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 471 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::None> {
 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>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Padd, true,
+                            InstX86Base<Machine>::SseSuffix::None>(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 18 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::None> {
 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>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Psub, true,
+                            InstX86Base<Machine>::SseSuffix::None>(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::None> {
 public:
   static InstX86Pmull *create(Cfg *Func, Variable *Dest, Operand *Source) {
     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>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pmull, true,
+                            InstX86Base<Machine>::SseSuffix::None>(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) {
     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 89 matching lines @@
   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::None> {
 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>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true,
+                            InstX86Base<Machine>::SseSuffix::None>(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::None> {
 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>(
-            Func, Dest, Source) {}
+      : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true,
+                            InstX86Base<Machine>::SseSuffix::None>(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 1345 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H