Handle "inplace" ops and unary ops w/ assembler

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 411 matching lines @@
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Call); }
 
 private:
   InstX8632Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
   InstX8632Call(const InstX8632Call &) LLVM_DELETED_FUNCTION;
   InstX8632Call &operator=(const InstX8632Call &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Call() {}
 };
 
+// Emit a one-operand (GPR) instruction.
+void emitIASVarTyGPR(const Cfg *Func, Type Ty, const Variable *Var,
+                     const x86::AssemblerX86::GPREmitterOneOp &Emitter);
+
 // Instructions of the form x := op(x).
 template <InstX8632::InstKindX8632 K>
-class InstX8632Inplaceop : public InstX8632 {
+class InstX8632InplaceopGPR : public InstX8632 {
 public:
-  static InstX8632Inplaceop *create(Cfg *Func, Operand *SrcDest) {
-    return new (Func->allocate<InstX8632Inplaceop>())
-        InstX8632Inplaceop(Func, SrcDest);
+  static InstX8632InplaceopGPR *create(Cfg *Func, Operand *SrcDest) {
+    return new (Func->allocate<InstX8632InplaceopGPR>())
+        InstX8632InplaceopGPR(Func, SrcDest);
   }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getSrc(0)->emit(Func);
     Str << "\n";
   }
+  virtual void emitIAS(const Cfg *Func) const {
+    assert(getSrcSize() == 1);
+    const Variable *Var = getDest();
+    Type Ty = Var->getType();
+    emitIASVarTyGPR(Func, Ty, Var, Emitter);
+  }
   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:
-  InstX8632Inplaceop(Cfg *Func, Operand *SrcDest)
+  InstX8632InplaceopGPR(Cfg *Func, Operand *SrcDest)
       : InstX8632(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
     addSource(SrcDest);
   }
-  InstX8632Inplaceop(const InstX8632Inplaceop &) LLVM_DELETED_FUNCTION;
-  InstX8632Inplaceop &
-  operator=(const InstX8632Inplaceop &) LLVM_DELETED_FUNCTION;
-  virtual ~InstX8632Inplaceop() {}
+  InstX8632InplaceopGPR(const InstX8632InplaceopGPR &) LLVM_DELETED_FUNCTION;
+  InstX8632InplaceopGPR &
+  operator=(const InstX8632InplaceopGPR &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632InplaceopGPR() {}
   static const char *Opcode;
+  static const x86::AssemblerX86::GPREmitterOneOp Emitter;
 };
 
+// Emit a two-operand (GPR) instruction, where the dest operand is a
+// Variable that's guaranteed to be a register.
+void emitIASRegOpTyGPR(const Cfg *Func, Type Ty, const Variable *Dst,
+                       const Operand *Src,
+                       const x86::AssemblerX86::GPREmitterRegOp &Emitter);
+
 // Instructions of the form x := op(y)
 template <InstX8632::InstKindX8632 K>
-class InstX8632Unaryop : public InstX8632 {
+class InstX8632UnaryopGPR : public InstX8632 {
 public:
-  static InstX8632Unaryop *create(Cfg *Func, Variable *Dest, Operand *Src) {
-    return new (Func->allocate<InstX8632Unaryop>())
-        InstX8632Unaryop(Func, Dest, Src);
+  static InstX8632UnaryopGPR *create(Cfg *Func, Variable *Dest, Operand *Src) {
+    return new (Func->allocate<InstX8632UnaryopGPR>())
+        InstX8632UnaryopGPR(Func, Dest, Src);
   }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getDest()->emit(Func);
     Str << ", ";
     getSrc(0)->emit(Func);
     Str << "\n";
   }
-  virtual void emitIAS(const Cfg *Func) const { emit(Func); }
+  virtual void emitIAS(const Cfg *Func) const {
+    assert(getSrcSize() == 1);
+    const Variable *Var = getDest();
+    Type Ty = Var->getType();
+    const Operand *Src = getSrc(0);
+    emitIASRegOpTyGPR(Func, Ty, Var, Src, Emitter);
+  }
   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:
-  InstX8632Unaryop(Cfg *Func, Variable *Dest, Operand *Src)
+  InstX8632UnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src)
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
-  InstX8632Unaryop(const InstX8632Unaryop &) LLVM_DELETED_FUNCTION;
-  InstX8632Unaryop &operator=(const InstX8632Unaryop &) LLVM_DELETED_FUNCTION;
-  virtual ~InstX8632Unaryop() {}
+  InstX8632UnaryopGPR(const InstX8632UnaryopGPR &) LLVM_DELETED_FUNCTION;
+  InstX8632UnaryopGPR &
+  operator=(const InstX8632UnaryopGPR &) LLVM_DELETED_FUNCTION;
+  virtual ~InstX8632UnaryopGPR() {}
   static const char *Opcode;
+  static const x86::AssemblerX86::GPREmitterRegOp Emitter;
 };
 
 void emitIASVarOperandTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
                             const Operand *Src,
-                            const x86::AssemblerX86::TypedXmmEmitters &Emitter);
+                            const x86::AssemblerX86::XmmEmitterTwoOps &Emitter);
 
 template <InstX8632::InstKindX8632 K>
 class InstX8632UnaryopXmm : public InstX8632 {
 public:
   static InstX8632UnaryopXmm *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopXmm>())
         InstX8632UnaryopXmm(Func, Dest, Src);
   }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
