Fuse icmp/fcmp with select

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 30 matching lines @@
   enum InstKindX86 {
     k__Start = Inst::Target,
     Adc,
     AdcRMW,
     Add,
     AddRMW,
     Addps,
     Addss,
     Adjuststack,
     And,
+    Andnps,
+    Andps,
     AndRMW,
     Blendvps,
     Br,
     Bsf,
     Bsr,
     Bswap,
     Call,
     Cbwdq,
     Cmov,
     Cmpps,
     Cmpxchg,
     Cmpxchg8b,
     Cvt,
     Div,
     Divps,
     Divss,
     FakeRMW,
     Fld,
     Fstp,
     Icmp,
     Idiv,
     Imul,
     ImulImm,
     Insertps,
     Jmp,
     Label,
     Lea,
     Load,
     Mfence,
+    Minss,
+    Maxss,
     Mov,
     Movd,
     Movp,
     Movq,
     MovssRegs,
     Movsx,
     Movzx,
     Mul,
     Mulps,
     Mulss,
     Neg,
     Nop,
     Or,
+    Orps,
     OrRMW,
     Padd,
     Pand,
     Pandn,
     Pblendvb,
     Pcmpeq,
     Pcmpgt,
     Pextr,
     Pinsr,
     Pmull,
@@ skipping 25 matching lines @@
     Sub,
     SubRMW,
     Subps,
     Subss,
     Test,
     Ucomiss,
     UD2,
     Xadd,
     Xchg,
     Xor,
+    Xorps,
     XorRMW,
 
     /// Intel Architecture Code Analyzer markers. These are not executable so
     /// must only be used for analysis.
     IacaStart,
     IacaEnd
   };
 
   static const char *getWidthString(Type Ty);
   static const char *getFldString(Type Ty);
@@ skipping 1304 matching lines @@
     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:
+  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) {}
+};
+
+template <class Machine>
+class InstX86Andps
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Andps, true> {
+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) {}
+};
+
+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);
   }
@@ skipping 29 matching lines @@
         InstX86Pandn(Func, Dest, Source);
   }
 
 private:
   InstX86Pandn(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pandn, false>(
             Func, Dest, Source) {}
 };
 
 template <class Machine>
+class InstX86Maxss
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Maxss, true> {
+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) {}
+};
+
+template <class Machine>
+class InstX86Minss
+    : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Minss, true> {
+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) {}
+};
+
+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:
+  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) {}
+};
+
+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);
   }
@@ skipping 28 matching lines @@
     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:
+  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) {}
+};
+
+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);
   }
@@ skipping 1198 matching lines @@
   using Sqrtss = InstX86Sqrtss<Machine>;
   using Mov = InstX86Mov<Machine>;
   using Movp = InstX86Movp<Machine>;
   using Movq = InstX86Movq<Machine>;
   using Add = InstX86Add<Machine>;
   using AddRMW = InstX86AddRMW<Machine>;
   using Addps = InstX86Addps<Machine>;
   using Adc = InstX86Adc<Machine>;
   using AdcRMW = InstX86AdcRMW<Machine>;
   using Addss = InstX86Addss<Machine>;
+  using Andnps = InstX86Andnps<Machine>;
+  using Andps = InstX86Andps<Machine>;
   using Padd = InstX86Padd<Machine>;
   using Sub = InstX86Sub<Machine>;
   using SubRMW = InstX86SubRMW<Machine>;
   using Subps = InstX86Subps<Machine>;
   using Subss = InstX86Subss<Machine>;
   using Sbb = InstX86Sbb<Machine>;
   using SbbRMW = InstX86SbbRMW<Machine>;
   using Psub = InstX86Psub<Machine>;
   using And = InstX86And<Machine>;
   using AndRMW = InstX86AndRMW<Machine>;
   using Pand = InstX86Pand<Machine>;
   using Pandn = InstX86Pandn<Machine>;
   using Or = InstX86Or<Machine>;
+  using Orps = InstX86Orps<Machine>;
   using OrRMW = InstX86OrRMW<Machine>;
   using Por = InstX86Por<Machine>;
   using Xor = InstX86Xor<Machine>;
+  using Xorps = InstX86Xorps<Machine>;
   using XorRMW = InstX86XorRMW<Machine>;
   using Pxor = InstX86Pxor<Machine>;
+  using Maxss = InstX86Maxss<Machine>;
+  using Minss = InstX86Minss<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>;
@@ skipping 70 matching lines @@
   template <> const char *InstX86Mov<Machine>::Base::Opcode = "mov";           \
   template <> const char *InstX86Movp<Machine>::Base::Opcode = "movups";       \
   template <> const char *InstX86Movq<Machine>::Base::Opcode = "movq";         \
   /* Binary ops */                                                             \
   template <> const char *InstX86Add<Machine>::Base::Opcode = "add";           \
   template <> const char *InstX86AddRMW<Machine>::Base::Opcode = "add";        \
   template <> const char *InstX86Addps<Machine>::Base::Opcode = "addps";       \
   template <> const char *InstX86Adc<Machine>::Base::Opcode = "adc";           \
   template <> const char *InstX86AdcRMW<Machine>::Base::Opcode = "adc";        \
   template <> const char *InstX86Addss<Machine>::Base::Opcode = "addss";       \
