Add option to force filetype=asm for testing

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 746 matching lines @@
   InstX86BaseBinopXmm(const InstX86BaseBinopXmm &) = delete;
   InstX86BaseBinopXmm &operator=(const InstX86BaseBinopXmm &) = delete;
 
 public:
   using Base = InstX86BaseBinopXmm<Machine, K, NeedsElementType, Suffix>;
 
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     this->validateVectorAddrMode();
+    Type DestTy = this->getDest()->getType();
+    const char *SuffixString = "";
+    if (ArithmeticTypeOverride != IceType_void)
+      DestTy = ArithmeticTypeOverride;
+
     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;
+    case InstX86Base<Machine>::SseSuffix::Packed:
+      SuffixString =
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PdPsString;
+      break;
+    case InstX86Base<Machine>::SseSuffix::Scalar:
+      SuffixString =
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].SdSsString;
+      break;
+    case InstX86Base<Machine>::SseSuffix::Integral:
+      SuffixString =
+          InstX86Base<Machine>::Traits::TypeAttributes[DestTy].PackString;
+      break;
     }
+    this->emitTwoAddress(Func, Opcode, SuffixString);
   }
   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);
   }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     this->dumpDest(Func);
     Str << " = " << Opcode << "." << this->getDest()->getType() << " ";
     this->dumpSources(Func);
   }
   static bool classof(const Inst *Inst) {
     return InstX86Base<Machine>::isClassof(Inst, InstX86Base<Machine>::K);
   }
 
 protected:
-  InstX86BaseBinopXmm(Cfg *Func, Variable *Dest, Operand *Source)
+  InstX86BaseBinopXmm(Cfg *Func, Variable *Dest, Operand *Source,
+                      Type ArithmeticType = IceType_void)
       : InstX86Base<Machine>(Func, K, 2, Dest) {
     this->addSource(Dest);
     this->addSource(Source);
+    ArithmeticTypeOverride = ArithmeticType;

[Jim Stichnoth, 2015/12/20 18:42:23]

Can this assignment be moved into the ctor member initializer list?

If so, I would rename the parameter to ArithmeticTypeOverride, and declare the
field as const.

[sehr, 2016/01/07 18:53:11]

Done.

   }
 
+  Type ArithmeticTypeOverride;
   static const char *Opcode;
   static const typename InstX86Base<Machine>::Traits::Assembler::XmmEmitterRegOp
       Emitter;
 };
 
 template <class Machine>
 void emitIASXmmShift(
     const Cfg *Func, Type Ty, const Variable *Var, const Operand *Src,
     const typename InstX86Base<Machine>::Traits::Assembler::XmmEmitterShiftOp
         &Emitter);
@@ skipping 1174 matching lines @@
   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,
                                  InstX86Base<Machine>::SseSuffix::Integral> {
 public:
-  static InstX86Pcmpeq *create(Cfg *Func, Variable *Dest, Operand *Source) {
+  static InstX86Pcmpeq *create(Cfg *Func, Variable *Dest, Operand *Source,
+                               Type ArithmeticTypeOverride = IceType_void) {
+    Type Ty = Dest->getType();
+    if (ArithmeticTypeOverride != IceType_void)
+      Ty = ArithmeticTypeOverride;
+    (void)Ty;
+    assert((Ty != IceType_f64 && Ty != IceType_i64) ||
+           InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+               InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Pcmpeq>())
-        InstX86Pcmpeq(Func, Dest, Source);
+        InstX86Pcmpeq(Func, Dest, Source, ArithmeticTypeOverride);
   }
 
 private:
-  InstX86Pcmpeq(Cfg *Func, Variable *Dest, Operand *Source)
+  InstX86Pcmpeq(Cfg *Func, Variable *Dest, Operand *Source,
+                Type ArithmeticTypeOverride)
       : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpeq, true,
                             InstX86Base<Machine>::SseSuffix::Integral>(
-            Func, Dest, Source) {}
+            Func, Dest, Source, ArithmeticTypeOverride) {}
 };
 
 template <class Machine>
 class InstX86Pcmpgt
     : public InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true,
                                  InstX86Base<Machine>::SseSuffix::Integral> {
 public:
   static InstX86Pcmpgt *create(Cfg *Func, Variable *Dest, Operand *Source) {
+    assert(Dest->getType() != IceType_f64 ||
+           InstX86Base<Machine>::getTarget(Func)->getInstructionSet() >=
+               InstX86Base<Machine>::Traits::SSE4_1);
     return new (Func->allocate<InstX86Pcmpgt>())
         InstX86Pcmpgt(Func, Dest, Source);
   }
 
 private:
   InstX86Pcmpgt(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX86BaseBinopXmm<Machine, InstX86Base<Machine>::Pcmpgt, true,
                             InstX86Base<Machine>::SseSuffix::Integral>(
             Func, Dest, Source) {}
 };
@@ skipping 1392 matching lines @@
           &InstX86Base<Machine>::Traits::Assembler::psrl};                     \
   }                                                                            \
   }
 
 } // end of namespace X86Internal
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H