@@ skipping 20 matching lines @@
 private:
   InstX8632UnaryopXmm(Cfg *Func, Variable *Dest, Operand *Src)
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
   InstX8632UnaryopXmm(const InstX8632UnaryopXmm &) LLVM_DELETED_FUNCTION;
   InstX8632UnaryopXmm &
   operator=(const InstX8632UnaryopXmm &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632UnaryopXmm() {}
   static const char *Opcode;
-  static const x86::AssemblerX86::TypedXmmEmitters Emitter;
+  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 {
 public:
@@ skipping 55 matching lines @@
 private:
   InstX8632BinopXmm(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
     addSource(Dest);
     addSource(Source);
   }
   InstX8632BinopXmm(const InstX8632BinopXmm &) LLVM_DELETED_FUNCTION;
   InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632BinopXmm() {}
   static const char *Opcode;
-  static const x86::AssemblerX86::TypedXmmEmitters Emitter;
+  static const x86::AssemblerX86::XmmEmitterTwoOps 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);
   }
@@ skipping 100 matching lines @@
       : InstX8632(Func, K, 1, Dest) {
     addSource(Source);
   }
   InstX8632Movlike(const InstX8632Movlike &) LLVM_DELETED_FUNCTION;
   InstX8632Movlike &operator=(const InstX8632Movlike &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Movlike() {}
 
   static const char *Opcode;
 };
 
-typedef InstX8632Inplaceop<InstX8632::Bswap> InstX8632Bswap;
-typedef InstX8632Inplaceop<InstX8632::Neg> InstX8632Neg;
-typedef InstX8632Unaryop<InstX8632::Bsf> InstX8632Bsf;
-typedef InstX8632Unaryop<InstX8632::Bsr> InstX8632Bsr;
-typedef InstX8632Unaryop<InstX8632::Lea> InstX8632Lea;
-typedef InstX8632Unaryop<InstX8632::Movd> InstX8632Movd;
+typedef InstX8632InplaceopGPR<InstX8632::Bswap> InstX8632Bswap;
+typedef InstX8632InplaceopGPR<InstX8632::Neg> InstX8632Neg;
+typedef InstX8632UnaryopGPR<InstX8632::Bsf> InstX8632Bsf;
+typedef InstX8632UnaryopGPR<InstX8632::Bsr> InstX8632Bsr;
+typedef InstX8632UnaryopGPR<InstX8632::Lea> InstX8632Lea;
+// Cbwdq instruction - wrapper for cbw, cwd, and cdq
+typedef InstX8632UnaryopGPR<InstX8632::Cbwdq> InstX8632Cbwdq;
+typedef InstX8632UnaryopXmm<InstX8632::Movd> InstX8632Movd;
 typedef InstX8632UnaryopXmm<InstX8632::Sqrtss> InstX8632Sqrtss;
-// Cbwdq instruction - wrapper for cbw, cwd, and cdq
-typedef InstX8632Unaryop<InstX8632::Cbwdq> InstX8632Cbwdq;
 // Move/assignment instruction - wrapper for mov/movss/movsd.
 typedef InstX8632Movlike<InstX8632::Mov> InstX8632Mov;
 // Move packed - copy 128 bit values between XMM registers, or mem128
 // and XMM registers.
 typedef InstX8632Movlike<InstX8632::Movp> InstX8632Movp;
 // Movq - copy between XMM registers, or mem64 and XMM registers.
 typedef InstX8632Movlike<InstX8632::Movq> InstX8632Movq;
 typedef InstX8632Binop<InstX8632::Add> InstX8632Add;
 typedef InstX8632BinopXmm<InstX8632::Addps, true> InstX8632Addps;
 typedef InstX8632Binop<InstX8632::Adc> InstX8632Adc;
@@ skipping 614 matching lines @@
 template <> void InstX8632Pinsr::emit(const Cfg *Func) const;
 template <> void InstX8632Pmull::emit(const Cfg *Func) const;
 template <> void InstX8632Pmuludq::emit(const Cfg *Func) const;
 template <> void InstX8632Psll::emit(const Cfg *Func) const;
 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 InstX8632Cbwdq::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Movd::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H