Add initial integrated assembler w/ some Xmm ops.

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
 // their subclasses.  This represents the machine instructions and
 // operands used for x86-32 code selection.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINSTX8632_H
 #define SUBZERO_SRC_ICEINSTX8632_H
 
+#include "assembler_ia32.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceConditionCodesX8632.h"
 #include "IceInstX8632.def"
 #include "IceOperand.h"
 
 namespace Ice {
 
 class TargetX8632;
 
@@ skipping 39 matching lines @@
                                  uint16_t Shift = 0,
                                  SegmentRegisters SegmentReg = DefaultSegment) {
     return new (Func->allocate<OperandX8632Mem>())
         OperandX8632Mem(Func, Ty, Base, Offset, Index, Shift, SegmentReg);
   }
   Variable *getBase() const { return Base; }
   Constant *getOffset() const { return Offset; }
   Variable *getIndex() const { return Index; }
   uint16_t getShift() const { return Shift; }
   SegmentRegisters getSegmentRegister() const { return SegmentReg; }
+  x86::Address toAsmAddress(Assembler *Asm) const;
   virtual void emit(const Cfg *Func) const;
   using OperandX8632::dump;
   virtual void dump(const Cfg *Func, Ostream &Str) const;
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == static_cast<OperandKind>(kMem);
   }
 
 private:
   OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base, Constant *Offset,
@@ skipping 301 matching lines @@
 
 // AdjustStack instruction - subtracts esp by the given amount and
 // updates the stack offset during code emission.
 class InstX8632AdjustStack : public InstX8632 {
 public:
   static InstX8632AdjustStack *create(Cfg *Func, SizeT Amount, Variable *Esp) {
     return new (Func->allocate<InstX8632AdjustStack>())
         InstX8632AdjustStack(Func, Amount, Esp);
   }
   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, Adjuststack); }
 
 private:
   InstX8632AdjustStack(Cfg *Func, SizeT Amount, Variable *Esp);
   InstX8632AdjustStack(const InstX8632AdjustStack &) LLVM_DELETED_FUNCTION;
   InstX8632AdjustStack &operator=(const InstX8632AdjustStack &)
       LLVM_DELETED_FUNCTION;
   SizeT Amount;
 };
@@ skipping 62 matching lines @@
   }
   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 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)
       : InstX8632(Func, K, 1, Dest) {
     addSource(Src);
   }
   InstX8632Unaryop(const InstX8632Unaryop &) LLVM_DELETED_FUNCTION;
   InstX8632Unaryop &operator=(const InstX8632Unaryop &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Unaryop() {}
   static const char *Opcode;
 };
 
