Handle GPR and vector shift ops. Handle pmull also.

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 553 matching lines @@
   ~InstX8632UnaryopXmm() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::XmmEmitterTwoOps Emitter;
 };
 
 // See the definition of emitTwoAddress() for a description of
 // ShiftHack.
 void emitTwoAddress(const char *Opcode, const Inst *Inst, const Cfg *Func,
                     bool ShiftHack = false);
 
-template <InstX8632::InstKindX8632 K, bool ShiftHack = false>
-class InstX8632Binop : public InstX8632 {
+template <InstX8632::InstKindX8632 K> class InstX8632Binop : public InstX8632 {
 public:
-  // Create a binary-op instruction like shifts.
+  // Create a binary-op instruction (not yet migrated to integrated assembler)
   static InstX8632Binop *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Binop>())
         InstX8632Binop(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
+    bool ShiftHack = false;

[Jim Stichnoth, 2014/10/02 20:35:17]

const bool

[jvoung (off chromium), 2014/10/02 22:04:13]

Done.

     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void dump(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632Binop(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
     addSource(Dest);
     addSource(Source);
   }
   InstX8632Binop(const InstX8632Binop &) = delete;
   InstX8632Binop &operator=(const InstX8632Binop &) = delete;
   ~InstX8632Binop() override {}
   static const char *Opcode;
 };
 
+void emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
+                     const Operand *Src,
+                     const x86::AssemblerX86::GPREmitterShiftOp &Emitter);
+
+template <InstX8632::InstKindX8632 K>
+class InstX8632BinopGPRShift : public InstX8632 {
+public:
+  // Create a binary-op GPR shift instruction.
+  static InstX8632BinopGPRShift *create(Cfg *Func, Variable *Dest,
+                                        Operand *Source) {
+    return new (Func->allocate<InstX8632BinopGPRShift>())
+        InstX8632BinopGPRShift(Func, Dest, Source);
+  }
+  void emit(const Cfg *Func) const override {
+    bool ShiftHack = true;
+    emitTwoAddress(Opcode, this, Func, ShiftHack);
+  }
+  void emitIAS(const Cfg *Func) const override {
+    Type Ty = getDest()->getType();
+    assert(getSrcSize() == 2);
+    emitIASGPRShift(Func, Ty, getDest(), getSrc(1), Emitter);
+  }
+  void dump(const Cfg *Func) const override {
+    Ostream &Str = Func->getContext()->getStrDump();
+    dumpDest(Func);
+    Str << " = " << Opcode << "." << getDest()->getType() << " ";
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstX8632BinopGPRShift(Cfg *Func, Variable *Dest, Operand *Source)
+      : InstX8632(Func, K, 2, Dest) {
+    addSource(Dest);
+    addSource(Source);
+  }
+  InstX8632BinopGPRShift(const InstX8632BinopGPRShift &) = delete;
+  InstX8632BinopGPRShift &operator=(const InstX8632BinopGPRShift &) = delete;
+  ~InstX8632BinopGPRShift() override {}
+  static const char *Opcode;
+  static const x86::AssemblerX86::GPREmitterShiftOp Emitter;
+};
+
 template <InstX8632::InstKindX8632 K>
 class InstX8632BinopGPR : public InstX8632 {
 public:
   // Create an ordinary binary-op instruction like add or sub.
   static InstX8632BinopGPR *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632BinopGPR>())
         InstX8632BinopGPR(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
     const bool ShiftHack = false;
@@ skipping 58 matching lines @@
     addSource(Dest);
     addSource(Source);
   }
   InstX8632BinopXmm(const InstX8632BinopXmm &) = delete;
   InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) = delete;
   ~InstX8632BinopXmm() override {}
   static const char *Opcode;
   static const x86::AssemblerX86::XmmEmitterTwoOps Emitter;
 };
 
