src/share/vm/opto/narrowptrnode.cpp

@@ -24,83 +24,83 @@
 
 #include "precompiled.hpp"
 #include "opto/narrowptrnode.hpp"
 #include "opto/phaseX.hpp"
 
-Node* DecodeNNode::Identity(PhaseTransform* phase) {
+Node* DecodeNNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
 
   if (in(1)->is_EncodeP()) {
     // (DecodeN (EncodeP p)) -> p
     return in(1)->in(1);
   }
   return this;
 }
 
-const Type *DecodeNNode::Value( PhaseTransform *phase ) const {
+const Type* DecodeNNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if (t == Type::TOP) return Type::TOP;
   if (t == TypeNarrowOop::NULL_PTR) return TypePtr::NULL_PTR;
 
   assert(t->isa_narrowoop(), "only  narrowoop here");
   return t->make_ptr();
 }
 
-Node* EncodePNode::Identity(PhaseTransform* phase) {
+Node* EncodePNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
 
   if (in(1)->is_DecodeN()) {
     // (EncodeP (DecodeN p)) -> p
     return in(1)->in(1);
   }
   return this;
 }
 
-const Type *EncodePNode::Value( PhaseTransform *phase ) const {
+const Type* EncodePNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if (t == Type::TOP) return Type::TOP;
   if (t == TypePtr::NULL_PTR) return TypeNarrowOop::NULL_PTR;
 
   assert(t->isa_oop_ptr(), "only oopptr here");
   return t->make_narrowoop();
 }
 
 
-Node* DecodeNKlassNode::Identity(PhaseTransform* phase) {
+Node* DecodeNKlassNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
 
   if (in(1)->is_EncodePKlass()) {
     // (DecodeNKlass (EncodePKlass p)) -> p
     return in(1)->in(1);
   }
   return this;
 }
 
-const Type *DecodeNKlassNode::Value( PhaseTransform *phase ) const {
+const Type* DecodeNKlassNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if (t == Type::TOP) return Type::TOP;
   assert(t != TypeNarrowKlass::NULL_PTR, "null klass?");
 
   assert(t->isa_narrowklass(), "only narrow klass ptr here");
   return t->make_ptr();
 }
 
-Node* EncodePKlassNode::Identity(PhaseTransform* phase) {
+Node* EncodePKlassNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
 
   if (in(1)->is_DecodeNKlass()) {
     // (EncodePKlass (DecodeNKlass p)) -> p
     return in(1)->in(1);
   }
   return this;
 }
 
-const Type *EncodePKlassNode::Value( PhaseTransform *phase ) const {
+const Type* EncodePKlassNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if (t == Type::TOP) return Type::TOP;
   assert (t != TypePtr::NULL_PTR, "null klass?");
 
   assert(UseCompressedClassPointers && t->isa_klassptr(), "only klass ptr here");