Fuse icmp/fcmp with select

src/IceInstX86BaseImpl.h

 //===- subzero/src/IceInstX86BaseImpl.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 1087 matching lines @@
     return;
   char buf[30];
   snprintf(
       buf, llvm::array_lengthof(buf), "mul%s",
       InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
           .SdSsString);
   this->emitTwoAddress(buf, this, Func);
 }
 
 template <class Machine>
+void InstX86Andnps<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "andn%s",

[Jim Stichnoth, 2015/12/16 01:00:37]

Instead of:
  "andn%s",
Can you use:
  "%s%s", Opcode,

i.e. reduce the duplication of the "andn" string.

If that works, maybe all these emit() functions can be refactored and reduced by
a lot.

[sehr, 2015/12/16 01:34:04]

Done.

+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .PdPsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
+void InstX86Andps<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "and%s",
+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .PdPsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
+void InstX86Maxss<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "max%s",
+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .SdSsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
+void InstX86Minss<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "min%s",
+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .SdSsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
+void InstX86Orps<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "or%s",
+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .PdPsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
+void InstX86Xorps<Machine>::emit(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+
+  char buf[30];
+  snprintf(
+      buf, llvm::array_lengthof(buf), "xor%s",
+      InstX86Base<Machine>::Traits::TypeAttributes[this->getDest()->getType()]
+          .PdPsString);
+  this->emitTwoAddress(buf, this, Func);
+}
+
+template <class Machine>
 void InstX86Pmuludq<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   assert(this->getSrc(0)->getType() == IceType_v4i32 &&
          this->getSrc(1)->getType() == IceType_v4i32);
   this->emitTwoAddress(this->Opcode, this, Func);
 }
 
 template <class Machine>
 void InstX86Divss<Machine>::emit(const Cfg *Func) const {
@@ skipping 499 matching lines @@
   this->dumpSources(Func);
 }
 
 template <class Machine>
 void InstX86Cmpps<Machine>::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(this->getSrcSize() == 2);
   assert(Condition < InstX86Base<Machine>::Traits::Cond::Cmpps_Invalid);
+  Type DestTy = this->Dest->getType();
   Str << "\t";
   Str << "cmp"
       << InstX86Base<Machine>::Traits::InstCmppsAttributes[Condition].EmitString
-      << "ps"
+      << InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PdPsString
       << "\t";
   this->getSrc(1)->emit(Func);
   Str << ", ";
   this->getDest()->emit(Func);
 }
 
 template <class Machine>
 void InstX86Cmpps<Machine>::emitIAS(const Cfg *Func) const {
   typename InstX86Base<Machine>::Traits::Assembler *Asm =
       Func->getAssembler<typename InstX86Base<Machine>::Traits::Assembler>();
   assert(this->getSrcSize() == 2);
   assert(Condition < InstX86Base<Machine>::Traits::Cond::Cmpps_Invalid);
   // Assuming there isn't any load folding for cmpps, and vector constants are
   // not allowed in PNaCl.
   assert(llvm::isa<Variable>(this->getSrc(1)));
   auto *Target = InstX86Base<Machine>::getTarget(Func);
   const auto *SrcVar = llvm::cast<Variable>(this->getSrc(1));
   if (SrcVar->hasReg()) {
-    Asm->cmpps(InstX86Base<Machine>::Traits::getEncodedXmm(
+    Asm->cmpps(this->getDest()->getType(),
+               InstX86Base<Machine>::Traits::getEncodedXmm(
                    this->getDest()->getRegNum()),
                InstX86Base<Machine>::Traits::getEncodedXmm(SrcVar->getRegNum()),
                Condition);
   } else {
     typename InstX86Base<Machine>::Traits::Address SrcStackAddr =
         Target->stackVarToAsmOperand(SrcVar);
-    Asm->cmpps(InstX86Base<Machine>::Traits::getEncodedXmm(
+    Asm->cmpps(this->getDest()->getType(),
+               InstX86Base<Machine>::Traits::getEncodedXmm(
                    this->getDest()->getRegNum()),
                SrcStackAddr, Condition);
   }
 }
 
 template <class Machine>
 void InstX86Cmpps<Machine>::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
@@ skipping 1519 matching lines @@
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "IACA_END";
 }
 
 } // end of namespace X86Internal
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX86BASEIMPL_H