Move X8632-specific Assembler stuff to Machine Traits.

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - x86-32 machine 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 "IceAssemblerX8632.h"
 #include "IceConditionCodesX8632.h"
 #include "IceDefs.h"
 #include "IceInst.h"
 #include "IceInstX8632.def"
 #include "IceOperand.h"
+#include "IceTargetLoweringX8632Traits.h"
 
 namespace Ice {
 
 class TargetX8632;
 
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
 // OperandX8632Mem and VariableSplit.
 class OperandX8632 : public Operand {
   OperandX8632() = delete;
   OperandX8632(const OperandX8632 &) = delete;
@@ skipping 34 matching lines @@
                                  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; }
   void emitSegmentOverride(X8632::AssemblerX8632 *Asm) const;
-  X8632::Address toAsmAddress(Assembler *Asm) const;
+  X8632::Traits::Address toAsmAddress(Assembler *Asm) const;
   void emit(const Cfg *Func) const override;
   using OperandX8632::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == static_cast<OperandKind>(kMem);
   }
 
   void setRandomized(bool R) { Randomized = R; }
 
@@ skipping 25 matching lines @@
   VariableSplit(const VariableSplit &) = delete;
   VariableSplit &operator=(const VariableSplit &) = delete;
 
 public:
   enum Portion { Low, High };
   static VariableSplit *create(Cfg *Func, Variable *Var, Portion Part) {
     return new (Func->allocate<VariableSplit>()) VariableSplit(Func, Var, Part);
   }
   int32_t getOffset() const { return Part == High ? 4 : 0; }
 
-  X8632::Address toAsmAddress(const Cfg *Func) const;
+  X8632::Traits::Address toAsmAddress(const Cfg *Func) const;
   void emit(const Cfg *Func) const override;
   using OperandX8632::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == static_cast<OperandKind>(kSplit);
   }
 
 private:
   VariableSplit(Cfg *Func, Variable *Var, Portion Part)
@@ skipping 136 matching lines @@
     Ucomiss,
     UD2,
     Xadd,
     Xchg,
     Xor,
     XorRMW
   };
 
   static const char *getWidthString(Type Ty);
   static const char *getFldString(Type Ty);
-  static CondX86::BrCond getOppositeCondition(CondX86::BrCond Cond);
+  static X8632::Traits::Cond::BrCond
+  getOppositeCondition(X8632::Traits::Cond::BrCond Cond);
   void dump(const Cfg *Func) const override;
 
   // Shared emit routines for common forms of instructions.
   // See the definition of emitTwoAddress() for a description of
   // ShiftHack.
   static void emitTwoAddress(const char *Opcode, const Inst *Inst,
                              const Cfg *Func, bool ShiftHack = false);
 
   static void
   emitIASGPRShift(const Cfg *Func, Type Ty, const Variable *Var,
@@ skipping 128 matching lines @@
 
 // Conditional and unconditional branch instruction.
 class InstX8632Br : public InstX8632 {
   InstX8632Br() = delete;
   InstX8632Br(const InstX8632Br &) = delete;
   InstX8632Br &operator=(const InstX8632Br &) = delete;
 
 public:
   // Create a conditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *TargetTrue,
-                             CfgNode *TargetFalse, CondX86::BrCond Condition) {
-    assert(Condition != CondX86::Br_None);
+                             CfgNode *TargetFalse,
+                             X8632::Traits::Cond::BrCond Condition) {
+    assert(Condition != X8632::Traits::Cond::Br_None);
     const InstX8632Label *NoLabel = nullptr;
     return new (Func->allocate<InstX8632Br>())
         InstX8632Br(Func, TargetTrue, TargetFalse, NoLabel, Condition);
   }
   // Create an unconditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *Target) {
     const CfgNode *NoCondTarget = nullptr;
     const InstX8632Label *NoLabel = nullptr;
-    return new (Func->allocate<InstX8632Br>())
-        InstX8632Br(Func, NoCondTarget, Target, NoLabel, CondX86::Br_None);
+    return new (Func->allocate<InstX8632Br>()) InstX8632Br(
+        Func, NoCondTarget, Target, NoLabel, X8632::Traits::Cond::Br_None);
   }
   // Create a non-terminator conditional branch to a node, with a
   // fallthrough to the next instruction in the current node.  This is
   // used for switch lowering.
   static InstX8632Br *create(Cfg *Func, CfgNode *Target,
-                             CondX86::BrCond Condition) {
-    assert(Condition != CondX86::Br_None);
+                             X8632::Traits::Cond::BrCond Condition) {
+    assert(Condition != X8632::Traits::Cond::Br_None);
     const CfgNode *NoUncondTarget = nullptr;
     const InstX8632Label *NoLabel = nullptr;
     return new (Func->allocate<InstX8632Br>())
         InstX8632Br(Func, Target, NoUncondTarget, NoLabel, Condition);
   }
   // Create a conditional intra-block branch (or unconditional, if
   // Condition==Br_None) to a label in the current block.
   static InstX8632Br *create(Cfg *Func, InstX8632Label *Label,
-                             CondX86::BrCond Condition) {
+                             X8632::Traits::Cond::BrCond Condition) {
     const CfgNode *NoCondTarget = nullptr;
     const CfgNode *NoUncondTarget = nullptr;
     return new (Func->allocate<InstX8632Br>())
         InstX8632Br(Func, NoCondTarget, NoUncondTarget, Label, Condition);
   }
   const CfgNode *getTargetTrue() const { return TargetTrue; }
   const CfgNode *getTargetFalse() const { return TargetFalse; }
   bool optimizeBranch(const CfgNode *NextNode);
   uint32_t getEmitInstCount() const override {
     uint32_t Sum = 0;
     if (Label)
       ++Sum;
     if (getTargetTrue())
       ++Sum;
     if (getTargetFalse())
       ++Sum;
     return Sum;
   }
   bool isUnconditionalBranch() const override {
-    return !Label && Condition == CondX86::Br_None;
+    return !Label && Condition == X8632::Traits::Cond::Br_None;
   }
   bool repointEdge(CfgNode *OldNode, CfgNode *NewNode) override;
   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, Br); }
 
 private:
   InstX8632Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
