Handle a few more instructions in assembler (cmov, cdq, cmpxchg, xadd, xchg).

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 877 matching lines @@
 
 // Conditional move instruction.
 class InstX8632Cmov : public InstX8632 {
 public:
   static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
                                CondX86::BrCond Cond) {
     return new (Func->allocate<InstX8632Cmov>())
         InstX8632Cmov(Func, Dest, Source, Cond);
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Cmov); }
 
 private:
   InstX8632Cmov(Cfg *Func, Variable *Dest, Operand *Source,
                 CondX86::BrCond Cond);
   InstX8632Cmov(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   InstX8632Cmov &operator=(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmov() {}
 
@@ skipping 30 matching lines @@
 // <dest> can be a register or memory, while <desired> must be a register.
 // It is the user's responsiblity to mark eax with a FakeDef.
 class InstX8632Cmpxchg : public InstX8632Lockable {
 public:
   static InstX8632Cmpxchg *create(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                                   Variable *Desired, bool Locked) {
     return new (Func->allocate<InstX8632Cmpxchg>())
         InstX8632Cmpxchg(Func, DestOrAddr, Eax, Desired, Locked);
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Cmpxchg); }
 
 private:
   InstX8632Cmpxchg(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
                    Variable *Desired, bool Locked);
   InstX8632Cmpxchg(const InstX8632Cmpxchg &) LLVM_DELETED_FUNCTION;
   InstX8632Cmpxchg &operator=(const InstX8632Cmpxchg &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmpxchg() {}
 };
 
 // Cmpxchg8b instruction - cmpxchg8b <m64> will compare if <m64>
 // equals edx:eax. If so, the ZF is set and ecx:ebx is stored in <m64>.
 // If not, ZF is cleared and <m64> is copied to edx:eax.
 // The caller is responsible for inserting FakeDefs to mark edx
 // and eax as modified.
 // <m64> must be a memory operand.
 class InstX8632Cmpxchg8b : public InstX8632Lockable {
 public:
-  static InstX8632Cmpxchg8b *create(Cfg *Func, OperandX8632 *Dest,
+  static InstX8632Cmpxchg8b *create(Cfg *Func, OperandX8632Mem *Dest,
                                     Variable *Edx, Variable *Eax, Variable *Ecx,
                                     Variable *Ebx, bool Locked) {
     return new (Func->allocate<InstX8632Cmpxchg8b>())
         InstX8632Cmpxchg8b(Func, Dest, Edx, Eax, Ecx, Ebx, Locked);
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Cmpxchg8b); }
 
 private:
-  InstX8632Cmpxchg8b(Cfg *Func, OperandX8632 *Dest, Variable *Edx,
+  InstX8632Cmpxchg8b(Cfg *Func, OperandX8632Mem *Dest, Variable *Edx,
                      Variable *Eax, Variable *Ecx, Variable *Ebx, bool Locked);
   InstX8632Cmpxchg8b(const InstX8632Cmpxchg8b &) LLVM_DELETED_FUNCTION;
   InstX8632Cmpxchg8b &
   operator=(const InstX8632Cmpxchg8b &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmpxchg8b() {}
 };
 
 // Cvt instruction - wrapper for cvtsX2sY where X and Y are in {s,d,i}
 // as appropriate.  s=float, d=double, i=int.  X and Y are determined
 // from dest/src types.  Sign and zero extension on the integer
@@ skipping 323 matching lines @@
 // 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,
                                bool Locked) {
     return new (Func->allocate<InstX8632Xadd>())
         InstX8632Xadd(Func, Dest, Source, Locked);
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Xadd); }
 
 private:
   InstX8632Xadd(Cfg *Func, Operand *Dest, Variable *Source, bool Locked);
   InstX8632Xadd(const InstX8632Xadd &) LLVM_DELETED_FUNCTION;
   InstX8632Xadd &operator=(const InstX8632Xadd &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Xadd() {}
 };
 
 // Exchange instruction.  Exchanges the first operand (destination
 // operand) with the second operand (source operand). At least one of
 // the operands must be a register (and the other can be reg or mem).
 // Both the Dest and Source are updated. If there is a memory operand,
 // then the instruction is automatically "locked" without the need for
 // a lock prefix.
 class InstX8632Xchg : public InstX8632 {
 public:
   static InstX8632Xchg *create(Cfg *Func, Operand *Dest, Variable *Source) {
     return new (Func->allocate<InstX8632Xchg>())
         InstX8632Xchg(Func, Dest, Source);
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Xchg); }
 
 private:
   InstX8632Xchg(Cfg *Func, Operand *Dest, Variable *Source);
   InstX8632Xchg(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   InstX8632Xchg &operator=(const InstX8632Xchg &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Xchg() {}
 };
 
@@ skipping 16 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 InstX8632Cbwdq::emitIAS(const Cfg *Func) const;
+
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H