Handle add, adc, etc., mfence, div, idiv, mul in the 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 410 matching lines @@
   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;
   ~InstX8632Call() override {}
 };
 
 // Emit a one-operand (GPR) instruction.
-void emitIASVarTyGPR(const Cfg *Func, Type Ty, const Variable *Var,
-                     const x86::AssemblerX86::GPREmitterOneOp &Emitter);
+void emitIASOpTyGPR(const Cfg *Func, Type Ty, const Operand *Var,
+                    const x86::AssemblerX86::GPREmitterOneOp &Emitter);
 
 // Instructions of the form x := op(x).
 template <InstX8632::InstKindX8632 K>
 class InstX8632InplaceopGPR : public InstX8632 {
 public:
   static InstX8632InplaceopGPR *create(Cfg *Func, Operand *SrcDest) {
     return new (Func->allocate<InstX8632InplaceopGPR>())
         InstX8632InplaceopGPR(Func, SrcDest);
   }
   void emit(const Cfg *Func) const override {
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getSrc(0)->emit(Func);
     Str << "\n";
   }
   void emitIAS(const Cfg *Func) const override {
     assert(getSrcSize() == 1);
     const Variable *Var = getDest();
     Type Ty = Var->getType();
-    emitIASVarTyGPR(Func, Ty, Var, Emitter);
+    emitIASOpTyGPR(Func, Ty, Var, 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:
@@ skipping 107 matching lines @@
 };
 
 // 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:
-  // Create an ordinary binary-op instruction like add or sub.
+  // Create a binary-op instruction like shifts.
   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 {
     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 &) LLVM_DELETED_FUNCTION;
   InstX8632Binop &operator=(const InstX8632Binop &) LLVM_DELETED_FUNCTION;
   ~InstX8632Binop() override {}
   static const char *Opcode;
 };
 
+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;
+    emitTwoAddress(Opcode, this, Func, ShiftHack);
+  }
+  void emitIAS(const Cfg *Func) const override {
+    Type Ty = getDest()->getType();
+    assert(getSrcSize() == 2);
+    emitIASRegOpTyGPR(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:
+  InstX8632BinopGPR(Cfg *Func, Variable *Dest, Operand *Source)
+      : InstX8632(Func, K, 2, Dest) {
+    addSource(Dest);
+    addSource(Source);
+  }
+  InstX8632BinopGPR(const InstX8632BinopGPR &) LLVM_DELETED_FUNCTION;
+  InstX8632BinopGPR &operator=(const InstX8632BinopGPR &) LLVM_DELETED_FUNCTION;
+  ~InstX8632BinopGPR() override {}
+  static const char *Opcode;
+  static const x86::AssemblerX86::GPREmitterRegOp Emitter;
+};
+
 template <InstX8632::InstKindX8632 K, bool NeedsElementType>
 class InstX8632BinopXmm : public InstX8632 {
 public:
   // Create an XMM binary-op instruction like addss or addps.
   static InstX8632BinopXmm *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632BinopXmm>())
         InstX8632BinopXmm(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
     const bool ShiftHack = false;
@@ skipping 39 matching lines @@
     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";
   }
+  void emitIAS(const Cfg *Func) const override { emit(Func); }
   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:
   InstX8632Ternop(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
@@ skipping 96 matching lines @@
 typedef InstX8632UnaryopGPR<InstX8632::Cbwdq> InstX8632Cbwdq;
 typedef InstX8632UnaryopXmm<InstX8632::Movd> InstX8632Movd;
 typedef InstX8632UnaryopXmm<InstX8632::Sqrtss> InstX8632Sqrtss;
 // 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 InstX8632BinopGPR<InstX8632::Add> InstX8632Add;
 typedef InstX8632BinopXmm<InstX8632::Addps, true> InstX8632Addps;
-typedef InstX8632Binop<InstX8632::Adc> InstX8632Adc;
+typedef InstX8632BinopGPR<InstX8632::Adc> InstX8632Adc;
 typedef InstX8632BinopXmm<InstX8632::Addss, false> InstX8632Addss;
 typedef InstX8632BinopXmm<InstX8632::Padd, true> InstX8632Padd;
-typedef InstX8632Binop<InstX8632::Sub> InstX8632Sub;
+typedef InstX8632BinopGPR<InstX8632::Sub> InstX8632Sub;
 typedef InstX8632BinopXmm<InstX8632::Subps, true> InstX8632Subps;
 typedef InstX8632BinopXmm<InstX8632::Subss, false> InstX8632Subss;
-typedef InstX8632Binop<InstX8632::Sbb> InstX8632Sbb;
+typedef InstX8632BinopGPR<InstX8632::Sbb> InstX8632Sbb;
 typedef InstX8632BinopXmm<InstX8632::Psub, true> InstX8632Psub;
-typedef InstX8632Binop<InstX8632::And> InstX8632And;
+typedef InstX8632BinopGPR<InstX8632::And> InstX8632And;
 typedef InstX8632BinopXmm<InstX8632::Pand, false> InstX8632Pand;
 typedef InstX8632BinopXmm<InstX8632::Pandn, false> InstX8632Pandn;
-typedef InstX8632Binop<InstX8632::Or> InstX8632Or;
+typedef InstX8632BinopGPR<InstX8632::Or> InstX8632Or;
 typedef InstX8632BinopXmm<InstX8632::Por, false> InstX8632Por;
-typedef InstX8632Binop<InstX8632::Xor> InstX8632Xor;
+typedef InstX8632BinopGPR<InstX8632::Xor> InstX8632Xor;
 typedef InstX8632BinopXmm<InstX8632::Pxor, false> InstX8632Pxor;
 typedef InstX8632Binop<InstX8632::Imul> InstX8632Imul;
 typedef InstX8632BinopXmm<InstX8632::Mulps, true> InstX8632Mulps;
 typedef InstX8632BinopXmm<InstX8632::Mulss, false> InstX8632Mulss;
 typedef InstX8632Binop<InstX8632::Pmull> 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;
@@ skipping 41 matching lines @@
 
 // Mul instruction - unsigned multiply.
 class InstX8632Mul : public InstX8632 {
 public:
   static InstX8632Mul *create(Cfg *Func, Variable *Dest, Variable *Source1,
                               Operand *Source2) {
     return new (Func->allocate<InstX8632Mul>())
         InstX8632Mul(Func, Dest, Source1, Source2);
   }
   void emit(const Cfg *Func) const override;
+  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Mul); }
 
 private:
   InstX8632Mul(Cfg *Func, Variable *Dest, Variable *Source1, Operand *Source2);
   InstX8632Mul(const InstX8632Mul &) LLVM_DELETED_FUNCTION;
   InstX8632Mul &operator=(const InstX8632Mul &) LLVM_DELETED_FUNCTION;
   ~InstX8632Mul() override {}
 };
 
@@ skipping 234 matching lines @@
   ~InstX8632Test() override {}
 };
 
 // Mfence instruction.
 class InstX8632Mfence : public InstX8632 {
 public:
   static InstX8632Mfence *create(Cfg *Func) {
     return new (Func->allocate<InstX8632Mfence>()) InstX8632Mfence(Func);
   }
   void emit(const Cfg *Func) const override;
+  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Mfence); }
 
 private:
   InstX8632Mfence(Cfg *Func);
   InstX8632Mfence(const InstX8632Mfence &) LLVM_DELETED_FUNCTION;
   InstX8632Mfence &operator=(const InstX8632Mfence &) LLVM_DELETED_FUNCTION;
   ~InstX8632Mfence() override {}
 };
 
@@ skipping 275 matching lines @@
 template <> void InstX8632Pextr::emit(const Cfg *Func) const;
 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 InstX8632Div::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Idiv::emitIAS(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