-              const InstX8632Label *Label, CondX86::BrCond Condition);
+              const InstX8632Label *Label,
+              X8632::Traits::Cond::BrCond Condition);
 
-  CondX86::BrCond Condition;
+  X8632::Traits::Cond::BrCond Condition;
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstX8632Label *Label; // Intra-block branch target
 };
 
 // Jump to a target outside this function, such as tailcall, nacljump,
 // naclret, unreachable.  This is different from a Branch instruction
 // in that there is no intra-function control flow to represent.
 class InstX8632Jmp : public InstX8632 {
   InstX8632Jmp() = delete;
@@ skipping 748 matching lines @@
 };
 
 // Conditional move instruction.
 class InstX8632Cmov : public InstX8632 {
   InstX8632Cmov() = delete;
   InstX8632Cmov(const InstX8632Cmov &) = delete;
   InstX8632Cmov &operator=(const InstX8632Cmov &) = delete;
 
 public:
   static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
-                               CondX86::BrCond Cond) {
+                               X8632::Traits::Cond::BrCond Cond) {
     return new (Func->allocate<InstX8632Cmov>())
         InstX8632Cmov(Func, Dest, Source, Cond);
   }
   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, Cmov); }
 
 private:
   InstX8632Cmov(Cfg *Func, Variable *Dest, Operand *Source,
-                CondX86::BrCond Cond);
+                X8632::Traits::Cond::BrCond Cond);
 
-  CondX86::BrCond Condition;
+  X8632::Traits::Cond::BrCond Condition;
 };
 
 // Cmpps instruction - compare packed singled-precision floating point
 // values
 class InstX8632Cmpps : public InstX8632 {
   InstX8632Cmpps() = delete;
   InstX8632Cmpps(const InstX8632Cmpps &) = delete;
   InstX8632Cmpps &operator=(const InstX8632Cmpps &) = delete;
 
 public:
   static InstX8632Cmpps *create(Cfg *Func, Variable *Dest, Operand *Source,
-                                CondX86::CmppsCond Condition) {
+                                X8632::Traits::Cond::CmppsCond Condition) {
     return new (Func->allocate<InstX8632Cmpps>())
         InstX8632Cmpps(Func, Dest, Source, Condition);
   }
   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, Cmpps); }
 
 private:
   InstX8632Cmpps(Cfg *Func, Variable *Dest, Operand *Source,
-                 CondX86::CmppsCond Cond);
+                 X8632::Traits::Cond::CmppsCond Cond);
 
-  CondX86::CmppsCond Condition;
+  X8632::Traits::Cond::CmppsCond Condition;
 };
 
 // Cmpxchg instruction - cmpxchg <dest>, <desired> will compare if <dest>
 // equals eax. If so, the ZF is set and <desired> is stored in <dest>.
 // If not, ZF is cleared and <dest> is copied to eax (or subregister).
 // <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 {
   InstX8632Cmpxchg() = delete;
   InstX8632Cmpxchg(const InstX8632Cmpxchg &) = delete;
@@ skipping 355 matching lines @@
 };
 
 // Conditional set-byte instruction.
 class InstX8632Setcc : public InstX8632 {
   InstX8632Setcc() = delete;
   InstX8632Setcc(const InstX8632Cmov &) = delete;
   InstX8632Setcc &operator=(const InstX8632Setcc &) = delete;
 
 public:
   static InstX8632Setcc *create(Cfg *Func, Variable *Dest,
-                                CondX86::BrCond Cond) {
+                                X8632::Traits::Cond::BrCond Cond) {
     return new (Func->allocate<InstX8632Setcc>())
         InstX8632Setcc(Func, Dest, Cond);
   }
   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, Setcc); }
 
 private:
-  InstX8632Setcc(Cfg *Func, Variable *Dest, CondX86::BrCond Cond);
+  InstX8632Setcc(Cfg *Func, Variable *Dest, X8632::Traits::Cond::BrCond Cond);
 
-  const CondX86::BrCond Condition;
+  const X8632::Traits::Cond::BrCond Condition;
 };
 
 // Exchanging Add instruction.  Exchanges the first operand (destination
 // operand) with the second operand (source operand), then loads the sum
 // of the two values into the destination operand. The destination may be
 // a register or memory, while the source must be a register.
 //
 // Both the dest and source are updated. The caller should then insert a
 // FakeDef to reflect the second udpate.
 class InstX8632Xadd : public InstX8632Lockable {
@@ skipping 81 matching lines @@
 template <> void InstX8632Pinsr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movsx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movzx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pshufd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Shufps::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H