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 805 matching lines @@
     InstX86BaseBinopXmm(const InstX86BaseBinopXmm &) = delete;
     InstX86BaseBinopXmm &operator=(const InstX86BaseBinopXmm &) = delete;
 
   public:
     using Base = InstX86BaseBinopXmm<K, NeedsElementType, Suffix>;
 
     void emit(const Cfg *Func) const override {
       if (!BuildDefs::dump())
         return;
       this->validateVectorAddrMode();
+      Type DestTy = this->getDest()->getType();

[Jim Stichnoth, 2016/01/10 03:08:55]

How about this:

  const Type DestTy = ArithmeticTypeOverride == IceType_void ?
this->getDest()->getType() : ArithmeticTypeOverride;

[sehr, 2016/01/11 21:49:47]

Done.

+      const char *SuffixString = "";
+      if (ArithmeticTypeOverride != IceType_void)
+        DestTy = ArithmeticTypeOverride;
+
       switch (Suffix) {
       case InstX86Base::SseSuffix::None:
-        this->emitTwoAddress(Func, Opcode);
         break;
-      case InstX86Base::SseSuffix::Packed: {
-        const Type DestTy = this->getDest()->getType();
-        this->emitTwoAddress(Func, this->Opcode,
-                             Traits::TypeAttributes[DestTy].PdPsString);
-      } break;
-      case InstX86Base::SseSuffix::Scalar: {
-        const Type DestTy = this->getDest()->getType();
-        this->emitTwoAddress(Func, this->Opcode,
-                             Traits::TypeAttributes[DestTy].SdSsString);
-      } break;
-      case InstX86Base::SseSuffix::Integral: {
-        const Type DestTy = this->getDest()->getType();
-        this->emitTwoAddress(Func, this->Opcode,
-                             Traits::TypeAttributes[DestTy].PackString);
-      } break;
+      case InstX86Base::SseSuffix::Packed:
+        SuffixString = Traits::TypeAttributes[DestTy].PdPsString;
+        break;
+      case InstX86Base::SseSuffix::Scalar:
+        SuffixString = Traits::TypeAttributes[DestTy].SdSsString;
+        break;
+      case InstX86Base::SseSuffix::Integral:
+        SuffixString = 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(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::isClassof(Inst, InstX86Base::K);
     }
 
   protected:
-    InstX86BaseBinopXmm(Cfg *Func, Variable *Dest, Operand *Source)
-        : InstX86Base(Func, K, 2, Dest) {
+    InstX86BaseBinopXmm(Cfg *Func, Variable *Dest, Operand *Source,
+                        Type ArithmeticTypeOverride = IceType_void)
+        : InstX86Base(Func, K, 2, Dest),
+          ArithmeticTypeOverride(ArithmeticTypeOverride) {
       this->addSource(Dest);
       this->addSource(Source);
     }
 
+    const Type ArithmeticTypeOverride;
     static const char *Opcode;
     static const XmmEmitterRegOp Emitter;
   };
 
   template <typename InstX86Base::InstKindX86 K, bool AllowAllTypes = false>
   class InstX86BaseBinopXmmShift : public InstX86Base {
     InstX86BaseBinopXmmShift() = delete;
     InstX86BaseBinopXmmShift(const InstX86BaseBinopXmmShift &) = delete;
     InstX86BaseBinopXmmShift &
     operator=(const InstX86BaseBinopXmmShift &) = delete;
@@ skipping 1023 matching lines @@
 
   private:
     InstX86Psra(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86BaseBinopXmmShift<InstX86Base::Psra>(Func, Dest, Source) {}
   };
 
   class InstX86Pcmpeq
       : public InstX86BaseBinopXmm<InstX86Base::Pcmpeq, true,
                                    InstX86Base::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();

[Jim Stichnoth, 2016/01/10 03:08:55]

Same "const Type Ty = ..." comment as above.

[sehr, 2016/01/11 21:49:47]

Done.

+      if (ArithmeticTypeOverride != IceType_void)
+        Ty = ArithmeticTypeOverride;
+      (void)Ty;
+      assert((Ty != IceType_f64 && Ty != IceType_i64) ||
+             InstX86Base::getTarget(Func)->getInstructionSet() >=
+                 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<InstX86Base::Pcmpeq, true,
-                              InstX86Base::SseSuffix::Integral>(Func, Dest,
-                                                                Source) {}
+                              InstX86Base::SseSuffix::Integral>(
+              Func, Dest, Source, ArithmeticTypeOverride) {}
   };
 
   class InstX86Pcmpgt
       : public InstX86BaseBinopXmm<InstX86Base::Pcmpgt, true,
                                    InstX86Base::SseSuffix::Integral> {
   public:
     static InstX86Pcmpgt *create(Cfg *Func, Variable *Dest, Operand *Source) {
+      assert(Dest->getType() != IceType_f64 ||
+             InstX86Base::getTarget(Func)->getInstructionSet() >=
+                 Traits::SSE4_1);
       return new (Func->allocate<InstX86Pcmpgt>())
           InstX86Pcmpgt(Func, Dest, Source);
     }
 
   private:
     InstX86Pcmpgt(Cfg *Func, Variable *Dest, Operand *Source)
         : InstX86BaseBinopXmm<InstX86Base::Pcmpgt, true,
                               InstX86Base::SseSuffix::Integral>(Func, Dest,
                                                                 Source) {}
   };
@@ skipping 1553 matching lines @@
           &InstImpl<TraitsType>::Assembler::psrl};                             \
   }                                                                            \
   }
 
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #include "IceInstX86BaseImpl.h"
 
 #endif // SUBZERO_SRC_ICEINSTX86BASE_H