+void emitIASVarOperandTyXMM(const Cfg *Func, Type Ty, const Variable *Var,
+                            const Operand *Src,
+                            const x86::AssemblerX86::TypedXmmEmitters &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();
+    assert(getSrcSize() == 1);
+    Str << "\t" << Opcode << "\t";
+    getDest()->emit(Func);
+    Str << ", ";
+    getSrc(0)->emit(Func);
+    Str << "\n";
+  }
+  virtual void emitIAS(const Cfg *Func) const {
+    Type Ty = getDest()->getType();
+    assert(getSrcSize() == 1);
+    emitIASVarOperandTyXMM(Func, Ty, getDest(), getSrc(0), 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:
+  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;
+};
+
 // 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.
   static InstX8632Binop *create(Cfg *Func, Variable *Dest, Operand *Source) {
@@ skipping 16 matching lines @@
       : InstX8632(Func, K, 2, Dest) {
     addSource(Dest);
     addSource(Source);
   }
   InstX8632Binop(const InstX8632Binop &) LLVM_DELETED_FUNCTION;
   InstX8632Binop &operator=(const InstX8632Binop &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Binop() {}
   static const char *Opcode;
 };
 
+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);
+  }
+  virtual void emit(const Cfg *Func) const {
+    const bool ShiftHack = false;
+    emitTwoAddress(Opcode, this, Func, ShiftHack);
+  }
+  virtual void emitIAS(const Cfg *Func) const {
+    Type Ty = getDest()->getType();
+    if (NeedsElementType)
+      Ty = typeElementType(Ty);
+    assert(getSrcSize() == 2);
+    emitIASVarOperandTyXMM(Func, Ty, getDest(), getSrc(1), 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:
+  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;
+};
+
 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);
   }
   virtual void emit(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrEmit();
@@ skipping 104 matching lines @@
 
   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 InstX8632Unaryop<InstX8632::Sqrtss> InstX8632Sqrtss;
+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 InstX8632Binop<InstX8632::Addps> InstX8632Addps;
+typedef InstX8632BinopXmm<InstX8632::Addps, true> InstX8632Addps;
 typedef InstX8632Binop<InstX8632::Adc> InstX8632Adc;
-typedef InstX8632Binop<InstX8632::Addss> InstX8632Addss;
-typedef InstX8632Binop<InstX8632::Padd> InstX8632Padd;
+typedef InstX8632BinopXmm<InstX8632::Addss, false> InstX8632Addss;
+typedef InstX8632BinopXmm<InstX8632::Padd, true> InstX8632Padd;
 typedef InstX8632Binop<InstX8632::Sub> InstX8632Sub;
-typedef InstX8632Binop<InstX8632::Subps> InstX8632Subps;
-typedef InstX8632Binop<InstX8632::Subss> InstX8632Subss;
+typedef InstX8632BinopXmm<InstX8632::Subps, true> InstX8632Subps;
+typedef InstX8632BinopXmm<InstX8632::Subss, false> InstX8632Subss;
 typedef InstX8632Binop<InstX8632::Sbb> InstX8632Sbb;
-typedef InstX8632Binop<InstX8632::Psub> InstX8632Psub;
+typedef InstX8632BinopXmm<InstX8632::Psub, true> InstX8632Psub;
 typedef InstX8632Binop<InstX8632::And> InstX8632And;
-typedef InstX8632Binop<InstX8632::Pand> InstX8632Pand;
-typedef InstX8632Binop<InstX8632::Pandn> InstX8632Pandn;
+typedef InstX8632BinopXmm<InstX8632::Pand, false> InstX8632Pand;
+typedef InstX8632BinopXmm<InstX8632::Pandn, false> InstX8632Pandn;
 typedef InstX8632Binop<InstX8632::Or> InstX8632Or;
-typedef InstX8632Binop<InstX8632::Por> InstX8632Por;
+typedef InstX8632BinopXmm<InstX8632::Por, false> InstX8632Por;
 typedef InstX8632Binop<InstX8632::Xor> InstX8632Xor;
-typedef InstX8632Binop<InstX8632::Pxor> InstX8632Pxor;
+typedef InstX8632BinopXmm<InstX8632::Pxor, false> InstX8632Pxor;
 typedef InstX8632Binop<InstX8632::Imul> InstX8632Imul;
-typedef InstX8632Binop<InstX8632::Mulps> InstX8632Mulps;
-typedef InstX8632Binop<InstX8632::Mulss> InstX8632Mulss;
+typedef InstX8632BinopXmm<InstX8632::Mulps, true> InstX8632Mulps;
+typedef InstX8632BinopXmm<InstX8632::Mulss, false> InstX8632Mulss;
 typedef InstX8632Binop<InstX8632::Pmull> InstX8632Pmull;
-typedef InstX8632Binop<InstX8632::Pmuludq> InstX8632Pmuludq;
-typedef InstX8632Binop<InstX8632::Divps> InstX8632Divps;
-typedef InstX8632Binop<InstX8632::Divss> InstX8632Divss;
+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 InstX8632Binop<InstX8632::Pcmpeq> InstX8632Pcmpeq;
 typedef InstX8632Binop<InstX8632::Pcmpgt> 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
@@ skipping 117 matching lines @@
 // Cmpps instruction - compare packed singled-precision floating point
 // values
 class InstX8632Cmpps : public InstX8632 {
 public:
   static InstX8632Cmpps *create(Cfg *Func, Variable *Dest, Operand *Source,
                                 CondX86::CmppsCond Condition) {
     return new (Func->allocate<InstX8632Cmpps>())
         InstX8632Cmpps(Func, Dest, Source, Condition);
   }
   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, Cmpps); }
 
 private:
   InstX8632Cmpps(Cfg *Func, Variable *Dest, Operand *Source,
                  CondX86::CmppsCond Cond);
   InstX8632Cmpps(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   InstX8632Cmpps &operator=(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmpps() {}
 
@@ skipping 93 matching lines @@
 };
 
 // ucomiss/ucomisd - floating-point compare instruction.
 class InstX8632Ucomiss : public InstX8632 {
 public:
   static InstX8632Ucomiss *create(Cfg *Func, Operand *Src1, Operand *Src2) {
     return new (Func->allocate<InstX8632Ucomiss>())
         InstX8632Ucomiss(Func, Src1, Src2);
   }
   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, Ucomiss); }
 
 private:
   InstX8632Ucomiss(Cfg *Func, Operand *Src1, Operand *Src2);
   InstX8632Ucomiss(const InstX8632Ucomiss &) LLVM_DELETED_FUNCTION;
   InstX8632Ucomiss &operator=(const InstX8632Ucomiss &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Ucomiss() {}
 };
 
@@ skipping 147 matching lines @@
 // Nop instructions of varying length
 class InstX8632Nop : public InstX8632 {
 public:
   // TODO: Replace with enum.
   typedef unsigned NopVariant;
 
   static InstX8632Nop *create(Cfg *Func, NopVariant Variant) {
     return new (Func->allocate<InstX8632Nop>()) InstX8632Nop(Func, Variant);
   }
   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, Nop); }
 
 private:
   InstX8632Nop(Cfg *Func, SizeT Length);
   InstX8632Nop(const InstX8632Nop &) LLVM_DELETED_FUNCTION;
   InstX8632Nop &operator=(const InstX8632Nop &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Nop() {}
 
   NopVariant Variant;
@@ skipping 32 matching lines @@
   InstX8632Fstp &operator=(const InstX8632Fstp &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Fstp() {}
 };
 
 class InstX8632Pop : public InstX8632 {
 public:
   static InstX8632Pop *create(Cfg *Func, Variable *Dest) {
     return new (Func->allocate<InstX8632Pop>()) InstX8632Pop(Func, Dest);
   }
   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, Pop); }
 
 private:
   InstX8632Pop(Cfg *Func, Variable *Dest);
   InstX8632Pop(const InstX8632Pop &) LLVM_DELETED_FUNCTION;
   InstX8632Pop &operator=(const InstX8632Pop &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Pop() {}
 };
 
@@ skipping 19 matching lines @@
 // 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 emitIAS(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() {}
 };
 
@@ skipping 67 matching lines @@
 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;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H