Subzero: Add support for SSE4.1 instructions.

src/IceTargetLoweringX8632.h

 //===- subzero/src/IceTargetLoweringX8632.h - x86-32 lowering ---*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the TargetLoweringX8632 class, which
@@ skipping 53 matching lines @@
 
   enum Registers {
 #define X(val, init, name, name16, name8, scratch, preserved, stackptr,        \
           frameptr, isI8, isInt, isFP)                                         \
   val init,
     REGX8632_TABLE
 #undef X
         Reg_NUM
   };
 
+  enum X86InstructionSet {
+    // SSE2 is the PNaCl baseline instruction set.
+    SSE2,
+    SSE4_1
+  };
+
+  X86InstructionSet getInstructionSet() const { return InstructionSet; }
+
 protected:
   TargetX8632(Cfg *Func);
 
   virtual void postLower();
 
   virtual void lowerAlloca(const InstAlloca *Inst);
   virtual void lowerArithmetic(const InstArithmetic *Inst);
   virtual void lowerAssign(const InstAssign *Inst);
   virtual void lowerBr(const InstBr *Inst);
   virtual void lowerCall(const InstCall *Inst);
@@ skipping 91 matching lines @@
   }
   void _addps(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Addps::create(Func, Dest, Src0));
   }
   void _addss(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Addss::create(Func, Dest, Src0));
   }
   void _and(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632And::create(Func, Dest, Src0));
   }
+  void _blendvps(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Blendvps::create(Func, Dest, Src0, Src1));
+  }
   void _br(InstX8632::BrCond Condition, CfgNode *TargetTrue,
            CfgNode *TargetFalse) {
     Context.insert(
         InstX8632Br::create(Func, TargetTrue, TargetFalse, Condition));
   }
   void _br(CfgNode *Target) {
     Context.insert(InstX8632Br::create(Func, Target));
   }
   void _br(InstX8632::BrCond Condition, CfgNode *Target) {
     Context.insert(InstX8632Br::create(Func, Target, Condition));
@@ skipping 54 matching lines @@
   void _fld(Operand *Src0) { Context.insert(InstX8632Fld::create(Func, Src0)); }
   void _fstp(Variable *Dest) {
     Context.insert(InstX8632Fstp::create(Func, Dest));
   }
   void _idiv(Variable *Dest, Operand *Src0, Operand *Src1) {
     Context.insert(InstX8632Idiv::create(Func, Dest, Src0, Src1));
   }
   void _imul(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Imul::create(Func, Dest, Src0));
   }
+  void _insertps(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Insertps::create(Func, Dest, Src0, Src1));
+  }
   void _lea(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Lea::create(Func, Dest, Src0));
   }
   void _mfence() { Context.insert(InstX8632Mfence::create(Func)); }
   // If Dest=NULL is passed in, then a new variable is created, marked
   // as infinite register allocation weight, and returned through the
   // in/out Dest argument.
   void _mov(Variable *&Dest, Operand *Src0,
             int32_t RegNum = Variable::NoRegister) {
     if (Dest == NULL) {
@@ skipping 37 matching lines @@
   }
   void _padd(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Padd::create(Func, Dest, Src0));
   }
   void _pand(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pand::create(Func, Dest, Src0));
   }
   void _pandn(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pandn::create(Func, Dest, Src0));
   }
+  void _pblendvb(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Pblendvb::create(Func, Dest, Src0, Src1));
+  }
   void _pcmpeq(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pcmpeq::create(Func, Dest, Src0));
   }
   void _pcmpgt(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pcmpgt::create(Func, Dest, Src0));
   }
-  void _pextrw(Variable *Dest, Operand *Src0, Operand *Src1) {
-    Context.insert(InstX8632Pextrw::create(Func, Dest, Src0, Src1));
+  void _pextr(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Pextr::create(Func, Dest, Src0, Src1));
   }
-  void _pinsrw(Variable *Dest, Operand *Src0, Operand *Src1) {
-    Context.insert(InstX8632Pinsrw::create(Func, Dest, Src0, Src1));
+  void _pinsr(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Pinsr::create(Func, Dest, Src0, Src1));
   }
-  void _pmullw(Variable *Dest, Operand *Src0) {
-    Context.insert(InstX8632Pmullw::create(Func, Dest, Src0));
+  void _pmull(Variable *Dest, Operand *Src0) {
+    Context.insert(InstX8632Pmull::create(Func, Dest, Src0));
   }
   void _pmuludq(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pmuludq::create(Func, Dest, Src0));
   }
   void _pop(Variable *Dest) {
     Context.insert(InstX8632Pop::create(Func, Dest));
   }
   void _por(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Por::create(Func, Dest, Src0));
   }
@@ skipping 77 matching lines @@
   void _xchg(Operand *Dest, Variable *Src) {
     Context.insert(InstX8632Xchg::create(Func, Dest, Src));
     // The xchg modifies Dest and Src -- model that update with a FakeDef.
     Context.insert(
         InstFakeDef::create(Func, Src, llvm::dyn_cast<Variable>(Dest)));
   }
   void _xor(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Xor::create(Func, Dest, Src0));
   }
 
+  X86InstructionSet InstructionSet;

[Jim Stichnoth, 2014/07/29 23:01:17]

Make this const?

[wala, 2014/07/30 00:11:24]

Done.

   bool IsEbpBasedFrame;
   size_t FrameSizeLocals;
   size_t LocalsSizeBytes;
   llvm::SmallBitVector TypeToRegisterSet[IceType_NUM];
   llvm::SmallBitVector ScratchRegs;
   llvm::SmallBitVector RegsUsed;
   SizeT NextLabelNumber;
   bool ComputedLiveRanges;
   VarList PhysicalRegisters;
   static IceString RegNames[];
@@ skipping 24 matching lines @@
   virtual ~TargetGlobalInitX8632() {}
 };
 
 template <> void ConstantInteger::emit(GlobalContext *Ctx) const;
 template <> void ConstantFloat::emit(GlobalContext *Ctx) const;
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX8632_H