Start adding an integrated 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
 // 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 "IceInstX8632.def"
 #include "IceOperand.h"
 
 namespace Ice {
 
 class TargetX8632;
 
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
@@ skipping 35 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 convertToAsmAddress(IceString &SymbolicOffset) const;
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == static_cast<OperandKind>(kMem);
   }
 
 private:
   OperandX8632Mem(Cfg *Func, Type Ty, Variable *Base, Constant *Offset,
                   Variable *Index, uint16_t Shift, SegmentRegisters SegmentReg);
@@ skipping 137 matching lines @@
 
   enum BrCond {
 #define X(tag, dump, emit) tag,
     ICEINSTX8632BR_TABLE
 #undef X
         Br_None
   };
 
   static const char *getWidthString(Type Ty);
   virtual void emit(const Cfg *Func) const = 0;
+  virtual void emitIAS(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
 
 protected:
   InstX8632(Cfg *Func, InstKindX8632 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
   virtual ~InstX8632() {}
   static bool isClassof(const Inst *Inst, InstKindX8632 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
 
@@ skipping 124 matching lines @@
 
 // Call instruction.  Arguments should have already been pushed.
 class InstX8632Call : public InstX8632 {
 public:
   static InstX8632Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
     return new (Func->allocate<InstX8632Call>())
         InstX8632Call(Func, Dest, CallTarget);
   }
   Operand *getCallTarget() const { return getSrc(0); }
   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, Call); }
 
 private:
   InstX8632Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
   InstX8632Call(const InstX8632Call &) LLVM_DELETED_FUNCTION;
   InstX8632Call &operator=(const InstX8632Call &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Call() {}
 };
 
 // Instructions of the form x := op(x).
 template <InstX8632::InstKindX8632 K>
 class InstX8632Inplaceop : public InstX8632 {
 public:
   static InstX8632Inplaceop *create(Cfg *Func, Operand *SrcDest) {
     return new (Func->allocate<InstX8632Inplaceop>())
         InstX8632Inplaceop(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 { 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:
   InstX8632Inplaceop(Cfg *Func, Operand *SrcDest)
@@ skipping 17 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)
@@ skipping 15 matching lines @@
 class InstX8632Binop : public InstX8632 {
 public:
   // Create an ordinary binary-op instruction like add or sub.
   static InstX8632Binop *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Binop>())
         InstX8632Binop(Func, Dest, Source);
   }
   virtual void emit(const Cfg *Func) const {
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
+  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:
   InstX8632Binop(Cfg *Func, Variable *Dest, Operand *Source)
@@ skipping 19 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";
   }
+  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:
   InstX8632Ternop(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
@@ skipping 21 matching lines @@
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 2);
     Str << "\t" << Opcode << "\t";
     getDest()->emit(Func);
     Str << ", ";
     getSrc(0)->emit(Func);
     Str << ", ";
     getSrc(1)->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:
   InstX8632ThreeAddressop(Cfg *Func, Variable *Dest, Operand *Source0,
@@ skipping 17 matching lines @@
 class InstX8632Movlike : public InstX8632 {
 public:
   static InstX8632Movlike *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movlike>())
         InstX8632Movlike(Func, Dest, Source);
   }
   virtual bool isRedundantAssign() const {
     return checkForRedundantAssign(getDest(), getSrc(0));
   }
   virtual void emit(const Cfg *Func) const;
+  virtual void emitIAS(const Cfg *Func) const { emit(Func); }
   virtual void dump(const Cfg *Func) const {
     Ostream &Str = Func->getContext()->getStrDump();
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
@@ skipping 159 matching lines @@
 
 // Conditional move instruction.
 class InstX8632Cmov : public InstX8632 {
 public:
   static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
                                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, BrCond Cond);
   InstX8632Cmov(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   InstX8632Cmov &operator=(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmov() {}
 
   BrCond Condition;
 };
 
 // Cmpps instruction - compare packed singled-precision floating point
 // values
 class InstX8632Cmpps : public InstX8632 {
 public:
   enum CmppsCond {
 #define X(tag, emit) tag,
     ICEINSTX8632CMPPS_TABLE
 #undef X
     Cmpps_Invalid
   };
 
   static InstX8632Cmpps *create(Cfg *Func, Variable *Dest, Operand *Source,
                                 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, CmppsCond Cond);
   InstX8632Cmpps(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   InstX8632Cmpps &operator=(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmpps() {}
 
   CmppsCond Condition;
@@ skipping 74 matching lines @@
 };
 
 // cmp - Integer compare instruction.
 class InstX8632Icmp : public InstX8632 {
 public:
   static InstX8632Icmp *create(Cfg *Func, Operand *Src1, Operand *Src2) {
     return new (Func->allocate<InstX8632Icmp>())
         InstX8632Icmp(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, Icmp); }
 
 private:
   InstX8632Icmp(Cfg *Func, Operand *Src1, Operand *Src2);
   InstX8632Icmp(const InstX8632Icmp &) LLVM_DELETED_FUNCTION;
   InstX8632Icmp &operator=(const InstX8632Icmp &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Icmp() {}
 };
 
 // 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 108 matching lines @@
 
 // Movsx - copy from a narrower integer type to a wider integer
 // type, with sign extension.
 class InstX8632Movsx : public InstX8632 {
 public:
   static InstX8632Movsx *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movsx>())
         InstX8632Movsx(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, Movsx); }
 
 private:
   InstX8632Movsx(Cfg *Func, Variable *Dest, Operand *Source);
   InstX8632Movsx(const InstX8632Movsx &) LLVM_DELETED_FUNCTION;
   InstX8632Movsx &operator=(const InstX8632Movsx &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Movsx() {}
 };
 
 // Movsx - copy from a narrower integer type to a wider integer
 // type, with zero extension.
 class InstX8632Movzx : public InstX8632 {
 public:
   static InstX8632Movzx *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632Movzx>())
         InstX8632Movzx(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, Movzx); }
 
 private:
   InstX8632Movzx(Cfg *Func, Variable *Dest, Operand *Source);
   InstX8632Movzx(const InstX8632Movzx &) LLVM_DELETED_FUNCTION;
   InstX8632Movzx &operator=(const InstX8632Movzx &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Movzx() {}
 };
 
 // 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 64 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;
 
+// Same with emitIAS() methods.
+template <> void InstX8632Adc::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Add::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Addps::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Addss::emitIAS(const Cfg *Func) const;
+template <> void InstX8632And::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Cbwdq::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Divps::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Divss::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Mulps::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Mulss::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Or::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Sbb::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Sqrtss::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Sub::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Subps::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Subss::emitIAS(const Cfg *Func) const;
+template <> void InstX8632Xor::emitIAS(const Cfg *Func) const;
+
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H