src/share/vm/opto/divnode.hpp

@@ -41,11 +41,11 @@
 // On processors which don't naturally support this special case (e.g., x86),
 // the matcher or runtime system must take care of this.
 class DivINode : public Node {
 public:
   DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }

@@ -54,11 +54,11 @@
 //------------------------------DivLNode---------------------------------------
 // Long division
 class DivLNode : public Node {
 public:
   DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }

@@ -67,11 +67,11 @@
 //------------------------------DivFNode---------------------------------------
 // Float division
 class DivFNode : public Node {
 public:
   DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint ideal_reg() const { return Op_RegF; }

@@ -80,11 +80,11 @@
 //------------------------------DivDNode---------------------------------------
 // Double division
 class DivDNode : public Node {
 public:
   DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }

@@ -93,11 +93,11 @@
 //------------------------------ModINode---------------------------------------
 // Integer modulus
 class ModINode : public Node {
 public:
   ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };

@@ -105,11 +105,11 @@
 //------------------------------ModLNode---------------------------------------
 // Long modulus
 class ModLNode : public Node {
 public:
   ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };

@@ -117,22 +117,22 @@
 //------------------------------ModFNode---------------------------------------
 // Float Modulus
 class ModFNode : public Node {
 public:
   ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint ideal_reg() const { return Op_RegF; }
 };
 
 //------------------------------ModDNode---------------------------------------
 // Double Modulus
 class ModDNode : public Node {
 public:
   ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 

@@ -144,11 +144,11 @@
 public:
   enum {
     div_proj_num =  0,      // quotient
     mod_proj_num =  1       // remainder
   };
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; }
   virtual const Type* Value(PhaseGVN* phase)  const { return bottom_type(); }
   virtual uint hash() const { return Node::hash(); }
   virtual bool is_CFG() const  { return false; }

@@ -161,11 +161,11 @@
 //------------------------------DivModINode---------------------------------------
 // Integer division with remainder result.
 class DivModINode : public DivModNode {
 public:
   DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; }
   virtual Node *match( const ProjNode *proj, const Matcher *m );
 
   // Make a divmod and associated projections from a div or mod.
   static DivModINode* make(Node* div_or_mod);

@@ -174,11 +174,11 @@
 //------------------------------DivModLNode---------------------------------------
 // Long division with remainder result.
 class DivModLNode : public DivModNode {
 public:
   DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; }
   virtual Node *match( const ProjNode *proj, const Matcher *m );
 
   // Make a divmod and associated projections from a div or mod.
   static DivModLNode* make(Node* div_or_mod);