Lower insertelement and extractelement.

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 64 matching lines @@
   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);
   virtual void lowerCast(const InstCast *Inst);
+  virtual void lowerExtractElement(const InstExtractElement *Inst);
   virtual void lowerFcmp(const InstFcmp *Inst);
   virtual void lowerIcmp(const InstIcmp *Inst);
   virtual void lowerIntrinsicCall(const InstIntrinsicCall *Inst);
+  virtual void lowerInsertElement(const InstInsertElement *Inst);
   virtual void lowerLoad(const InstLoad *Inst);
   virtual void lowerPhi(const InstPhi *Inst);
   virtual void lowerRet(const InstRet *Inst);
   virtual void lowerSelect(const InstSelect *Inst);
   virtual void lowerStore(const InstStore *Inst);
   virtual void lowerSwitch(const InstSwitch *Inst);
   virtual void lowerUnreachable(const InstUnreachable *Inst);
   virtual void doAddressOptLoad();
   virtual void doAddressOptStore();
 
@@ skipping 47 matching lines @@
     return Call;
   }
   static Type stackSlotType();
 
   Variable *copyToReg(Operand *Src, int32_t RegNum = Variable::NoRegister);
 
   // Returns a vector in a register with the given constant entries.
   Variable *makeVectorOfZeros(Type Ty, int32_t RegNum = Variable::NoRegister);
   Variable *makeVectorOfOnes(Type Ty, int32_t RegNum = Variable::NoRegister);
 
+  // Return a memory operand corresponding to a stack allocated Variable.
+  OperandX8632Mem *getMemoryOperandForStackSlot(Type Ty, Variable *Slot,
+                                                uint32_t Offset = 0);
+
   // The following are helpers that insert lowered x86 instructions
   // with minimal syntactic overhead, so that the lowering code can
   // look as close to assembly as practical.
   void _adc(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Adc::create(Func, Dest, Src0));
   }
   void _add(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Add::create(Func, Dest, Src0));
   }
   void _addps(Variable *Dest, Operand *Src0) {
@@ skipping 65 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 _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) {
       Dest = legalizeToVar(Src0, false, RegNum);
     } else {
       Context.insert(InstX8632Mov::create(Func, Dest, Src0));
     }
   }
+  void _movd(Variable *Dest, Operand *Src0) {
+    Context.insert(InstX8632Movd::create(Func, Dest, Src0));
+  }
   void _movp(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Movp::create(Func, Dest, Src0));
   }
   void _movq(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Movq::create(Func, Dest, Src0));
   }
+  void _movss(Variable *Dest, Operand *Src0) {
+    Context.insert(InstX8632Movss::create(Func, Dest, Src0));
+  }
   void _movsx(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Movsx::create(Func, Dest, Src0));
   }
   void _movzx(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Movzx::create(Func, Dest, Src0));
   }
   void _mul(Variable *Dest, Variable *Src0, Operand *Src1) {
     Context.insert(InstX8632Mul::create(Func, Dest, Src0, Src1));
   }
   void _mulps(Variable *Dest, Operand *Src0) {
@@ skipping 13 matching lines @@
   }
   void _pand(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pand::create(Func, Dest, Src0));
   }
   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 _pinsrw(Variable *Dest, Operand *Src0, Operand *Src1) {
+    Context.insert(InstX8632Pinsrw::create(Func, Dest, Src0, Src1));
+  }
   void _pmullw(Variable *Dest, Operand *Src0) {
     Context.insert(InstX8632Pmullw::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) {
@@ skipping 120 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