Lower insertelement and extractelement.

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- 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 InstX8632 and OperandX8632 classes and
@@ skipping 138 matching lines @@
     Cvt,
     Div,
     Divps,
     Divss,
     Fld,
     Fstp,
     Icmp,
     Idiv,
     Imul,
     Label,
+    Lea,
     Load,
     Mfence,
     Mov,
+    Movd,
     Movp,
     Movq,
+    Movss,
     Movsx,
     Movzx,
     Mul,
     Mulps,
     Mulss,
     Neg,
     Or,
     Padd,
     Pand,
     Pcmpeq,
     Pcmpgt,
+    Pextrw,
+    Pinsrw,
     Pmullw,
     Pmuludq,
     Pop,
     Por,
     Pshufd,
     Psll,
     Psra,
     Psub,
     Push,
     Pxor,
@@ skipping 238 matching lines @@
   // Create a ternary-op instruction like div or idiv.
   static InstX8632Ternop *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                  Operand *Source2) {
     return new (Func->allocate<InstX8632Ternop>())
         InstX8632Ternop(Func, Dest, Source1, Source2);
   }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 3);
     Str << "\t" << Opcode << "\t";
+    getDest()->emit(Func);
+    Str << ", ";
     getSrc(1)->emit(Func);
+    Str << ", ";
+    getSrc(2)->emit(Func);
     Str << "\n";
   }
   virtual void dump(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632Ternop(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
       : InstX8632(Func, K, 3, Dest) {
     addSource(Dest);
     addSource(Source1);
     addSource(Source2);
   }
   InstX8632Ternop(const InstX8632Ternop &) LLVM_DELETED_FUNCTION;
   InstX8632Ternop &operator=(const InstX8632Ternop &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Ternop() {}
   static const char *Opcode;
 };
 
+// Instructions of the form x := y op z
+template <InstX8632::InstKindX8632 K>
+class InstX8632ThreeAddressop : public InstX8632 {
+public:
+  static InstX8632ThreeAddressop *create(Cfg *Func, Variable *Dest,
+                                         Operand *Source0, Operand *Source1) {
+    return new (Func->allocate<InstX8632ThreeAddressop>())
+        InstX8632ThreeAddressop(Func, Dest, Source0, Source1);
+  }
+  virtual void emit(const Cfg *Func) const {
+    Ostream &Str = Func->getContext()->getStrEmit();
+    assert(getSrcSize() == 2);
+    Str << "\t" << Opcode << "\t";
+    getDest()->emit(Func);
+    Str << ", ";
+    getSrc(0)->emit(Func);
+    Str << ", ";
+    getSrc(1)->emit(Func);
+    Str << "\n";
+  }
+  virtual void dump(const Cfg *Func) const {
+    Ostream &Str = Func->getContext()->getStrDump();
+    dumpDest(Func);
+    Str << " = " << Opcode << "." << getDest()->getType() << " ";
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstX8632ThreeAddressop(Cfg *Func, Variable *Dest, Operand *Source0,
+                          Operand *Source1)
+      : InstX8632(Func, K, 2, Dest) {
+    addSource(Source0);
+    addSource(Source1);
+  }
+  InstX8632ThreeAddressop(const InstX8632ThreeAddressop &)
+      LLVM_DELETED_FUNCTION;
+  InstX8632ThreeAddressop &
+  operator=(const InstX8632ThreeAddressop &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632ThreeAddressop() {}
+  static const char *Opcode;
+};
+
 typedef InstX8632Unaryop<InstX8632::Bsf> InstX8632Bsf;
 typedef InstX8632Unaryop<InstX8632::Bsr> InstX8632Bsr;
+typedef InstX8632Unaryop<InstX8632::Lea> InstX8632Lea;
+typedef InstX8632Unaryop<InstX8632::Movd> InstX8632Movd;
+typedef InstX8632Unaryop<InstX8632::Movss> InstX8632Movss;
 typedef InstX8632Unaryop<InstX8632::Sqrtss> InstX8632Sqrtss;
 typedef InstX8632Binop<InstX8632::Add> InstX8632Add;
 typedef InstX8632Binop<InstX8632::Addps> InstX8632Addps;
 typedef InstX8632Binop<InstX8632::Adc> InstX8632Adc;
 typedef InstX8632Binop<InstX8632::Addss> InstX8632Addss;
 typedef InstX8632Binop<InstX8632::Padd> InstX8632Padd;
 typedef InstX8632Binop<InstX8632::Sub> InstX8632Sub;
 typedef InstX8632Binop<InstX8632::Subps> InstX8632Subps;
 typedef InstX8632Binop<InstX8632::Subss> InstX8632Subss;
 typedef InstX8632Binop<InstX8632::Sbb> InstX8632Sbb;
@@ skipping 13 matching lines @@
 typedef InstX8632Binop<InstX8632::Divss> InstX8632Divss;
 typedef InstX8632Binop<InstX8632::Shl, true> InstX8632Shl;
 typedef InstX8632Binop<InstX8632::Psll> InstX8632Psll;
 typedef InstX8632Binop<InstX8632::Shr, true> InstX8632Shr;
 typedef InstX8632Binop<InstX8632::Sar, true> InstX8632Sar;
 typedef InstX8632Binop<InstX8632::Psra> InstX8632Psra;
 typedef InstX8632Binop<InstX8632::Pcmpeq> InstX8632Pcmpeq;
 typedef InstX8632Binop<InstX8632::Pcmpgt> InstX8632Pcmpgt;
 typedef InstX8632Ternop<InstX8632::Idiv> InstX8632Idiv;
 typedef InstX8632Ternop<InstX8632::Div> InstX8632Div;
+typedef InstX8632Ternop<InstX8632::Pinsrw> InstX8632Pinsrw;
+typedef InstX8632Ternop<InstX8632::Shufps> InstX8632Shufps;
+typedef InstX8632ThreeAddressop<InstX8632::Pextrw> InstX8632Pextrw;
+typedef InstX8632ThreeAddressop<InstX8632::Pshufd> InstX8632Pshufd;
 
 // Base class for a lockable x86-32 instruction (emits a locked prefix).
 class InstX8632Lockable : public InstX8632 {
 public:
   virtual void emit(const Cfg *Func) const = 0;
   virtual void dump(const Cfg *Func) const;
 
 protected:
   bool Locked;
 
@@ skipping 485 matching lines @@
   static bool classof(const Inst *Inst) { return isClassof(Inst, Push); }
 
 private:
   InstX8632Push(Cfg *Func, Operand *Source, bool SuppressStackAdjustment);
   InstX8632Push(const InstX8632Push &) LLVM_DELETED_FUNCTION;
   InstX8632Push &operator=(const InstX8632Push &) LLVM_DELETED_FUNCTION;
   bool SuppressStackAdjustment;
   virtual ~InstX8632Push() {}
 };
 
-// Pshufd - shuffle a vector of doublewords 
-class InstX8632Pshufd : public InstX8632 {
-public:
-  static InstX8632Pshufd *create(Cfg *Func, Variable *Dest, Operand *Source1,
-                                 Operand *Source2) {
-    return new (Func->allocate<InstX8632Pshufd>())
-        InstX8632Pshufd(Func, Dest, Source1, Source2);
-  }
-  virtual void emit(const Cfg *Func) const;
-  virtual void dump(const Cfg *Func) const;
-  static bool classof(const Inst *Inst) { return isClassof(Inst, Pshufd); }
-
-private:
-  InstX8632Pshufd(Cfg *Func, Variable *Dest, Operand *Source1,
-                  Operand *Source2);
-  InstX8632Pshufd(const InstX8632Pshufd &) LLVM_DELETED_FUNCTION;
-  InstX8632Pshufd &operator=(const InstX8632Pshufd &) LLVM_DELETED_FUNCTION;
-  virtual ~InstX8632Pshufd() {}
-  static const char *Opcode;
-};
-
 // Ret instruction.  Currently only supports the "ret" version that
 // does not pop arguments.  This instruction takes a Source operand
 // (for non-void returning functions) for liveness analysis, though
 // a FakeUse before the ret would do just as well.
 class InstX8632Ret : public InstX8632 {
 public:
   static InstX8632Ret *create(Cfg *Func, Variable *Source = NULL) {
     return new (Func->allocate<InstX8632Ret>()) InstX8632Ret(Func, Source);
   }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Ret); }
 
 private:
   InstX8632Ret(Cfg *Func, Variable *Source);
   InstX8632Ret(const InstX8632Ret &) LLVM_DELETED_FUNCTION;
   InstX8632Ret &operator=(const InstX8632Ret &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Ret() {}
 };
 
-// Shufps - select from two vectors of floating point values
-class InstX8632Shufps : public InstX8632 {
-public:
-  static InstX8632Shufps *create(Cfg *Func, Variable *Dest, Operand *Source1,
-                                 Operand *Source2) {
-    return new (Func->allocate<InstX8632Shufps>())
-        InstX8632Shufps(Func, Dest, Source1, Source2);
-  }
-  virtual void emit(const Cfg *Func) const;
-  virtual void dump(const Cfg *Func) const;
-  static bool classof(const Inst *Inst) { return isClassof(Inst, Shufps); }
-
-private:
-  InstX8632Shufps(Cfg *Func, Variable *Dest, Operand *Source1,
-                  Operand *Source2);
-  InstX8632Shufps(const InstX8632Shufps &) LLVM_DELETED_FUNCTION;
-  InstX8632Shufps &operator=(const InstX8632Shufps &) LLVM_DELETED_FUNCTION;
-  virtual ~InstX8632Shufps() {}
-  static const char *Opcode;
-};
-
 // Exchanging Add instruction.  Exchanges the first operand (destination
 // operand) with the second operand (source operand), then loads the sum
 // of the two values into the destination operand. The destination may be
 // a register or memory, while the source must be a register.
 //
 // Both the dest and source are updated. The caller should then insert a
 // FakeDef to reflect the second udpate.
 class InstX8632Xadd : public InstX8632Lockable {
 public:
   static InstX8632Xadd *create(Cfg *Func, Operand *Dest, Variable *Source,
@@ skipping 31 matching lines @@
 private:
   InstX8632Xchg(Cfg *Func, Operand *Dest, Variable *Source);
   InstX8632Xchg(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   InstX8632Xchg &operator=(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Xchg() {}
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H