+void emitIASXmmShift(const Cfg *Func, Type Ty, const Variable *Var,
+                     const Operand *Src,
+                     const x86::AssemblerX86::XmmEmitterShiftOp &Emitter);
+
+template <InstX8632::InstKindX8632 K>
+class InstX8632BinopXmmShift : public InstX8632 {
+public:
+  // Create an XMM binary-op instruction like addss or addps.
+  static InstX8632BinopXmmShift *create(Cfg *Func, Variable *Dest,
+                                        Operand *Source) {
+    return new (Func->allocate<InstX8632BinopXmmShift>())
+        InstX8632BinopXmmShift(Func, Dest, Source);
+  }
+  void emit(const Cfg *Func) const override {
+    const bool ShiftHack = false;
+    emitTwoAddress(Opcode, this, Func, ShiftHack);
+  }
+  void emitIAS(const Cfg *Func) const override {
+    Type Ty = getDest()->getType();
+    assert(Ty == IceType_v8i16 || Ty == IceType_v8i1 || Ty == IceType_v4i32 ||
+           Ty == IceType_v4i1);
+    Type ElementTy = typeElementType(Ty);
+    assert(getSrcSize() == 2);
+    emitIASXmmShift(Func, ElementTy, getDest(), getSrc(1), Emitter);
+  }
+  void dump(const Cfg *Func) const override {
+    Ostream &Str = Func->getContext()->getStrDump();
+    dumpDest(Func);
+    Str << " = " << Opcode << "." << getDest()->getType() << " ";
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstX8632BinopXmmShift(Cfg *Func, Variable *Dest, Operand *Source)
+      : InstX8632(Func, K, 2, Dest) {
+    addSource(Dest);
+    addSource(Source);
+  }
+  InstX8632BinopXmmShift(const InstX8632BinopXmmShift &) = delete;
+  InstX8632BinopXmmShift &operator=(const InstX8632BinopXmmShift &) = delete;
+  ~InstX8632BinopXmmShift() override {}
+  static const char *Opcode;
+  static const x86::AssemblerX86::XmmEmitterShiftOp Emitter;
+};
+
 template <InstX8632::InstKindX8632 K> class InstX8632Ternop : public InstX8632 {
 public:
   // 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);
   }
   void emit(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrEmit();
@@ skipping 134 matching lines @@
 typedef InstX8632BinopGPR<InstX8632::And> InstX8632And;
 typedef InstX8632BinopXmm<InstX8632::Pand, false> InstX8632Pand;
 typedef InstX8632BinopXmm<InstX8632::Pandn, false> InstX8632Pandn;
 typedef InstX8632BinopGPR<InstX8632::Or> InstX8632Or;
 typedef InstX8632BinopXmm<InstX8632::Por, false> InstX8632Por;
 typedef InstX8632BinopGPR<InstX8632::Xor> InstX8632Xor;
 typedef InstX8632BinopXmm<InstX8632::Pxor, false> InstX8632Pxor;
 typedef InstX8632BinopGPR<InstX8632::Imul> InstX8632Imul;
 typedef InstX8632BinopXmm<InstX8632::Mulps, true> InstX8632Mulps;
 typedef InstX8632BinopXmm<InstX8632::Mulss, false> InstX8632Mulss;
-typedef InstX8632Binop<InstX8632::Pmull> InstX8632Pmull;
+typedef InstX8632BinopXmm<InstX8632::Pmull, true> InstX8632Pmull;
 typedef InstX8632BinopXmm<InstX8632::Pmuludq, false> InstX8632Pmuludq;
 typedef InstX8632BinopXmm<InstX8632::Divps, true> InstX8632Divps;
 typedef InstX8632BinopXmm<InstX8632::Divss, false> InstX8632Divss;
-typedef InstX8632Binop<InstX8632::Rol, true> InstX8632Rol;
-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 InstX8632BinopGPRShift<InstX8632::Rol> InstX8632Rol;
+typedef InstX8632BinopGPRShift<InstX8632::Shl> InstX8632Shl;
+typedef InstX8632BinopXmmShift<InstX8632::Psll> InstX8632Psll;
+typedef InstX8632BinopGPRShift<InstX8632::Shr> InstX8632Shr;
+typedef InstX8632BinopGPRShift<InstX8632::Sar> InstX8632Sar;
+typedef InstX8632BinopXmmShift<InstX8632::Psra> InstX8632Psra;
 typedef InstX8632BinopXmm<InstX8632::Pcmpeq, true> InstX8632Pcmpeq;
 typedef InstX8632BinopXmm<InstX8632::Pcmpgt, true> InstX8632Pcmpgt;
 // TODO: movss is only a binary operation when the source and dest
 // operands are both registers.  In other cases, it behaves like a copy
 // (mov-like) operation.  Eventually, InstX8632Movss should assert that
 // both its source and dest operands are registers, and the lowering
 // code should use _mov instead of _movss in cases where a copy
 // operation is intended.
 typedef InstX8632Binop<InstX8632::Movss> InstX8632Movss;
 typedef InstX8632Ternop<InstX8632::Idiv> InstX8632Idiv;
@@ skipping 582 matching lines @@
 template <> void InstX8632Psra::emit(const Cfg *Func) const;
 template <> void InstX8632Psub::emit(const Cfg *Func) const;
 template <> void InstX8632Sqrtss::emit(const Cfg *Func) const;
 template <> void InstX8632Subss::emit(const Cfg *Func) const;
 
 template <> void InstX8632Div::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Idiv::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Imul::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Cbwdq::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movd::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H