src/share/vm/opto/callnode.cpp

@@ -47,11 +47,11 @@
 //=============================================================================
 uint StartNode::size_of() const { return sizeof(*this); }
 uint StartNode::cmp( const Node &n ) const
 { return _domain == ((StartNode&)n)._domain; }
 const Type *StartNode::bottom_type() const { return _domain; }
-const Type *StartNode::Value(PhaseTransform *phase) const { return _domain; }
+const Type* StartNode::Value(PhaseGVN* phase) const { return _domain; }
 #ifndef PRODUCT
 void StartNode::dump_spec(outputStream *st) const { st->print(" #"); _domain->dump_on(st);}
 void StartNode::dump_compact_spec(outputStream *st) const { /* empty */ }
 #endif
 

@@ -171,11 +171,11 @@
 
 Node *ReturnNode::Ideal(PhaseGVN *phase, bool can_reshape){
   return remove_dead_region(phase, can_reshape) ? this : NULL;
 }
 
-const Type *ReturnNode::Value( PhaseTransform *phase ) const {
+const Type* ReturnNode::Value(PhaseGVN* phase) const {
   return ( phase->type(in(TypeFunc::Control)) == Type::TOP)
     ? Type::TOP
     : Type::BOTTOM;
 }
 

@@ -216,11 +216,11 @@
 
 Node *RethrowNode::Ideal(PhaseGVN *phase, bool can_reshape){
   return remove_dead_region(phase, can_reshape) ? this : NULL;
 }
 
-const Type *RethrowNode::Value( PhaseTransform *phase ) const {
+const Type* RethrowNode::Value(PhaseGVN* phase) const {
   return (phase->type(in(TypeFunc::Control)) == Type::TOP)
     ? Type::TOP
     : Type::BOTTOM;
 }
 

@@ -683,11 +683,11 @@
   if (jvms() != NULL)  jvms()->dump_spec(st);
 }
 #endif
 
 const Type *CallNode::bottom_type() const { return tf()->range(); }
-const Type *CallNode::Value(PhaseTransform *phase) const {
+const Type* CallNode::Value(PhaseGVN* phase) const {
   if (phase->type(in(0)) == Type::TOP)  return Type::TOP;
   return tf()->range();
 }
 
 //------------------------------calling_convention-----------------------------

@@ -1131,11 +1131,11 @@
   return remove_dead_region(phase, can_reshape) ? this : NULL;
 }
 
 //------------------------------Identity---------------------------------------
 // Remove obviously duplicate safepoints
-Node *SafePointNode::Identity( PhaseTransform *phase ) {
+Node* SafePointNode::Identity(PhaseGVN* phase) {
 
   // If you have back to back safepoints, remove one
   if( in(TypeFunc::Control)->is_SafePoint() )
     return in(TypeFunc::Control);
 

@@ -1154,11 +1154,11 @@
 
   return this;
 }
 
 //------------------------------Value------------------------------------------
-const Type *SafePointNode::Value( PhaseTransform *phase ) const {
+const Type* SafePointNode::Value(PhaseGVN* phase) const {
   if( phase->type(in(0)) == Type::TOP ) return Type::TOP;
   if( phase->eqv( in(0), this ) ) return Type::TOP; // Dead infinite loop
   return Type::CONTROL;
 }