src/share/vm/opto/loopnode.hpp

@@ -119,11 +119,11 @@
     init_req(EntryControl, entry);
     init_req(LoopBackControl, backedge);
   }
 
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   bool can_be_counted_loop(PhaseTransform* phase) const {
     return req() == 3 && in(0) != NULL &&
       in(1) != NULL && phase->type(in(1)) != Type::TOP &&
       in(2) != NULL && phase->type(in(2)) != Type::TOP;
   }

@@ -196,11 +196,11 @@
     init_class_id(Class_CountedLoop);
     // Initialize _trip_count to the largest possible value.
     // Will be reset (lower) if the loop's trip count is known.
   }
 
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 
   Node *init_control() const { return in(EntryControl); }
   Node *back_control() const { return in(LoopBackControl); }
   CountedLoopEndNode *loopexit() const;

@@ -292,11 +292,11 @@
 
   CountedLoopEndNode( Node *control, Node *test, float prob, float cnt )
     : IfNode( control, test, prob, cnt) {
     init_class_id(Class_CountedLoopEnd);
   }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 
   Node *cmp_node() const            { return (in(TestValue)->req() >=2) ? in(TestValue)->in(1) : NULL; }
   Node *incr() const                { Node *tmp = cmp_node(); return (tmp && tmp->req()==3) ? tmp->in(1) : NULL; }
   Node *limit() const               { Node *tmp = cmp_node(); return (tmp && tmp->req()==3) ? tmp->in(2) : NULL; }
   Node *stride() const              { Node *tmp = incr    (); return (tmp && tmp->req()==3) ? tmp->in(2) : NULL; }

@@ -337,11 +337,11 @@
 
 inline CountedLoopEndNode *CountedLoopNode::loopexit() const {
   Node *bc = back_control();
   if( bc == NULL ) return NULL;
   Node *le = bc->in(0);
-  if( le->Opcode() != Op_CountedLoopEnd )
+  if( le->Opcode() != Opcodes::Op_CountedLoopEnd )
     return NULL;
   return (CountedLoopEndNode*)le;
 }
 inline Node *CountedLoopNode::init_trip() const { return loopexit() ? loopexit()->init_trip() : NULL; }
 inline Node *CountedLoopNode::stride() const { return loopexit() ? loopexit()->stride() : NULL; }

@@ -364,13 +364,13 @@
   LoopLimitNode( Compile* C, Node *init, Node *limit, Node *stride ) : Node(0,init,limit,stride) {
     // Put it on the Macro nodes list to optimize during macro nodes expansion.
     init_flags(Flag_is_macro);
     C->add_macro_node(this);
   }
-  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;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual Node* Identity(PhaseGVN* phase);
 };
 

@@ -957,11 +957,11 @@
   bool is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale, Node** p_offset, int depth = 0);
 
   // Create a new if above the uncommon_trap_if_pattern for the predicate to be promoted
   ProjNode* create_new_if_for_predicate(ProjNode* cont_proj, Node* new_entry,
                                         Deoptimization::DeoptReason reason,
-                                        int opcode);
+                                        Opcodes opcode);
   void register_control(Node* n, IdealLoopTree *loop, Node* pred);
 
   // Clone loop predicates to cloned loops (peeled, unswitched)
   static ProjNode* clone_predicate(ProjNode* predicate_proj, Node* new_entry,
                                    Deoptimization::DeoptReason reason,

@@ -1018,11 +1018,11 @@
 
   // Create a slow version of the loop by cloning the loop
   // and inserting an if to select fast-slow versions.
   ProjNode* create_slow_version_of_loop(IdealLoopTree *loop,
                                         Node_List &old_new,
-                                        int opcode);
+                                        Opcodes opcode);
 
   // Clone a loop and return the clone head (clone_loop_head).
   // Added nodes include int(1), int(0) - disconnected, If, IfTrue, IfFalse,
   // This routine was created for usage in CountedLoopReserveKit.
   //