Use three-address form of imul

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 50 matching lines @@
     Cvt,
     Div,
     Divps,
     Divss,
     FakeRMW,
     Fld,
     Fstp,
     Icmp,
     Idiv,
     Imul,
+    ImulImm,
     Insertps,
     Jmp,
     Label,
     Lea,
     Load,
     Mfence,
     Mov,
     Movd,
     Movp,
     Movq,
@@ skipping 1534 matching lines @@
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
 
 private:
   InstX86Imul(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopGPR<Machine, InstX86Base<Machine>::Imul>(Func, Dest,
                                                                  Source) {}
 };
 
 template <class Machine>
+class InstX86ImulImm
+    : public InstX86BaseThreeAddressop<Machine, InstX86Base<Machine>::ImulImm> {
+public:
+  static InstX86ImulImm *create(Cfg *Func, Variable *Dest, Operand *Source0,
+                                Operand *Source1) {
+    return new (Func->allocate<InstX86ImulImm>())
+        InstX86ImulImm(Func, Dest, Source0, Source1);
+  }
+
+  void emit(const Cfg *Func) const override;
+  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:
   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)
@@ skipping 1148 matching lines @@
   using AndRMW = InstX86AndRMW<Machine>;
   using Pand = InstX86Pand<Machine>;
   using Pandn = InstX86Pandn<Machine>;
   using Or = InstX86Or<Machine>;
   using OrRMW = InstX86OrRMW<Machine>;
   using Por = InstX86Por<Machine>;
   using Xor = InstX86Xor<Machine>;
   using XorRMW = InstX86XorRMW<Machine>;
   using Pxor = InstX86Pxor<Machine>;
   using Imul = InstX86Imul<Machine>;
+  using ImulImm = InstX86ImulImm<Machine>;
   using Mulps = InstX86Mulps<Machine>;
   using Mulss = InstX86Mulss<Machine>;
   using Pmull = InstX86Pmull<Machine>;
   using Pmuludq = InstX86Pmuludq<Machine>;
   using Divps = InstX86Divps<Machine>;
   using Divss = InstX86Divss<Machine>;
   using Rol = InstX86Rol<Machine>;
   using Shl = InstX86Shl<Machine>;
   using Psll = InstX86Psll<Machine>;
   using Psrl = InstX86Psrl<Machine>;
@@ skipping 87 matching lines @@
   template <> const char *InstX86AndRMW<Machine>::Base::Opcode = "and";        \
   template <> const char *InstX86Pand<Machine>::Base::Opcode = "pand";         \
   template <> const char *InstX86Pandn<Machine>::Base::Opcode = "pandn";       \
   template <> const char *InstX86Or<Machine>::Base::Opcode = "or";             \
   template <> const char *InstX86OrRMW<Machine>::Base::Opcode = "or";          \
   template <> const char *InstX86Por<Machine>::Base::Opcode = "por";           \
   template <> const char *InstX86Xor<Machine>::Base::Opcode = "xor";           \
   template <> const char *InstX86XorRMW<Machine>::Base::Opcode = "xor";        \
   template <> const char *InstX86Pxor<Machine>::Base::Opcode = "pxor";         \
   template <> const char *InstX86Imul<Machine>::Base::Opcode = "imul";         \
+  template <> const char *InstX86ImulImm<Machine>::Base::Opcode = "imul";      \
   template <> const char *InstX86Mulps<Machine>::Base::Opcode = "mulps";       \
   template <> const char *InstX86Mulss<Machine>::Base::Opcode = "mulss";       \
   template <> const char *InstX86Pmull<Machine>::Base::Opcode = "pmull";       \
   template <> const char *InstX86Pmuludq<Machine>::Base::Opcode = "pmuludq";   \
   template <> const char *InstX86Div<Machine>::Base::Opcode = "div";           \
   template <> const char *InstX86Divps<Machine>::Base::Opcode = "divps";       \
   template <> const char *InstX86Idiv<Machine>::Base::Opcode = "idiv";         \
   template <> const char *InstX86Divss<Machine>::Base::Opcode = "divss";       \
   template <> const char *InstX86Rol<Machine>::Base::Opcode = "rol";           \
   template <> const char *InstX86Shl<Machine>::Base::Opcode = "shl";           \
@@ skipping 287 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H