+  template <> const char *InstX86Andnps<Machine>::Base::Opcode = "andn";       \
+  template <> const char *InstX86Andps<Machine>::Base::Opcode = "and";         \
+  template <> const char *InstX86Maxss<Machine>::Base::Opcode = "max";         \
+  template <> const char *InstX86Minss<Machine>::Base::Opcode = "min";         \
   template <> const char *InstX86Padd<Machine>::Base::Opcode = "padd";         \
   template <> const char *InstX86Sub<Machine>::Base::Opcode = "sub";           \
   template <> const char *InstX86SubRMW<Machine>::Base::Opcode = "sub";        \
   template <> const char *InstX86Subps<Machine>::Base::Opcode = "subps";       \
   template <> const char *InstX86Subss<Machine>::Base::Opcode = "subss";       \
   template <> const char *InstX86Sbb<Machine>::Base::Opcode = "sbb";           \
   template <> const char *InstX86SbbRMW<Machine>::Base::Opcode = "sbb";        \
   template <> const char *InstX86Psub<Machine>::Base::Opcode = "psub";         \
   template <> const char *InstX86And<Machine>::Base::Opcode = "and";           \
   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 *InstX86Orps<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 *InstX86Xorps<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 *InstX86Divss<Machine>::Base::Opcode = "divss";       \
   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";           \
   template <> const char *InstX86Psll<Machine>::Base::Opcode = "psll";         \
   template <> const char *InstX86Shr<Machine>::Base::Opcode = "shr";           \
   template <> const char *InstX86Sar<Machine>::Base::Opcode = "sar";           \
   template <> const char *InstX86Psra<Machine>::Base::Opcode = "psra";         \
   template <> const char *InstX86Psrl<Machine>::Base::Opcode = "psrl";         \
   template <> const char *InstX86Pcmpeq<Machine>::Base::Opcode = "pcmpeq";     \
   template <> const char *InstX86Pcmpgt<Machine>::Base::Opcode = "pcmpgt";     \
   template <> const char *InstX86MovssRegs<Machine>::Base::Opcode = "movss";   \
@@ skipping 250 matching lines @@
   template <>                                                                  \
   const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
       InstX86Subss<Machine>::Base::Emitter = {                                 \
           &InstX86Base<Machine>::Traits::Assembler::subss,                     \
           &InstX86Base<Machine>::Traits::Assembler::subss};                    \
   template <>                                                                  \
   const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
       InstX86Subps<Machine>::Base::Emitter = {                                 \
           &InstX86Base<Machine>::Traits::Assembler::subps,                     \
           &InstX86Base<Machine>::Traits::Assembler::subps};                    \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Andnps<Machine>::Base::Emitter = {                                \
+          &InstX86Base<Machine>::Traits::Assembler::andnps,                    \
+          &InstX86Base<Machine>::Traits::Assembler::andnps};                   \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Andps<Machine>::Base::Emitter = {                                 \
+          &InstX86Base<Machine>::Traits::Assembler::andps,                     \
+          &InstX86Base<Machine>::Traits::Assembler::andps};                    \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Maxss<Machine>::Base::Emitter = {                                 \
+          &InstX86Base<Machine>::Traits::Assembler::maxss,                     \
+          &InstX86Base<Machine>::Traits::Assembler::maxss};                    \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Minss<Machine>::Base::Emitter = {                                 \
+          &InstX86Base<Machine>::Traits::Assembler::minss,                     \
+          &InstX86Base<Machine>::Traits::Assembler::minss};                    \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Orps<Machine>::Base::Emitter = {                                  \
+          &InstX86Base<Machine>::Traits::Assembler::orps,                      \
+          &InstX86Base<Machine>::Traits::Assembler::orps};                     \
+  template <>                                                                  \
+  const InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp               \
+      InstX86Xorps<Machine>::Base::Emitter = {                                 \
+          &InstX86Base<Machine>::Traits::Assembler::xorps,                     \
+          &InstX86Base<Machine>::Traits::Assembler::xorps};                    \
                                                                                \
   /* Binary XMM Shift ops */                                                   \
   template <>                                                                  \
   const InstX86Base<Machine>::Traits::Assembler::XmmEmitterShiftOp             \
       InstX86Psll<Machine>::Base::Emitter = {                                  \
           &InstX86Base<Machine>::Traits::Assembler::psll,                      \
           &InstX86Base<Machine>::Traits::Assembler::psll,                      \
           &InstX86Base<Machine>::Traits::Assembler::psll};                     \
   template <>                                                                  \
   const InstX86Base<Machine>::Traits::Assembler::XmmEmitterShiftOp             \
       InstX86Psra<Machine>::Base::Emitter = {                                  \
           &InstX86Base<Machine>::Traits::Assembler::psra,                      \
           &InstX86Base<Machine>::Traits::Assembler::psra,                      \
           &InstX86Base<Machine>::Traits::Assembler::psra};                     \
   template <>                                                                  \
   const InstX86Base<Machine>::Traits::Assembler::XmmEmitterShiftOp             \
       InstX86Psrl<Machine>::Base::Emitter = {                                  \
           &InstX86Base<Machine>::Traits::Assembler::psrl,                      \
           &InstX86Base<Machine>::Traits::Assembler::psrl,                      \
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H