changeset 35555:06982bbaaa22

Merge
author kshefov
date Tue, 12 Jan 2016 15:07:46 +0100
parents c9184290875c be1bff8945dc
children a5fe2691c0e5
files
diffstat 44 files changed, 338 insertions(+), 329 deletions(-) [+]
line wrap: on
line diff
--- a/hotspot/src/share/vm/opto/addnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/addnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -52,7 +52,7 @@
 
 //------------------------------Identity---------------------------------------
 // If either input is a constant 0, return the other input.
-Node *AddNode::Identity( PhaseTransform *phase ) {
+Node* AddNode::Identity(PhaseGVN* phase) {
   const Type *zero = add_id();  // The additive identity
   if( phase->type( in(1) )->higher_equal( zero ) ) return in(2);
   if( phase->type( in(2) )->higher_equal( zero ) ) return in(1);
@@ -204,7 +204,7 @@
 //------------------------------Value-----------------------------------------
 // An add node sums it's two _in.  If one input is an RSD, we must mixin
 // the other input's symbols.
-const Type *AddNode::Value( PhaseTransform *phase ) const {
+const Type* AddNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -326,7 +326,7 @@
 
 //------------------------------Identity---------------------------------------
 // Fold (x-y)+y  OR  y+(x-y)  into  x
-Node *AddINode::Identity( PhaseTransform *phase ) {
+Node* AddINode::Identity(PhaseGVN* phase) {
   if( in(1)->Opcode() == Op_SubI && phase->eqv(in(1)->in(2),in(2)) ) {
     return in(1)->in(1);
   }
@@ -443,7 +443,7 @@
 
 //------------------------------Identity---------------------------------------
 // Fold (x-y)+y  OR  y+(x-y)  into  x
-Node *AddLNode::Identity( PhaseTransform *phase ) {
+Node* AddLNode::Identity(PhaseGVN* phase) {
   if( in(1)->Opcode() == Op_SubL && phase->eqv(in(1)->in(2),in(2)) ) {
     return in(1)->in(1);
   }
@@ -561,7 +561,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If one input is a constant 0, return the other input.
-Node *AddPNode::Identity( PhaseTransform *phase ) {
+Node* AddPNode::Identity(PhaseGVN* phase) {
   return ( phase->type( in(Offset) )->higher_equal( TypeX_ZERO ) ) ? in(Address) : this;
 }
 
@@ -659,7 +659,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *AddPNode::Value( PhaseTransform *phase ) const {
+const Type* AddPNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(Address) );
   const Type *t2 = phase->type( in(Offset) );
@@ -733,7 +733,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *OrINode::Identity( PhaseTransform *phase ) {
+Node* OrINode::Identity(PhaseGVN* phase) {
   // x | x => x
   if (phase->eqv(in(1), in(2))) {
     return in(1);
@@ -774,7 +774,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *OrLNode::Identity( PhaseTransform *phase ) {
+Node* OrLNode::Identity(PhaseGVN* phase) {
   // x | x => x
   if (phase->eqv(in(1), in(2))) {
     return in(1);
--- a/hotspot/src/share/vm/opto/addnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/addnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -47,7 +47,7 @@
 
   // Handle algebraic identities here.  If we have an identity, return the Node
   // we are equivalent to.  We look for "add of zero" as an identity.
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // We also canonicalize the Node, moving constants to the right input,
   // and flatten expressions (so that 1+x+2 becomes x+3).
@@ -55,7 +55,7 @@
 
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   // Check if this addition involves the additive identity
   virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
@@ -80,7 +80,7 @@
   virtual const Type *add_id() const { return TypeInt::ZERO; }
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 
@@ -94,7 +94,7 @@
   virtual const Type *add_id() const { return TypeLong::ZERO; }
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 
@@ -109,7 +109,7 @@
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeF::ZERO; }
   virtual const Type *bottom_type() const { return Type::FLOAT; }
-  virtual Node *Identity( PhaseTransform *phase ) { return this; }
+  virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual uint ideal_reg() const { return Op_RegF; }
 };
 
@@ -124,7 +124,7 @@
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeD::ZERO; }
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
-  virtual Node *Identity( PhaseTransform *phase ) { return this; }
+  virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 
@@ -142,9 +142,9 @@
     init_class_id(Class_AddP);
   }
   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;
   virtual uint  ideal_reg() const { return Op_RegP; }
   Node         *base_node() { assert( req() > Base, "Missing base"); return in(Base); }
@@ -170,7 +170,7 @@
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeInt::ZERO; }
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 
@@ -184,7 +184,7 @@
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeLong::ZERO; }
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 
--- a/hotspot/src/share/vm/opto/callnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/callnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -49,7 +49,7 @@
 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 */ }
@@ -173,7 +173,7 @@
   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;
@@ -218,7 +218,7 @@
   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;
@@ -685,7 +685,7 @@
 #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();
 }
@@ -1133,7 +1133,7 @@
 
 //------------------------------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() )
@@ -1156,7 +1156,7 @@
 }
 
 //------------------------------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;
--- a/hotspot/src/share/vm/opto/callnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/callnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -76,7 +76,7 @@
   virtual bool pinned() const { return true; };
   virtual const Type *bottom_type() const;
   virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual void  calling_convention( BasicType* sig_bt, VMRegPair *parm_reg, uint length ) const;
   virtual const RegMask &in_RegMask(uint) const;
@@ -127,7 +127,7 @@
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
   virtual bool depends_only_on_test() const { return false; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint ideal_reg() const { return NotAMachineReg; }
   virtual uint match_edge(uint idx) const;
 #ifndef PRODUCT
@@ -148,7 +148,7 @@
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
   virtual bool depends_only_on_test() const { return false; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint match_edge(uint idx) const;
   virtual uint ideal_reg() const { return NotAMachineReg; }
 #ifndef PRODUCT
@@ -465,11 +465,11 @@
   // Standard Node stuff
   virtual int            Opcode() const;
   virtual bool           pinned() const { return true; }
-  virtual const Type    *Value( PhaseTransform *phase ) const;
+  virtual const Type*    Value(PhaseGVN* phase) const;
   virtual const Type    *bottom_type() const { return Type::CONTROL; }
   virtual const TypePtr *adr_type() const { return _adr_type; }
   virtual Node          *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node          *Identity( PhaseTransform *phase );
+  virtual Node*          Identity(PhaseGVN* phase);
   virtual uint           ideal_reg() const { return 0; }
   virtual const RegMask &in_RegMask(uint) const;
   virtual const RegMask &out_RegMask() const;
@@ -593,9 +593,9 @@
   void set_generator(CallGenerator* cg) { _generator = cg; }
 
   virtual const Type *bottom_type() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase ) { return this; }
+  virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual uint        cmp( const Node &n ) const;
   virtual uint        size_of() const = 0;
   virtual void        calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
--- a/hotspot/src/share/vm/opto/castnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/castnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -34,7 +34,7 @@
 
 //=============================================================================
 // If input is already higher or equal to cast type, then this is an identity.
-Node *ConstraintCastNode::Identity(PhaseTransform *phase) {
+Node* ConstraintCastNode::Identity(PhaseGVN* phase) {
   Node* dom = dominating_cast(phase);
   if (dom != NULL) {
     assert(_carry_dependency, "only for casts that carry a dependency");
@@ -48,7 +48,7 @@
 
 //------------------------------Value------------------------------------------
 // Take 'join' of input and cast-up type
-const Type *ConstraintCastNode::Value(PhaseTransform *phase) const {
+const Type* ConstraintCastNode::Value(PhaseGVN* phase) const {
   if (in(0) && phase->type(in(0)) == Type::TOP) return Type::TOP;
   const Type* ft = phase->type(in(1))->filter_speculative(_type);
 
@@ -149,7 +149,7 @@
 }
 #endif
 
-const Type *CastIINode::Value(PhaseTransform *phase) const {
+const Type* CastIINode::Value(PhaseGVN* phase) const {
   const Type *res = ConstraintCastNode::Value(phase);
 
   // Try to improve the type of the CastII if we recognize a CmpI/If
@@ -280,7 +280,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If input is already higher or equal to cast type, then this is an identity.
-Node *CheckCastPPNode::Identity( PhaseTransform *phase ) {
+Node* CheckCastPPNode::Identity(PhaseGVN* phase) {
   Node* dom = dominating_cast(phase);
   if (dom != NULL) {
     assert(_carry_dependency, "only for casts that carry a dependency");
@@ -296,7 +296,7 @@
 
 //------------------------------Value------------------------------------------
 // Take 'join' of input and cast-up type, unless working with an Interface
-const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {
+const Type* CheckCastPPNode::Value(PhaseGVN* phase) const {
   if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
 
   const Type *inn = phase->type(in(1));
@@ -379,7 +379,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *CastX2PNode::Value( PhaseTransform *phase ) const {
+const Type* CastX2PNode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   if (t->base() == Type_X && t->singleton()) {
@@ -443,14 +443,14 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *CastX2PNode::Identity( PhaseTransform *phase ) {
+Node* CastX2PNode::Identity(PhaseGVN* phase) {
   if (in(1)->Opcode() == Op_CastP2X)  return in(1)->in(1);
   return this;
 }
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *CastP2XNode::Value( PhaseTransform *phase ) const {
+const Type* CastP2XNode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   if (t->base() == Type::RawPtr && t->singleton()) {
@@ -465,7 +465,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *CastP2XNode::Identity( PhaseTransform *phase ) {
+Node* CastP2XNode::Identity(PhaseGVN* phase) {
   if (in(1)->Opcode() == Op_CastX2P)  return in(1)->in(1);
   return this;
 }
--- a/hotspot/src/share/vm/opto/castnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/castnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -44,8 +44,8 @@
     init_class_id(Class_ConstraintCast);
     init_req(1, n);
   }
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual int Opcode() const;
   virtual uint ideal_reg() const = 0;
@@ -67,7 +67,7 @@
     : ConstraintCastNode(n, t, carry_dependency) {}
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
@@ -92,8 +92,8 @@
     init_req(0, c);
   }
 
-  virtual Node *Identity(PhaseTransform *phase);
-  virtual const Type *Value(PhaseTransform *phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int   Opcode() const;
   virtual uint  ideal_reg() const { return Op_RegP; }
 };
@@ -105,9 +105,9 @@
   public:
   CastX2PNode( Node *n ) : Node(NULL, n) {}
   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 Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegP; }
   virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
 };
@@ -119,9 +119,9 @@
   public:
   CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {}
   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 Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint ideal_reg() const { return Op_RegX; }
   virtual const Type *bottom_type() const { return TypeX_X; }
   // Return false to keep node from moving away from an associated card mark.
--- a/hotspot/src/share/vm/opto/cfgnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/cfgnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -48,7 +48,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Compute the type of the RegionNode.
-const Type *RegionNode::Value( PhaseTransform *phase ) const {
+const Type* RegionNode::Value(PhaseGVN* phase) const {
   for( uint i=1; i<req(); ++i ) {       // For all paths in
     Node *n = in(i);            // Get Control source
     if( !n ) continue;          // Missing inputs are TOP
@@ -60,7 +60,7 @@
 
 //------------------------------Identity---------------------------------------
 // Check for Region being Identity.
-Node *RegionNode::Identity( PhaseTransform *phase ) {
+Node* RegionNode::Identity(PhaseGVN* phase) {
   // Cannot have Region be an identity, even if it has only 1 input.
   // Phi users cannot have their Region input folded away for them,
   // since they need to select the proper data input
@@ -892,7 +892,7 @@
 
 //------------------------------Value------------------------------------------
 // Compute the type of the PhiNode
-const Type *PhiNode::Value( PhaseTransform *phase ) const {
+const Type* PhiNode::Value(PhaseGVN* phase) const {
   Node *r = in(0);              // RegionNode
   if( !r )                      // Copy or dead
     return in(1) ? phase->type(in(1)) : Type::TOP;
@@ -1145,7 +1145,7 @@
 
 //------------------------------Identity---------------------------------------
 // Check for Region being Identity.
-Node *PhiNode::Identity( PhaseTransform *phase ) {
+Node* PhiNode::Identity(PhaseGVN* phase) {
   // Check for no merging going on
   // (There used to be special-case code here when this->region->is_Loop.
   // It would check for a tributary phi on the backedge that the main phi
@@ -2069,13 +2069,13 @@
 
 
 //=============================================================================
-const Type *GotoNode::Value( PhaseTransform *phase ) const {
+const Type* GotoNode::Value(PhaseGVN* phase) const {
   // If the input is reachable, then we are executed.
   // If the input is not reachable, then we are not executed.
   return phase->type(in(0));
 }
 
-Node *GotoNode::Identity( PhaseTransform *phase ) {
+Node* GotoNode::Identity(PhaseGVN* phase) {
   return in(0);                // Simple copy of incoming control
 }
 
@@ -2137,7 +2137,7 @@
 //------------------------------Value------------------------------------------
 // Compute the type of the PCTableNode.  If reachable it is a tuple of
 // Control, otherwise the table targets are not reachable
-const Type *PCTableNode::Value( PhaseTransform *phase ) const {
+const Type* PCTableNode::Value(PhaseGVN* phase) const {
   if( phase->type(in(0)) == Type::CONTROL )
     return bottom_type();
   return Type::TOP;             // All paths dead?  Then so are we
@@ -2182,7 +2182,7 @@
 //------------------------------Value------------------------------------------
 // Check for being unreachable, or for coming from a Rethrow.  Rethrow's cannot
 // have the default "fall_through_index" path.
-const Type *CatchNode::Value( PhaseTransform *phase ) const {
+const Type* CatchNode::Value(PhaseGVN* phase) const {
   // Unreachable?  Then so are all paths from here.
   if( phase->type(in(0)) == Type::TOP ) return Type::TOP;
   // First assume all paths are reachable
@@ -2226,7 +2226,7 @@
 
 //------------------------------Identity---------------------------------------
 // If only 1 target is possible, choose it if it is the main control
-Node *CatchProjNode::Identity( PhaseTransform *phase ) {
+Node* CatchProjNode::Identity(PhaseGVN* phase) {
   // If my value is control and no other value is, then treat as ID
   const TypeTuple *t = phase->type(in(0))->is_tuple();
   if (t->field_at(_con) != Type::CONTROL)  return this;
@@ -2269,7 +2269,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // Check for CreateEx being Identity.
-Node *CreateExNode::Identity( PhaseTransform *phase ) {
+Node* CreateExNode::Identity(PhaseGVN* phase) {
   if( phase->type(in(1)) == Type::TOP ) return in(1);
   if( phase->type(in(0)) == Type::TOP ) return in(0);
   // We only come from CatchProj, unless the CatchProj goes away.
@@ -2285,7 +2285,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Check for being unreachable.
-const Type *NeverBranchNode::Value( PhaseTransform *phase ) const {
+const Type* NeverBranchNode::Value(PhaseGVN* phase) const {
   if (!in(0) || in(0)->is_top()) return Type::TOP;
   return bottom_type();
 }
--- a/hotspot/src/share/vm/opto/cfgnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/cfgnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -91,8 +91,8 @@
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
   virtual bool depends_only_on_test() const { return false; }
   virtual const Type *bottom_type() const { return Type::CONTROL; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const RegMask &out_RegMask() const;
   bool try_clean_mem_phi(PhaseGVN *phase);
@@ -205,8 +205,8 @@
            type()->higher_equal(tp);
   }
 
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const RegMask &out_RegMask() const;
   virtual const RegMask &in_RegMask(uint) const;
@@ -234,8 +234,8 @@
   virtual const Node *is_block_proj() const { return this; }
   virtual bool depends_only_on_test() const { return false; }
   virtual const Type *bottom_type() const { return Type::CONTROL; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const RegMask &out_RegMask() const;
 
 #ifndef PRODUCT
@@ -384,7 +384,7 @@
   virtual bool pinned() const { return true; }
   virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int required_outcnt() const { return 2; }
   virtual const RegMask &out_RegMask() const;
   Node* fold_compares(PhaseIterGVN* phase);
@@ -418,7 +418,7 @@
 class IfProjNode : public CProjNode {
 public:
   IfProjNode(IfNode *ifnode, uint idx) : CProjNode(ifnode,idx) {}
-  virtual Node *Identity(PhaseTransform *phase);
+  virtual Node* Identity(PhaseGVN* phase);
 
 protected:
   // Type of If input when this branch is always taken
@@ -472,7 +472,7 @@
     init_req(1, idx);
   }
   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;
   virtual bool pinned() const { return true; }
@@ -532,7 +532,7 @@
     init_class_id(Class_Catch);
   }
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 // CatchProjNode controls which exception handler is targetted after a call.
@@ -560,7 +560,7 @@
   }
 
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type *bottom_type() const { return Type::CONTROL; }
   int  handler_bci() const        { return _handler_bci; }
   bool is_handler_proj() const    { return _handler_bci >= 0; }
@@ -579,7 +579,7 @@
     init_req(1, i_o);
   }
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual bool pinned() const { return true; }
   uint match_edge(uint idx) const { return 0; }
   virtual uint ideal_reg() const { return Op_RegP; }
@@ -595,7 +595,7 @@
   virtual int Opcode() const;
   virtual bool pinned() const { return true; };
   virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual int required_outcnt() const { return 2; }
   virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { }
--- a/hotspot/src/share/vm/opto/convertnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/convertnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -32,7 +32,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *Conv2BNode::Identity( PhaseTransform *phase ) {
+Node* Conv2BNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
   if( t == TypeInt::ZERO ) return in(1);
@@ -42,7 +42,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *Conv2BNode::Value( PhaseTransform *phase ) const {
+const Type* Conv2BNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == TypeInt::ZERO ) return TypeInt::ZERO;
@@ -64,7 +64,7 @@
 // The conversions operations are all Alpha sorted.  Please keep it that way!
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvD2FNode::Value( PhaseTransform *phase ) const {
+const Type* ConvD2FNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == Type::DOUBLE ) return Type::FLOAT;
@@ -75,13 +75,13 @@
 //------------------------------Identity---------------------------------------
 // Float's can be converted to doubles with no loss of bits.  Hence
 // converting a float to a double and back to a float is a NOP.
-Node *ConvD2FNode::Identity(PhaseTransform *phase) {
+Node* ConvD2FNode::Identity(PhaseGVN* phase) {
   return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this;
 }
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvD2INode::Value( PhaseTransform *phase ) const {
+const Type* ConvD2INode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == Type::DOUBLE ) return TypeInt::INT;
@@ -100,13 +100,13 @@
 //------------------------------Identity---------------------------------------
 // Int's can be converted to doubles with no loss of bits.  Hence
 // converting an integer to a double and back to an integer is a NOP.
-Node *ConvD2INode::Identity(PhaseTransform *phase) {
+Node* ConvD2INode::Identity(PhaseGVN* phase) {
   return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this;
 }
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvD2LNode::Value( PhaseTransform *phase ) const {
+const Type* ConvD2LNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == Type::DOUBLE ) return TypeLong::LONG;
@@ -115,7 +115,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *ConvD2LNode::Identity(PhaseTransform *phase) {
+Node* ConvD2LNode::Identity(PhaseGVN* phase) {
   // Remove ConvD2L->ConvL2D->ConvD2L sequences.
   if( in(1)       ->Opcode() == Op_ConvL2D &&
      in(1)->in(1)->Opcode() == Op_ConvD2L )
@@ -133,7 +133,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvF2DNode::Value( PhaseTransform *phase ) const {
+const Type* ConvF2DNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == Type::FLOAT ) return Type::DOUBLE;
@@ -143,7 +143,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvF2INode::Value( PhaseTransform *phase ) const {
+const Type* ConvF2INode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP )       return Type::TOP;
   if( t == Type::FLOAT ) return TypeInt::INT;
@@ -152,7 +152,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *ConvF2INode::Identity(PhaseTransform *phase) {
+Node* ConvF2INode::Identity(PhaseGVN* phase) {
   // Remove ConvF2I->ConvI2F->ConvF2I sequences.
   if( in(1)       ->Opcode() == Op_ConvI2F &&
      in(1)->in(1)->Opcode() == Op_ConvF2I )
@@ -170,7 +170,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvF2LNode::Value( PhaseTransform *phase ) const {
+const Type* ConvF2LNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP )       return Type::TOP;
   if( t == Type::FLOAT ) return TypeLong::LONG;
@@ -179,7 +179,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *ConvF2LNode::Identity(PhaseTransform *phase) {
+Node* ConvF2LNode::Identity(PhaseGVN* phase) {
   // Remove ConvF2L->ConvL2F->ConvF2L sequences.
   if( in(1)       ->Opcode() == Op_ConvL2F &&
      in(1)->in(1)->Opcode() == Op_ConvF2L )
@@ -197,7 +197,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvI2DNode::Value( PhaseTransform *phase ) const {
+const Type* ConvI2DNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeInt *ti = t->is_int();
@@ -207,7 +207,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvI2FNode::Value( PhaseTransform *phase ) const {
+const Type* ConvI2FNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeInt *ti = t->is_int();
@@ -216,7 +216,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node *ConvI2FNode::Identity(PhaseTransform *phase) {
+Node* ConvI2FNode::Identity(PhaseGVN* phase) {
   // Remove ConvI2F->ConvF2I->ConvI2F sequences.
   if( in(1)       ->Opcode() == Op_ConvF2I &&
      in(1)->in(1)->Opcode() == Op_ConvI2F )
@@ -226,7 +226,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvI2LNode::Value( PhaseTransform *phase ) const {
+const Type* ConvI2LNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeInt *ti = t->is_int();
@@ -390,7 +390,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvL2DNode::Value( PhaseTransform *phase ) const {
+const Type* ConvL2DNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeLong *tl = t->is_long();
@@ -400,7 +400,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ConvL2FNode::Value( PhaseTransform *phase ) const {
+const Type* ConvL2FNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeLong *tl = t->is_long();
@@ -410,14 +410,14 @@
 
 //=============================================================================
 //----------------------------Identity-----------------------------------------
-Node *ConvL2INode::Identity( PhaseTransform *phase ) {
+Node* ConvL2INode::Identity(PhaseGVN* phase) {
   // Convert L2I(I2L(x)) => x
   if (in(1)->Opcode() == Op_ConvI2L)  return in(1)->in(1);
   return this;
 }
 
 //------------------------------Value------------------------------------------
-const Type *ConvL2INode::Value( PhaseTransform *phase ) const {
+const Type* ConvL2INode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeLong *tl = t->is_long();
@@ -469,7 +469,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // Remove redundant roundings
-Node *RoundFloatNode::Identity( PhaseTransform *phase ) {
+Node* RoundFloatNode::Identity(PhaseGVN* phase) {
   assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
   // Do not round constants
   if (phase->type(in(1))->base() == Type::FloatCon)  return in(1);
@@ -483,14 +483,14 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *RoundFloatNode::Value( PhaseTransform *phase ) const {
+const Type* RoundFloatNode::Value(PhaseGVN* phase) const {
   return phase->type( in(1) );
 }
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // Remove redundant roundings.  Incoming arguments are already rounded.
-Node *RoundDoubleNode::Identity( PhaseTransform *phase ) {
+Node* RoundDoubleNode::Identity(PhaseGVN* phase) {
   assert(Matcher::strict_fp_requires_explicit_rounding, "should only generate for Intel");
   // Do not round constants
   if (phase->type(in(1))->base() == Type::DoubleCon)  return in(1);
@@ -506,7 +506,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *RoundDoubleNode::Value( PhaseTransform *phase ) const {
+const Type* RoundDoubleNode::Value(PhaseGVN* phase) const {
   return phase->type( in(1) );
 }
 
--- a/hotspot/src/share/vm/opto/convertnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/convertnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -36,8 +36,8 @@
   Conv2BNode( Node *i ) : Node(0,i) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint  ideal_reg() const { return Op_RegI; }
 };
 
@@ -49,8 +49,8 @@
   ConvD2FNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint  ideal_reg() const { return Op_RegF; }
 };
 
@@ -61,8 +61,8 @@
   ConvD2INode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint  ideal_reg() const { return Op_RegI; }
 };
@@ -74,8 +74,8 @@
   ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint ideal_reg() const { return Op_RegL; }
 };
@@ -87,7 +87,7 @@
   ConvF2DNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint  ideal_reg() const { return Op_RegD; }
 };
 
@@ -98,8 +98,8 @@
   ConvF2INode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint  ideal_reg() const { return Op_RegI; }
 };
@@ -111,8 +111,8 @@
   ConvF2LNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint  ideal_reg() const { return Op_RegL; }
 };
@@ -124,7 +124,7 @@
   ConvI2DNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint  ideal_reg() const { return Op_RegD; }
 };
 
@@ -135,8 +135,8 @@
   ConvI2FNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual uint  ideal_reg() const { return Op_RegF; }
 };
 
@@ -148,7 +148,7 @@
   : TypeNode(t, 2)
   { init_req(1, in1); }
   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 uint  ideal_reg() const { return Op_RegL; }
 };
@@ -160,7 +160,7 @@
   ConvL2DNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 
@@ -171,7 +171,7 @@
   ConvL2FNode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint  ideal_reg() const { return Op_RegF; }
 };
 
@@ -182,8 +182,8 @@
   ConvL2INode( Node *in1 ) : Node(0,in1) {}
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint  ideal_reg() const { return Op_RegI; }
 };
@@ -195,8 +195,8 @@
   virtual int   Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint  ideal_reg() const { return Op_RegF; }
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 
@@ -207,8 +207,8 @@
   virtual int   Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint  ideal_reg() const { return Op_RegD; }
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 
--- a/hotspot/src/share/vm/opto/countbitsnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/countbitsnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -29,7 +29,7 @@
 #include "opto/type.hpp"
 
 //------------------------------Value------------------------------------------
-const Type* CountLeadingZerosINode::Value(PhaseTransform* phase) const {
+const Type* CountLeadingZerosINode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   const TypeInt* ti = t->isa_int();
@@ -51,7 +51,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type* CountLeadingZerosLNode::Value(PhaseTransform* phase) const {
+const Type* CountLeadingZerosLNode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   const TypeLong* tl = t->isa_long();
@@ -74,7 +74,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type* CountTrailingZerosINode::Value(PhaseTransform* phase) const {
+const Type* CountTrailingZerosINode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   const TypeInt* ti = t->isa_int();
@@ -96,7 +96,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type* CountTrailingZerosLNode::Value(PhaseTransform* phase) const {
+const Type* CountTrailingZerosLNode::Value(PhaseGVN* phase) const {
   const Type* t = phase->type(in(1));
   if (t == Type::TOP) return Type::TOP;
   const TypeLong* tl = t->isa_long();
--- a/hotspot/src/share/vm/opto/countbitsnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/countbitsnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -44,7 +44,7 @@
   public:
   CountLeadingZerosINode(Node* in1) : CountBitsNode(in1) {}
   virtual int Opcode() const;
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //---------- CountLeadingZerosLNode --------------------------------------------
@@ -53,7 +53,7 @@
   public:
   CountLeadingZerosLNode(Node* in1) : CountBitsNode(in1) {}
   virtual int Opcode() const;
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //---------- CountTrailingZerosINode -------------------------------------------
@@ -62,7 +62,7 @@
   public:
   CountTrailingZerosINode(Node* in1) : CountBitsNode(in1) {}
   virtual int Opcode() const;
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //---------- CountTrailingZerosLNode -------------------------------------------
@@ -71,7 +71,7 @@
   public:
   CountTrailingZerosLNode(Node* in1) : CountBitsNode(in1) {}
   virtual int Opcode() const;
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //---------- PopCountINode -----------------------------------------------------
--- a/hotspot/src/share/vm/opto/divnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/divnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -457,7 +457,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If the divisor is 1, we are an identity on the dividend.
-Node *DivINode::Identity( PhaseTransform *phase ) {
+Node* DivINode::Identity(PhaseGVN* phase) {
   return (phase->type( in(2) )->higher_equal(TypeInt::ONE)) ? in(1) : this;
 }
 
@@ -493,7 +493,7 @@
 //------------------------------Value------------------------------------------
 // A DivINode divides its inputs.  The third input is a Control input, used to
 // prevent hoisting the divide above an unsafe test.
-const Type *DivINode::Value( PhaseTransform *phase ) const {
+const Type* DivINode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -559,7 +559,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If the divisor is 1, we are an identity on the dividend.
-Node *DivLNode::Identity( PhaseTransform *phase ) {
+Node* DivLNode::Identity(PhaseGVN* phase) {
   return (phase->type( in(2) )->higher_equal(TypeLong::ONE)) ? in(1) : this;
 }
 
@@ -595,7 +595,7 @@
 //------------------------------Value------------------------------------------
 // A DivLNode divides its inputs.  The third input is a Control input, used to
 // prevent hoisting the divide above an unsafe test.
-const Type *DivLNode::Value( PhaseTransform *phase ) const {
+const Type* DivLNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -662,7 +662,7 @@
 //------------------------------Value------------------------------------------
 // An DivFNode divides its inputs.  The third input is a Control input, used to
 // prevent hoisting the divide above an unsafe test.
-const Type *DivFNode::Value( PhaseTransform *phase ) const {
+const Type* DivFNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -705,7 +705,7 @@
 //------------------------------isA_Copy---------------------------------------
 // Dividing by self is 1.
 // If the divisor is 1, we are an identity on the dividend.
-Node *DivFNode::Identity( PhaseTransform *phase ) {
+Node* DivFNode::Identity(PhaseGVN* phase) {
   return (phase->type( in(2) ) == TypeF::ONE) ? in(1) : this;
 }
 
@@ -750,7 +750,7 @@
 //------------------------------Value------------------------------------------
 // An DivDNode divides its inputs.  The third input is a Control input, used to
 // prevent hoisting the divide above an unsafe test.
-const Type *DivDNode::Value( PhaseTransform *phase ) const {
+const Type* DivDNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -800,7 +800,7 @@
 //------------------------------isA_Copy---------------------------------------
 // Dividing by self is 1.
 // If the divisor is 1, we are an identity on the dividend.
-Node *DivDNode::Identity( PhaseTransform *phase ) {
+Node* DivDNode::Identity(PhaseGVN* phase) {
   return (phase->type( in(2) ) == TypeD::ONE) ? in(1) : this;
 }
 
@@ -972,7 +972,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *ModINode::Value( PhaseTransform *phase ) const {
+const Type* ModINode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -1145,7 +1145,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *ModLNode::Value( PhaseTransform *phase ) const {
+const Type* ModLNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -1186,7 +1186,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ModFNode::Value( PhaseTransform *phase ) const {
+const Type* ModFNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -1230,7 +1230,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *ModDNode::Value( PhaseTransform *phase ) const {
+const Type* ModDNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
--- a/hotspot/src/share/vm/opto/divnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/divnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -44,9 +44,9 @@
 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; }
 };
@@ -57,9 +57,9 @@
 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; }
 };
@@ -70,9 +70,9 @@
 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; }
 };
@@ -83,9 +83,9 @@
 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; }
 };
@@ -96,7 +96,7 @@
 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; }
@@ -108,7 +108,7 @@
 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; }
@@ -120,7 +120,7 @@
 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; }
 };
@@ -131,7 +131,7 @@
 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; }
 };
@@ -147,9 +147,9 @@
     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; }
--- a/hotspot/src/share/vm/opto/ifnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/ifnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -45,7 +45,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Return a tuple for whichever arm of the IF is reachable
-const Type *IfNode::Value( PhaseTransform *phase ) const {
+const Type* IfNode::Value(PhaseGVN* phase) const {
   if( !in(0) ) return Type::TOP;
   if( phase->type(in(0)) == Type::TOP )
     return Type::TOP;
@@ -1527,16 +1527,19 @@
 
 //------------------------------Identity---------------------------------------
 // If the test is constant & we match, then we are the input Control
-Node *IfProjNode::Identity(PhaseTransform *phase) {
+Node* IfProjNode::Identity(PhaseGVN* phase) {
   // Can only optimize if cannot go the other way
   const TypeTuple *t = phase->type(in(0))->is_tuple();
-  if (t == TypeTuple::IFNEITHER ||
-      // kill dead branch first otherwise the IfNode's control will
-      // have 2 control uses (the IfNode that doesn't go away because
-      // it still has uses and this branch of the
-      // If). Node::has_special_unique_user() will cause this node to
-      // be reprocessed once the dead branch is killed.
-      (always_taken(t) && in(0)->outcnt() == 1)) {
+  if (t == TypeTuple::IFNEITHER || (always_taken(t) &&
+       // During parsing (GVN) we don't remove dead code aggressively.
+       // Cut off dead branch and let PhaseRemoveUseless take care of it.
+      (!phase->is_IterGVN() ||
+       // During IGVN, first wait for the dead branch to be killed.
+       // Otherwise, the IfNode's control will have two control uses (the IfNode
+       // that doesn't go away because it still has uses and this branch of the
+       // If) which breaks other optimizations. Node::has_special_unique_user()
+       // will cause this node to be reprocessed once the dead branch is killed.
+       in(0)->outcnt() == 1))) {
     // IfNode control
     return in(0)->in(0);
   }
--- a/hotspot/src/share/vm/opto/intrinsicnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/intrinsicnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -55,7 +55,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type* StrIntrinsicNode::Value(PhaseTransform* phase) const {
+const Type* StrIntrinsicNode::Value(PhaseGVN* phase) const {
   if (in(0) && phase->type(in(0)) == Type::TOP) return Type::TOP;
   return bottom_type();
 }
@@ -93,7 +93,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type* EncodeISOArrayNode::Value(PhaseTransform* phase) const {
+const Type* EncodeISOArrayNode::Value(PhaseGVN* phase) const {
   if (in(0) && phase->type(in(0)) == Type::TOP) return Type::TOP;
   return bottom_type();
 }
--- a/hotspot/src/share/vm/opto/intrinsicnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/intrinsicnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -77,7 +77,7 @@
   virtual uint match_edge(uint idx) const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   ArgEncoding encoding() const { return _encoding; }
 };
 
@@ -177,7 +177,7 @@
   virtual uint match_edge(uint idx) const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 #endif // SHARE_VM_OPTO_INTRINSICNODE_HPP
--- a/hotspot/src/share/vm/opto/locknode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/locknode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -96,7 +96,7 @@
   virtual uint size_of() const;
   virtual uint cmp( const Node &n ) const ;    // Always fail, except on self
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const { return TypeInt::CC; }
+  virtual const Type* Value(PhaseGVN* phase) const { return TypeInt::CC; }
   const Type *sub(const Type *t1, const Type *t2) const { return TypeInt::CC;}
 
   void create_lock_counter(JVMState* s);
@@ -123,7 +123,7 @@
   virtual uint hash() const ;                  // { return NO_HASH; }
   virtual uint cmp( const Node &n ) const ;    // Always fail, except on self
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const { return TypeInt::CC; }
+  virtual const Type* Value(PhaseGVN* phase) const { return TypeInt::CC; }
   const Type *sub(const Type *t1, const Type *t2) const { return TypeInt::CC;}
 
 };
--- a/hotspot/src/share/vm/opto/loopnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/loopnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -902,7 +902,7 @@
 
 //=============================================================================
 //------------------------------Value-----------------------------------------
-const Type *LoopLimitNode::Value( PhaseTransform *phase ) const {
+const Type* LoopLimitNode::Value(PhaseGVN* phase) const {
   const Type* init_t   = phase->type(in(Init));
   const Type* limit_t  = phase->type(in(Limit));
   const Type* stride_t = phase->type(in(Stride));
@@ -1016,7 +1016,7 @@
 
 //------------------------------Identity---------------------------------------
 // If stride == 1 return limit node.
-Node *LoopLimitNode::Identity( PhaseTransform *phase ) {
+Node* LoopLimitNode::Identity(PhaseGVN* phase) {
   int stride_con = phase->type(in(Stride))->is_int()->get_con();
   if (stride_con == 1 || stride_con == -1)
     return in(Limit);
--- a/hotspot/src/share/vm/opto/loopnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/loopnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -339,9 +339,9 @@
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 };
 
 // -----------------------------IdealLoopTree----------------------------------
--- a/hotspot/src/share/vm/opto/machnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/machnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -652,7 +652,7 @@
 uint MachCallNode::cmp( const Node &n ) const
 { return _tf == ((MachCallNode&)n)._tf; }
 const Type *MachCallNode::bottom_type() const { return tf()->range(); }
-const Type *MachCallNode::Value(PhaseTransform *phase) const { return tf()->range(); }
+const Type* MachCallNode::Value(PhaseGVN* phase) const { return tf()->range(); }
 
 #ifndef PRODUCT
 void MachCallNode::dump_spec(outputStream *st) const {
--- a/hotspot/src/share/vm/opto/machnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/machnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -863,7 +863,7 @@
 
   virtual const Type *bottom_type() const;
   virtual bool  pinned() const { return false; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const RegMask &in_RegMask(uint) const;
   virtual int ret_addr_offset() { return 0; }
 
--- a/hotspot/src/share/vm/opto/macro.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/macro.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -244,7 +244,7 @@
   } else {
     // G1 pre/post barriers
     assert(p2x->outcnt() <= 2, "expects 1 or 2 users: Xor and URShift nodes");
-    // It could be only one user, URShift node, in Object.clone() instrinsic
+    // It could be only one user, URShift node, in Object.clone() intrinsic
     // but the new allocation is passed to arraycopy stub and it could not
     // be scalar replaced. So we don't check the case.
 
--- a/hotspot/src/share/vm/opto/mathexactnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/mathexactnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -247,11 +247,11 @@
   return IdealHelper<OverflowLNode>::Ideal(this, phase, can_reshape);
 }
 
-const Type* OverflowINode::Value(PhaseTransform* phase) const {
+const Type* OverflowINode::Value(PhaseGVN* phase) const {
   return IdealHelper<OverflowINode>::Value(this, phase);
 }
 
-const Type* OverflowLNode::Value(PhaseTransform* phase) const {
+const Type* OverflowLNode::Value(PhaseGVN* phase) const {
   return IdealHelper<OverflowLNode>::Value(this, phase);
 }
 
--- a/hotspot/src/share/vm/opto/mathexactnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/mathexactnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -48,7 +48,7 @@
 
   OverflowINode(Node* in1, Node* in2) : OverflowNode(in1, in2) {}
   virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   virtual bool will_overflow(jint v1, jint v2) const = 0;
   virtual bool can_overflow(const Type* t1, const Type* t2) const = 0;
@@ -61,7 +61,7 @@
 
   OverflowLNode(Node* in1, Node* in2) : OverflowNode(in1, in2) {}
   virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
-  virtual const Type* Value(PhaseTransform* phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   virtual bool will_overflow(jlong v1, jlong v2) const = 0;
   virtual bool can_overflow(const Type* t1, const Type* t2) const = 0;
--- a/hotspot/src/share/vm/opto/memnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/memnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -1069,7 +1069,7 @@
 
 //------------------------------Identity---------------------------------------
 // Loads are identity if previous store is to same address
-Node *LoadNode::Identity( PhaseTransform *phase ) {
+Node* LoadNode::Identity(PhaseGVN* phase) {
   // If the previous store-maker is the right kind of Store, and the store is
   // to the same address, then we are equal to the value stored.
   Node* mem = in(Memory);
@@ -1615,7 +1615,7 @@
 }
 
 //------------------------------Value-----------------------------------------
-const Type *LoadNode::Value( PhaseTransform *phase ) const {
+const Type* LoadNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   Node* mem = in(MemNode::Memory);
   const Type *t1 = phase->type(mem);
@@ -1901,7 +1901,7 @@
   return LoadNode::Ideal(phase, can_reshape);
 }
 
-const Type* LoadBNode::Value(PhaseTransform *phase) const {
+const Type* LoadBNode::Value(PhaseGVN* phase) const {
   Node* mem = in(MemNode::Memory);
   Node* value = can_see_stored_value(mem,phase);
   if (value != NULL && value->is_Con() &&
@@ -1931,7 +1931,7 @@
   return LoadNode::Ideal(phase, can_reshape);
 }
 
-const Type* LoadUBNode::Value(PhaseTransform *phase) const {
+const Type* LoadUBNode::Value(PhaseGVN* phase) const {
   Node* mem = in(MemNode::Memory);
   Node* value = can_see_stored_value(mem,phase);
   if (value != NULL && value->is_Con() &&
@@ -1961,7 +1961,7 @@
   return LoadNode::Ideal(phase, can_reshape);
 }
 
-const Type* LoadUSNode::Value(PhaseTransform *phase) const {
+const Type* LoadUSNode::Value(PhaseGVN* phase) const {
   Node* mem = in(MemNode::Memory);
   Node* value = can_see_stored_value(mem,phase);
   if (value != NULL && value->is_Con() &&
@@ -1993,7 +1993,7 @@
   return LoadNode::Ideal(phase, can_reshape);
 }
 
-const Type* LoadSNode::Value(PhaseTransform *phase) const {
+const Type* LoadSNode::Value(PhaseGVN* phase) const {
   Node* mem = in(MemNode::Memory);
   Node* value = can_see_stored_value(mem,phase);
   if (value != NULL && value->is_Con() &&
@@ -2026,7 +2026,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *LoadKlassNode::Value( PhaseTransform *phase ) const {
+const Type* LoadKlassNode::Value(PhaseGVN* phase) const {
   return klass_value_common(phase);
 }
 
@@ -2036,7 +2036,7 @@
   return false;
 }
 
-const Type *LoadNode::klass_value_common( PhaseTransform *phase ) const {
+const Type* LoadNode::klass_value_common(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(MemNode::Memory) );
   if (t1 == Type::TOP)  return Type::TOP;
@@ -2172,11 +2172,11 @@
 //------------------------------Identity---------------------------------------
 // To clean up reflective code, simplify k.java_mirror.as_klass to plain k.
 // Also feed through the klass in Allocate(...klass...)._klass.
-Node* LoadKlassNode::Identity( PhaseTransform *phase ) {
+Node* LoadKlassNode::Identity(PhaseGVN* phase) {
   return klass_identity_common(phase);
 }
 
-Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
+Node* LoadNode::klass_identity_common(PhaseGVN* phase) {
   Node* x = LoadNode::Identity(phase);
   if (x != this)  return x;
 
@@ -2231,7 +2231,7 @@
 
 
 //------------------------------Value------------------------------------------
-const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
+const Type* LoadNKlassNode::Value(PhaseGVN* phase) const {
   const Type *t = klass_value_common(phase);
   if (t == Type::TOP)
     return t;
@@ -2242,7 +2242,7 @@
 //------------------------------Identity---------------------------------------
 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
 // Also feed through the klass in Allocate(...klass...)._klass.
-Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
+Node* LoadNKlassNode::Identity(PhaseGVN* phase) {
   Node *x = klass_identity_common(phase);
 
   const Type *t = phase->type( x );
@@ -2254,7 +2254,7 @@
 }
 
 //------------------------------Value-----------------------------------------
-const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
+const Type* LoadRangeNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(MemNode::Memory) );
   if( t1 == Type::TOP ) return Type::TOP;
@@ -2302,7 +2302,7 @@
 
 //------------------------------Identity---------------------------------------
 // Feed through the length in AllocateArray(...length...)._length.
-Node* LoadRangeNode::Identity( PhaseTransform *phase ) {
+Node* LoadRangeNode::Identity(PhaseGVN* phase) {
   Node* x = LoadINode::Identity(phase);
   if (x != this)  return x;
 
@@ -2473,7 +2473,7 @@
 }
 
 //------------------------------Value-----------------------------------------
-const Type *StoreNode::Value( PhaseTransform *phase ) const {
+const Type* StoreNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(MemNode::Memory) );
   if( t1 == Type::TOP ) return Type::TOP;
@@ -2488,7 +2488,7 @@
 // Remove redundant stores:
 //   Store(m, p, Load(m, p)) changes to m.
 //   Store(, p, x) -> Store(m, p, x) changes to Store(m, p, x).
-Node *StoreNode::Identity( PhaseTransform *phase ) {
+Node* StoreNode::Identity(PhaseGVN* phase) {
   Node* mem = in(MemNode::Memory);
   Node* adr = in(MemNode::Address);
   Node* val = in(MemNode::ValueIn);
@@ -2642,7 +2642,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *StoreCMNode::Identity( PhaseTransform *phase ) {
+Node* StoreCMNode::Identity(PhaseGVN* phase) {
   // No need to card mark when storing a null ptr
   Node* my_store = in(MemNode::OopStore);
   if (my_store->is_Store()) {
@@ -2671,7 +2671,7 @@
 }
 
 //------------------------------Value-----------------------------------------
-const Type *StoreCMNode::Value( PhaseTransform *phase ) const {
+const Type* StoreCMNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t = phase->type( in(MemNode::Memory) );
   if( t == Type::TOP ) return Type::TOP;
@@ -2689,7 +2689,7 @@
 
 //=============================================================================
 //----------------------------------SCMemProjNode------------------------------
-const Type * SCMemProjNode::Value( PhaseTransform *phase ) const
+const Type* SCMemProjNode::Value(PhaseGVN* phase) const
 {
   return bottom_type();
 }
@@ -2745,7 +2745,7 @@
 
 //------------------------------Identity---------------------------------------
 // Clearing a zero length array does nothing
-Node *ClearArrayNode::Identity( PhaseTransform *phase ) {
+Node* ClearArrayNode::Identity(PhaseGVN* phase) {
   return phase->type(in(2))->higher_equal(TypeX::ZERO)  ? in(1) : this;
 }
 
@@ -3001,7 +3001,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *MemBarNode::Value( PhaseTransform *phase ) const {
+const Type* MemBarNode::Value(PhaseGVN* phase) const {
   if( !in(0) ) return Type::TOP;
   if( phase->type(in(0)) == Type::TOP )
     return Type::TOP;
@@ -4143,7 +4143,7 @@
 }
 
 //------------------------------Identity---------------------------------------
-Node* MergeMemNode::Identity(PhaseTransform *phase) {
+Node* MergeMemNode::Identity(PhaseGVN* phase) {
   // Identity if this merge point does not record any interesting memory
   // disambiguations.
   Node* base_mem = base_memory();
--- a/hotspot/src/share/vm/opto/memnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/memnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -207,7 +207,7 @@
 
   // Handle algebraic identities here.  If we have an identity, return the Node
   // we are equivalent to.  We look for Load of a Store.
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // If the load is from Field memory and the pointer is non-null, it might be possible to
   // zero out the control input.
@@ -223,11 +223,11 @@
 
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   // Common methods for LoadKlass and LoadNKlass nodes.
-  const Type *klass_value_common( PhaseTransform *phase ) const;
-  Node *klass_identity_common( PhaseTransform *phase );
+  const Type* klass_value_common(PhaseGVN* phase) const;
+  Node* klass_identity_common(PhaseGVN* phase);
 
   virtual uint ideal_reg() const;
   virtual const Type *bottom_type() const;
@@ -284,7 +284,7 @@
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value(PhaseTransform *phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int store_Opcode() const { return Op_StoreB; }
   virtual BasicType memory_type() const { return T_BYTE; }
 };
@@ -298,7 +298,7 @@
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node* Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value(PhaseTransform *phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int store_Opcode() const { return Op_StoreB; }
   virtual BasicType memory_type() const { return T_BYTE; }
 };
@@ -312,7 +312,7 @@
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value(PhaseTransform *phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int store_Opcode() const { return Op_StoreC; }
   virtual BasicType memory_type() const { return T_CHAR; }
 };
@@ -326,7 +326,7 @@
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value(PhaseTransform *phase) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual int store_Opcode() const { return Op_StoreC; }
   virtual BasicType memory_type() const { return T_SHORT; }
 };
@@ -350,8 +350,8 @@
   LoadRangeNode(Node *c, Node *mem, Node *adr, const TypeInt *ti = TypeInt::POS)
     : LoadINode(c, mem, adr, TypeAryPtr::RANGE, ti, MemNode::unordered) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
@@ -483,8 +483,8 @@
   LoadKlassNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk, MemOrd mo)
     : LoadPNode(c, mem, adr, at, tk, mo) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual bool depends_only_on_test() const { return true; }
 
   // Polymorphic factory method:
@@ -503,8 +503,8 @@
   virtual int store_Opcode() const { return Op_StoreNKlass; }
   virtual BasicType memory_type() const { return T_NARROWKLASS; }
 
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   virtual bool depends_only_on_test() const { return true; }
 };
 
@@ -581,10 +581,10 @@
 
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   // Check for identity function on memory (Load then Store at same address)
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // Do not match memory edge
   virtual uint match_edge(uint idx) const;
@@ -746,9 +746,9 @@
            "bad oop alias idx");
   }
   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 BasicType memory_type() const { return T_VOID; } // unspecific
   int oop_alias_idx() const { return _oop_alias_idx; }
 };
@@ -782,7 +782,7 @@
     return ctrl->in(MemNode::Memory)->adr_type();
   }
   virtual uint ideal_reg() const { return 0;} // memory projections don't have a register
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const {};
 #endif
@@ -934,7 +934,7 @@
   // ClearArray modifies array elements, and so affects only the
   // array memory addressed by the bottom_type of its base address.
   virtual const class TypePtr *adr_type() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint match_edge(uint idx) const;
 
@@ -983,7 +983,7 @@
   MemBarNode(Compile* C, int alias_idx, Node* precedent);
   virtual int Opcode() const = 0;
   virtual const class TypePtr *adr_type() const { return _adr_type; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint match_edge(uint idx) const { return 0; }
   virtual const Type *bottom_type() const { return TypeTuple::MEMBAR; }
@@ -1199,7 +1199,7 @@
   static MergeMemNode* make(Node* base_memory);
 
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual uint ideal_reg() const { return NotAMachineReg; }
   virtual uint match_edge(uint idx) const { return 0; }
--- a/hotspot/src/share/vm/opto/movenode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/movenode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -121,7 +121,7 @@
 //------------------------------Identity---------------------------------------
 // Conditional-move is an identity if both inputs are the same, or the test
 // true or false.
-Node *CMoveNode::Identity( PhaseTransform *phase ) {
+Node* CMoveNode::Identity(PhaseGVN* phase) {
   if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs?
   return in(IfFalse);         // Then it doesn't matter
   if( phase->type(in(Condition)) == TypeInt::ZERO )
@@ -149,7 +149,7 @@
 
 //------------------------------Value------------------------------------------
 // Result is the meet of inputs
-const Type *CMoveNode::Value( PhaseTransform *phase ) const {
+const Type* CMoveNode::Value(PhaseGVN* phase) const {
   if( phase->type(in(Condition)) == Type::TOP )
   return Type::TOP;
   return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue)));
@@ -351,7 +351,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *MoveL2DNode::Value( PhaseTransform *phase ) const {
+const Type* MoveL2DNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeLong *tl = t->is_long();
@@ -362,7 +362,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *MoveI2FNode::Value( PhaseTransform *phase ) const {
+const Type* MoveI2FNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   const TypeInt *ti = t->is_int();
@@ -373,7 +373,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *MoveF2INode::Value( PhaseTransform *phase ) const {
+const Type* MoveF2INode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP )       return Type::TOP;
   if( t == Type::FLOAT ) return TypeInt::INT;
@@ -384,7 +384,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *MoveD2LNode::Value( PhaseTransform *phase ) const {
+const Type* MoveD2LNode::Value(PhaseGVN* phase) const {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return Type::TOP;
   if( t == Type::DOUBLE ) return TypeLong::LONG;
--- a/hotspot/src/share/vm/opto/movenode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/movenode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -45,8 +45,8 @@
     init_req(IfTrue,right);
   }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
   static CMoveNode *make(Node *c, Node *bol, Node *left, Node *right, const Type *t);
   // Helper function to spot cmove graph shapes
   static Node *is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b );
@@ -104,7 +104,7 @@
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint ideal_reg() const { return Op_RegF; }
-  virtual const Type* Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveL2DNode : public Node {
@@ -113,7 +113,7 @@
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
-  virtual const Type* Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveF2INode : public Node {
@@ -122,7 +122,7 @@
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
-  virtual const Type* Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 class MoveD2LNode : public Node {
@@ -131,7 +131,7 @@
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
-  virtual const Type* Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------BinaryNode-------------------------------------
--- a/hotspot/src/share/vm/opto/mulnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/mulnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -46,7 +46,7 @@
 
 //------------------------------Identity---------------------------------------
 // Multiplying a one preserves the other argument
-Node *MulNode::Identity( PhaseTransform *phase ) {
+Node* MulNode::Identity(PhaseGVN* phase) {
   register const Type *one = mul_id();  // The multiplicative identity
   if( phase->type( in(1) )->higher_equal( one ) ) return in(2);
   if( phase->type( in(2) )->higher_equal( one ) ) return in(1);
@@ -139,7 +139,7 @@
 }
 
 //------------------------------Value-----------------------------------------
-const Type *MulNode::Value( PhaseTransform *phase ) const {
+const Type* MulNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
   // Either input is TOP ==> the result is TOP
@@ -381,7 +381,7 @@
 
 //=============================================================================
 //------------------------------Value------------------------------------------
-const Type *MulHiLNode::Value( PhaseTransform *phase ) const {
+const Type* MulHiLNode::Value(PhaseGVN* phase) const {
   // Either input is TOP ==> the result is TOP
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -432,7 +432,7 @@
 
 //------------------------------Identity---------------------------------------
 // Masking off the high bits of an unsigned load is not required
-Node *AndINode::Identity( PhaseTransform *phase ) {
+Node* AndINode::Identity(PhaseGVN* phase) {
 
   // x & x => x
   if (phase->eqv(in(1), in(2))) return in(1);
@@ -562,7 +562,7 @@
 
 //------------------------------Identity---------------------------------------
 // Masking off the high bits of an unsigned load is not required
-Node *AndLNode::Identity( PhaseTransform *phase ) {
+Node* AndLNode::Identity(PhaseGVN* phase) {
 
   // x & x => x
   if (phase->eqv(in(1), in(2))) return in(1);
@@ -639,7 +639,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *LShiftINode::Identity( PhaseTransform *phase ) {
+Node* LShiftINode::Identity(PhaseGVN* phase) {
   const TypeInt *ti = phase->type( in(2) )->isa_int();  // shift count is an int
   return ( ti && ti->is_con() && ( ti->get_con() & ( BitsPerInt - 1 ) ) == 0 ) ? in(1) : this;
 }
@@ -704,7 +704,7 @@
 
 //------------------------------Value------------------------------------------
 // A LShiftINode shifts its input2 left by input1 amount.
-const Type *LShiftINode::Value( PhaseTransform *phase ) const {
+const Type* LShiftINode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
   // Either input is TOP ==> the result is TOP
@@ -751,7 +751,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *LShiftLNode::Identity( PhaseTransform *phase ) {
+Node* LShiftLNode::Identity(PhaseGVN* phase) {
   const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
   return ( ti && ti->is_con() && ( ti->get_con() & ( BitsPerLong - 1 ) ) == 0 ) ? in(1) : this;
 }
@@ -813,7 +813,7 @@
 
 //------------------------------Value------------------------------------------
 // A LShiftLNode shifts its input2 left by input1 amount.
-const Type *LShiftLNode::Value( PhaseTransform *phase ) const {
+const Type* LShiftLNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
   // Either input is TOP ==> the result is TOP
@@ -860,7 +860,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *RShiftINode::Identity( PhaseTransform *phase ) {
+Node* RShiftINode::Identity(PhaseGVN* phase) {
   const TypeInt *t2 = phase->type(in(2))->isa_int();
   if( !t2 ) return this;
   if ( t2->is_con() && ( t2->get_con() & ( BitsPerInt - 1 ) ) == 0 )
@@ -959,7 +959,7 @@
 
 //------------------------------Value------------------------------------------
 // A RShiftINode shifts its input2 right by input1 amount.
-const Type *RShiftINode::Value( PhaseTransform *phase ) const {
+const Type* RShiftINode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
   // Either input is TOP ==> the result is TOP
@@ -1014,14 +1014,14 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *RShiftLNode::Identity( PhaseTransform *phase ) {
+Node* RShiftLNode::Identity(PhaseGVN* phase) {
   const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
   return ( ti && ti->is_con() && ( ti->get_con() & ( BitsPerLong - 1 ) ) == 0 ) ? in(1) : this;
 }
 
 //------------------------------Value------------------------------------------
 // A RShiftLNode shifts its input2 right by input1 amount.
-const Type *RShiftLNode::Value( PhaseTransform *phase ) const {
+const Type* RShiftLNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
   // Either input is TOP ==> the result is TOP
@@ -1072,7 +1072,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *URShiftINode::Identity( PhaseTransform *phase ) {
+Node* URShiftINode::Identity(PhaseGVN* phase) {
   const TypeInt *ti = phase->type( in(2) )->isa_int();
   if ( ti && ti->is_con() && ( ti->get_con() & ( BitsPerInt - 1 ) ) == 0 ) return in(1);
 
@@ -1168,7 +1168,7 @@
 
 //------------------------------Value------------------------------------------
 // A URShiftINode shifts its input2 right by input1 amount.
-const Type *URShiftINode::Value( PhaseTransform *phase ) const {
+const Type* URShiftINode::Value(PhaseGVN* phase) const {
   // (This is a near clone of RShiftINode::Value.)
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
@@ -1242,7 +1242,7 @@
 
 //=============================================================================
 //------------------------------Identity---------------------------------------
-Node *URShiftLNode::Identity( PhaseTransform *phase ) {
+Node* URShiftLNode::Identity(PhaseGVN* phase) {
   const TypeInt *ti = phase->type( in(2) )->isa_int(); // shift count is an int
   return ( ti && ti->is_con() && ( ti->get_con() & ( BitsPerLong - 1 ) ) == 0 ) ? in(1) : this;
 }
@@ -1297,7 +1297,7 @@
 
 //------------------------------Value------------------------------------------
 // A URShiftINode shifts its input2 right by input1 amount.
-const Type *URShiftLNode::Value( PhaseTransform *phase ) const {
+const Type* URShiftLNode::Value(PhaseGVN* phase) const {
   // (This is a near clone of RShiftLNode::Value.)
   const Type *t1 = phase->type( in(1) );
   const Type *t2 = phase->type( in(2) );
--- a/hotspot/src/share/vm/opto/mulnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/mulnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -47,7 +47,7 @@
 
   // Handle algebraic identities here.  If we have an identity, return the Node
   // we are equivalent to.  We look for "add of zero" as an identity.
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // We also canonicalize the Node, moving constants to the right input,
   // and flatten expressions (so that 1+x+2 becomes x+3).
@@ -55,7 +55,7 @@
 
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   // Supplied function returns the product of the inputs.
   // This also type-checks the inputs for sanity.  Guaranteed never to
@@ -146,7 +146,7 @@
 public:
   MulHiLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
@@ -159,7 +159,7 @@
   AndINode( Node *in1, Node *in2 ) : MulINode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type *mul_ring( const Type *, const Type * ) const;
   const Type *mul_id() const { return TypeInt::MINUS_1; }
   const Type *add_id() const { return TypeInt::ZERO; }
@@ -176,7 +176,7 @@
   AndLNode( Node *in1, Node *in2 ) : MulLNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type *mul_ring( const Type *, const Type * ) const;
   const Type *mul_id() const { return TypeLong::MINUS_1; }
   const Type *add_id() const { return TypeLong::ZERO; }
@@ -191,9 +191,9 @@
 public:
   LShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   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;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
@@ -204,9 +204,9 @@
 public:
   LShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   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;
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
@@ -217,9 +217,9 @@
 public:
   RShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   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;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
@@ -230,8 +230,8 @@
 public:
   RShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
@@ -243,9 +243,9 @@
 public:
   URShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   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;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
@@ -256,9 +256,9 @@
 public:
   URShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {}
   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;
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
--- a/hotspot/src/share/vm/opto/multnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/multnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -147,7 +147,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *ProjNode::Value( PhaseTransform *phase ) const {
+const Type* ProjNode::Value(PhaseGVN* phase) const {
   if (in(0) == NULL) return Type::TOP;
   return proj_type(phase->type(in(0)));
 }
--- a/hotspot/src/share/vm/opto/multnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/multnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -81,7 +81,7 @@
   virtual const Type *bottom_type() const;
   virtual const TypePtr *adr_type() const;
   virtual bool pinned() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual uint ideal_reg() const;
   virtual const RegMask &out_RegMask() const;
 
--- a/hotspot/src/share/vm/opto/narrowptrnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/narrowptrnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -26,7 +26,7 @@
 #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);
 
@@ -37,7 +37,7 @@
   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;
@@ -46,7 +46,7 @@
   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);
 
@@ -57,7 +57,7 @@
   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;
@@ -67,7 +67,7 @@
 }
 
 
-Node* DecodeNKlassNode::Identity(PhaseTransform* phase) {
+Node* DecodeNKlassNode::Identity(PhaseGVN* phase) {
   const Type *t = phase->type( in(1) );
   if( t == Type::TOP ) return in(1);
 
@@ -78,7 +78,7 @@
   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?");
@@ -87,7 +87,7 @@
   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);
 
@@ -98,7 +98,7 @@
   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?");
--- a/hotspot/src/share/vm/opto/narrowptrnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/narrowptrnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -52,8 +52,8 @@
     init_class_id(Class_EncodeP);
   }
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------EncodePKlass--------------------------------
@@ -67,8 +67,8 @@
     init_class_id(Class_EncodePKlass);
   }
   virtual int Opcode() const;
-  virtual Node *Identity( PhaseTransform *phase );
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------DecodeNarrowPtr--------------------------------
@@ -95,8 +95,8 @@
     init_class_id(Class_DecodeN);
   }
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
 };
 
 //------------------------------DecodeNKlass--------------------------------
@@ -110,8 +110,8 @@
     init_class_id(Class_DecodeNKlass);
   }
   virtual int Opcode() const;
-  virtual const Type *Value( PhaseTransform *phase ) const;
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual const Type* Value(PhaseGVN* phase) const;
+  virtual Node* Identity(PhaseGVN* phase);
 };
 
 #endif // SHARE_VM_OPTO_NARROWPTRNODE_HPP
--- a/hotspot/src/share/vm/opto/node.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/node.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -1071,13 +1071,13 @@
 
 //------------------------------Identity---------------------------------------
 // Return a node that the given node is equivalent to.
-Node *Node::Identity( PhaseTransform * ) {
+Node* Node::Identity(PhaseGVN* phase) {
   return this;                  // Default to no identities
 }
 
 //------------------------------Value------------------------------------------
 // Compute a new Type for a node using the Type of the inputs.
-const Type *Node::Value( PhaseTransform * ) const {
+const Type* Node::Value(PhaseGVN* phase) const {
   return bottom_type();         // Default to worst-case Type
 }
 
@@ -2456,7 +2456,7 @@
 uint TypeNode::cmp( const Node &n ) const
 { return !Type::cmp( _type, ((TypeNode&)n)._type ); }
 const Type *TypeNode::bottom_type() const { return _type; }
-const Type *TypeNode::Value( PhaseTransform * ) const { return _type; }
+const Type* TypeNode::Value(PhaseGVN* phase) const { return _type; }
 
 //------------------------------ideal_reg--------------------------------------
 uint TypeNode::ideal_reg() const {
--- a/hotspot/src/share/vm/opto/node.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/node.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -926,10 +926,10 @@
   // Return an existing node which computes the same function as this node.
   // The optimistic combined algorithm requires this to return a Node which
   // is a small number of steps away (e.g., one of my inputs).
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // Return the set of values this Node can take on at runtime.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 
   // Return a node which is more "ideal" than the current node.
   // The invariants on this call are subtle.  If in doubt, read the
@@ -1696,7 +1696,7 @@
   TypeNode( const Type *t, uint required ) : Node(required), _type(t) {
     init_class_id(Class_Type);
   }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *bottom_type() const;
   virtual       uint  ideal_reg() const;
 #ifndef PRODUCT
--- a/hotspot/src/share/vm/opto/opaquenode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/opaquenode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -40,7 +40,7 @@
 // call to IterGVN and any chance of hitting this code.  Hence there's no
 // phase-ordering problem with stripping Opaque1 in IGVN followed by some
 // more loop optimizations that require it.
-Node *Opaque1Node::Identity( PhaseTransform *phase ) {
+Node* Opaque1Node::Identity(PhaseGVN* phase) {
   return phase->C->major_progress() ? this : in(1);
 }
 
@@ -76,7 +76,7 @@
   }
 }
 
-Node *ProfileBooleanNode::Identity( PhaseTransform *phase ) {
+Node* ProfileBooleanNode::Identity(PhaseGVN* phase) {
   if (_delay_removal) {
     return this;
   } else {
--- a/hotspot/src/share/vm/opto/opaquenode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/opaquenode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -50,7 +50,7 @@
   Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }
   virtual int Opcode() const;
   virtual const Type *bottom_type() const { return TypeInt::INT; }
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 };
 
 //------------------------------Opaque2Node------------------------------------
@@ -109,7 +109,7 @@
 
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual Node *Identity(PhaseTransform *phase);
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
 };
 
--- a/hotspot/src/share/vm/opto/rootnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/rootnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -79,7 +79,7 @@
 }
 
 //------------------------------Value------------------------------------------
-const Type *HaltNode::Value( PhaseTransform *phase ) const {
+const Type* HaltNode::Value(PhaseGVN* phase) const {
   return ( phase->type(in(TypeFunc::Control)) == Type::TOP)
     ? Type::TOP
     : Type::BOTTOM;
--- a/hotspot/src/share/vm/opto/rootnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/rootnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -42,9 +42,9 @@
   virtual int   Opcode() const;
   virtual const Node *is_block_proj() const { return this; }
   virtual const Type *bottom_type() const { return Type::BOTTOM; }
-  virtual Node *Identity( PhaseTransform *phase ) { return this; }
+  virtual Node* Identity(PhaseGVN* phase) { return this; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual const Type *Value( PhaseTransform *phase ) const { return Type::BOTTOM; }
+  virtual const Type* Value(PhaseGVN* phase) const { return Type::BOTTOM; }
 };
 
 //------------------------------HaltNode---------------------------------------
@@ -55,7 +55,7 @@
   virtual int Opcode() const;
   virtual bool  pinned() const { return true; };
   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;
   virtual bool  is_CFG() const { return true; }
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
--- a/hotspot/src/share/vm/opto/stringopts.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/stringopts.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -822,11 +822,10 @@
             }
           } else if (ctrl->is_IfTrue()) { // null checks, class checks
             iff = ctrl->in(0)->as_If();
-            assert(iff->is_If(), "must be if");
             // Verify that the other arm is an uncommon trap
             Node* otherproj = iff->proj_out(1 - ctrl->as_Proj()->_con);
             CallStaticJavaNode* call = otherproj->unique_out()->isa_CallStaticJava();
-            assert(strcmp(call->_name, "uncommon_trap") == 0, "must be uncommond trap");
+            assert(strcmp(call->_name, "uncommon_trap") == 0, "must be uncommon trap");
             ctrl = iff->in(0);
           } else {
             break;
@@ -914,6 +913,13 @@
       BoolNode* b = iff->in(1)->isa_Bool();
 
       if (b == NULL) {
+#ifndef PRODUCT
+        if (PrintOptimizeStringConcat) {
+          tty->print_cr("unexpected input to IfNode");
+          iff->in(1)->dump();
+          tty->cr();
+        }
+#endif
         fail = true;
         break;
       }
--- a/hotspot/src/share/vm/opto/subnode.cpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/subnode.cpp	Tue Jan 12 15:07:46 2016 +0100
@@ -46,7 +46,7 @@
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If right input is a constant 0, return the left input.
-Node *SubNode::Identity( PhaseTransform *phase ) {
+Node* SubNode::Identity(PhaseGVN* phase) {
   assert(in(1) != this, "Must already have called Value");
   assert(in(2) != this, "Must already have called Value");
 
@@ -100,7 +100,7 @@
   return NULL;
 }
 
-const Type* SubNode::Value(PhaseTransform *phase) const {
+const Type* SubNode::Value(PhaseGVN* phase) const {
   const Type* t = Value_common(phase);
   if (t != NULL) {
     return t;
@@ -378,7 +378,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // A subtract node differences its two inputs.
-const Type *SubFPNode::Value( PhaseTransform *phase ) const {
+const Type* SubFPNode::Value(PhaseGVN* phase) const {
   const Node* in1 = in(1);
   const Node* in2 = in(2);
   // Either input is TOP ==> the result is TOP
@@ -494,7 +494,7 @@
 // Unlike SubNodes, compare must still flatten return value to the
 // range -1, 0, 1.
 // And optimizations like those for (X + Y) - X fail if overflow happens.
-Node *CmpNode::Identity( PhaseTransform *phase ) {
+Node* CmpNode::Identity(PhaseGVN* phase) {
   return this;
 }
 
@@ -611,7 +611,7 @@
   return TypeInt::CC;                   // else use worst case results
 }
 
-const Type* CmpUNode::Value(PhaseTransform *phase) const {
+const Type* CmpUNode::Value(PhaseGVN* phase) const {
   const Type* t = SubNode::Value_common(phase);
   if (t != NULL) {
     return t;
@@ -1053,7 +1053,7 @@
 //------------------------------Value------------------------------------------
 // Simplify an CmpF (compare 2 floats ) node, based on local information.
 // If both inputs are constants, compare them.
-const Type *CmpFNode::Value( PhaseTransform *phase ) const {
+const Type* CmpFNode::Value(PhaseGVN* phase) const {
   const Node* in1 = in(1);
   const Node* in2 = in(2);
   // Either input is TOP ==> the result is TOP
@@ -1083,7 +1083,7 @@
 //------------------------------Value------------------------------------------
 // Simplify an CmpD (compare 2 doubles ) node, based on local information.
 // If both inputs are constants, compare them.
-const Type *CmpDNode::Value( PhaseTransform *phase ) const {
+const Type* CmpDNode::Value(PhaseGVN* phase) const {
   const Node* in1 = in(1);
   const Node* in2 = in(2);
   // Either input is TOP ==> the result is TOP
@@ -1423,7 +1423,7 @@
 //------------------------------Value------------------------------------------
 // Simplify a Bool (convert condition codes to boolean (1 or 0)) node,
 // based on local information.   If the input is constant, do it.
-const Type *BoolNode::Value( PhaseTransform *phase ) const {
+const Type* BoolNode::Value(PhaseGVN* phase) const {
   return _test.cc2logical( phase->type( in(1) ) );
 }
 
@@ -1466,7 +1466,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Compute sqrt
-const Type *SqrtDNode::Value( PhaseTransform *phase ) const {
+const Type* SqrtDNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   if( t1 == Type::TOP ) return Type::TOP;
   if( t1->base() != Type::DoubleCon ) return Type::DOUBLE;
@@ -1478,7 +1478,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Compute tan
-const Type *TanDNode::Value( PhaseTransform *phase ) const {
+const Type* TanDNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   if( t1 == Type::TOP ) return Type::TOP;
   if( t1->base() != Type::DoubleCon ) return Type::DOUBLE;
@@ -1489,7 +1489,7 @@
 //=============================================================================
 //------------------------------Value------------------------------------------
 // Compute log10
-const Type *Log10DNode::Value( PhaseTransform *phase ) const {
+const Type* Log10DNode::Value(PhaseGVN* phase) const {
   const Type *t1 = phase->type( in(1) );
   if( t1 == Type::TOP ) return Type::TOP;
   if( t1->base() != Type::DoubleCon ) return Type::DOUBLE;
--- a/hotspot/src/share/vm/opto/subnode.hpp	Tue Jan 12 13:57:48 2016 +0300
+++ b/hotspot/src/share/vm/opto/subnode.hpp	Tue Jan 12 15:07:46 2016 +0100
@@ -45,11 +45,11 @@
 
   // Handle algebraic identities here.  If we have an identity, return the Node
   // we are equivalent to.  We look for "add of zero" as an identity.
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
 
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
   const Type* Value_common( PhaseTransform *phase ) const;
 
   // Supplied function returns the subtractend of the inputs.
@@ -97,7 +97,7 @@
 protected:
   SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
 public:
-  const Type *Value( PhaseTransform *phase ) const;
+  const Type* Value(PhaseGVN* phase) const;
 };
 
 // NOTE: SubFNode should be taken away and replaced by add and negate
@@ -135,7 +135,7 @@
   CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {
     init_class_id(Class_Cmp);
   }
-  virtual Node *Identity( PhaseTransform *phase );
+  virtual Node* Identity(PhaseGVN* phase);
   const Type *add_id() const { return TypeInt::ZERO; }
   const Type *bottom_type() const { return TypeInt::CC; }
   virtual uint ideal_reg() const { return Op_RegFlags; }
@@ -165,7 +165,7 @@
   CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const;
-  const Type *Value( PhaseTransform *phase ) const;
+  const Type* Value(PhaseGVN* phase) const;
   bool is_index_range_check() const;
 };
 
@@ -219,7 +219,7 @@
   CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
-  const Type *Value( PhaseTransform *phase ) const;
+  const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------CmpF3Node--------------------------------------
@@ -247,7 +247,7 @@
   CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
-  const Type *Value( PhaseTransform *phase ) const;
+  const Type* Value(PhaseGVN* phase) const;
   virtual Node  *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 
@@ -309,7 +309,7 @@
   BoolNode* negate(PhaseGVN* phase);
   virtual int Opcode() const;
   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::BOOL; }
   uint match_edge(uint idx) const { return 0; }
   virtual uint ideal_reg() const { return Op_RegI; }
@@ -419,7 +419,7 @@
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 
@@ -445,7 +445,7 @@
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------Log10DNode---------------------------------------
@@ -459,7 +459,7 @@
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
-  virtual const Type *Value( PhaseTransform *phase ) const;
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //-------------------------------ReverseBytesINode--------------------------------