Lift register and condition code enums out into their own file.

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 "IceDefs.h"
 #include "IceInst.h"
+#include "IceConditionCodesX8632.h"
 #include "IceInstX8632.def"
 #include "IceOperand.h"
 
 namespace Ice {
 
 class TargetX8632;
 
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
 // OperandX8632Mem and VariableSplit.
 class OperandX8632 : public Operand {
@@ skipping 186 matching lines @@
     Subps,
     Subss,
     Test,
     Ucomiss,
     UD2,
     Xadd,
     Xchg,
     Xor
   };
 
-  enum BrCond {
-#define X(tag, opp, 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 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 57 matching lines @@
   InstX8632Label &operator=(const InstX8632Label &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Label() {}
   SizeT Number; // used only for unique label string generation
 };
 
 // Conditional and unconditional branch instruction.
 class InstX8632Br : public InstX8632 {
 public:
   // Create a conditional branch to a node.
   static InstX8632Br *create(Cfg *Func, CfgNode *TargetTrue,
-                             CfgNode *TargetFalse, BrCond Condition) {
+                             CfgNode *TargetFalse, CondX86::BrCond Condition) {
     const InstX8632Label *NoLabel = NULL;
     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 = NULL;
     const InstX8632Label *NoLabel = NULL;
     return new (Func->allocate<InstX8632Br>())
-        InstX8632Br(Func, NoCondTarget, Target, NoLabel, Br_None);
+        InstX8632Br(Func, NoCondTarget, Target, NoLabel, CondX86::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, BrCond Condition) {
+  static InstX8632Br *create(Cfg *Func, CfgNode *Target,
+                             CondX86::BrCond Condition) {
     const CfgNode *NoUncondTarget = NULL;
     const InstX8632Label *NoLabel = NULL;
     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,
-                             BrCond Condition) {
+                             CondX86::BrCond Condition) {
     const CfgNode *NoCondTarget = NULL;
     const CfgNode *NoUncondTarget = NULL;
     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);
   virtual uint32_t getEmitInstCount() const {
     uint32_t Sum = 0;
     if (Label)
       ++Sum;
     if (getTargetTrue())
       ++Sum;
     if (getTargetFalse())
       ++Sum;
     return Sum;
   }
   virtual void emit(const Cfg *Func) const;
   virtual void dump(const Cfg *Func) const;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Br); }
 
 private:
   InstX8632Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
-              const InstX8632Label *Label, BrCond Condition);
+              const InstX8632Label *Label, CondX86::BrCond Condition);
   InstX8632Br(const InstX8632Br &) LLVM_DELETED_FUNCTION;
   InstX8632Br &operator=(const InstX8632Br &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Br() {}
-  BrCond Condition;
+  CondX86::BrCond Condition;
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstX8632Label *Label; // Intra-block branch target
 };
 
 // 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) {
@@ skipping 398 matching lines @@
                 Variable *Source2);
   InstX8632Shrd(const InstX8632Shrd &) LLVM_DELETED_FUNCTION;
   InstX8632Shrd &operator=(const InstX8632Shrd &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Shrd() {}
 };
 
 // Conditional move instruction.
 class InstX8632Cmov : public InstX8632 {
 public:
   static InstX8632Cmov *create(Cfg *Func, Variable *Dest, Operand *Source,
-                               BrCond Cond) {
+                               CondX86::BrCond Cond) {
     return new (Func->allocate<InstX8632Cmov>())
         InstX8632Cmov(Func, Dest, Source, Cond);
   }
   virtual void emit(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(Cfg *Func, Variable *Dest, Operand *Source,
+                CondX86::BrCond Cond);
   InstX8632Cmov(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   InstX8632Cmov &operator=(const InstX8632Cmov &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmov() {}
 
-  BrCond Condition;
+  CondX86::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) {
+                                CondX86::CmppsCond Condition) {
     return new (Func->allocate<InstX8632Cmpps>())
         InstX8632Cmpps(Func, Dest, Source, Condition);
   }
   virtual void emit(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(Cfg *Func, Variable *Dest, Operand *Source,
+                 CondX86::CmppsCond Cond);
   InstX8632Cmpps(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   InstX8632Cmpps &operator=(const InstX8632Cmpps &) LLVM_DELETED_FUNCTION;
   virtual ~InstX8632Cmpps() {}
 
-  CmppsCond Condition;
+  CondX86::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 {
 public:
   static InstX8632Cmpxchg *create(Cfg *Func, Operand *DestOrAddr, Variable *Eax,
@@ skipping 427 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