src/share/vm/opto/movenode.hpp

@@ -54,85 +54,85 @@
 
 //------------------------------CMoveDNode-------------------------------------
 class CMoveDNode : public CMoveNode {
   public:
   CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
 //------------------------------CMoveFNode-------------------------------------
 class CMoveFNode : public CMoveNode {
   public:
   CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
 //------------------------------CMoveINode-------------------------------------
 class CMoveINode : public CMoveNode {
   public:
   CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
 //------------------------------CMoveLNode-------------------------------------
 class CMoveLNode : public CMoveNode {
   public:
   CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 //------------------------------CMovePNode-------------------------------------
 class CMovePNode : public CMoveNode {
   public:
   CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 //------------------------------CMoveNNode-------------------------------------
 class CMoveNNode : public CMoveNode {
   public:
   CMoveNNode( Node *c, Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 //
 class MoveI2FNode : public Node {
   public:
   MoveI2FNode( Node *value ) : Node(0,value) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
-  virtual uint ideal_reg() const { return Op_RegF; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegF; }
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveL2DNode : public Node {
   public:
   MoveL2DNode( Node *value ) : Node(0,value) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
-  virtual uint ideal_reg() const { return Op_RegD; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; }
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveF2INode : public Node {
   public:
   MoveF2INode( Node *value ) : Node(0,value) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual uint ideal_reg() const { return Op_RegI; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; }
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveD2LNode : public Node {
   public:
   MoveD2LNode( Node *value ) : Node(0,value) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
-  virtual uint ideal_reg() const { return Op_RegL; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegL; }
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------BinaryNode-------------------------------------
 // Place holder for the 2 conditional inputs to a CMove.  CMove needs 4

@@ -141,12 +141,12 @@
 // binary tree so we break it down like this:
 //     (CMove (Binary bol cmp) (Binary src1 src2))
 class BinaryNode : public Node {
   public:
   BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { }
-  virtual int Opcode() const;
-  virtual uint ideal_reg() const { return 0; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_Node; }
 
 #ifndef PRODUCT
   virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const;
 #endif
 };