src/share/vm/opto/divnode.hpp

@@ -42,63 +42,63 @@
 // 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 Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 
 //------------------------------DivLNode---------------------------------------
 // Long division
 class DivLNode : public Node {
 public:
   DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 
 //------------------------------DivFNode---------------------------------------
 // Float division
 class DivFNode : public Node {
 public:
   DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {}
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) 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; }
 };
 
 //------------------------------DivDNode---------------------------------------
 // Double division
 class DivDNode : public Node {
 public:
   DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {}
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) 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; }
 };
 
 //------------------------------ModINode---------------------------------------
 // Integer modulus
 class ModINode : public Node {
 public:
   ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) 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; }
 };
 

@@ -106,11 +106,11 @@
 // Long modulus
 class ModLNode : public Node {
 public:
   ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) 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; }
 };
 

@@ -118,22 +118,22 @@
 // Float Modulus
 class ModFNode : public Node {
 public:
   ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) 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 const Type *Value( PhaseTransform *phase ) 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; }
 };
 
 //------------------------------DivModNode---------------------------------------

@@ -145,13 +145,13 @@
   enum {
     div_proj_num =  0,      // quotient
     mod_proj_num =  1       // remainder
   };
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase ) { return this; }
+  virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; }
-  virtual const Type *Value( PhaseTransform *phase ) const { return bottom_type(); }
+  virtual const Type* Value(PhaseGVN* phase)  const { return bottom_type(); }
   virtual uint hash() const { return Node::hash(); }
   virtual bool is_CFG() const  { return false; }
   virtual uint ideal_reg() const { return NotAMachineReg; }
 
   ProjNode* div_proj() { return proj_out(div_proj_num); }