< prev index next >

src/share/vm/opto/cfgnode.cpp

Print this page

        

@@ -45,11 +45,11 @@
 // Optimization - Graph Style
 
 //=============================================================================
 //------------------------------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
     if( phase->type(n) == Type::CONTROL )
       return Type::CONTROL;

@@ -57,11 +57,11 @@
   return Type::TOP;             // All paths dead?  Then so are we
 }
 
 //------------------------------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
   return this;
 }

@@ -889,11 +889,11 @@
 #endif
 
 
 //------------------------------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;
 
   // Note: During parsing, phis are often transformed before their regions.

@@ -1140,11 +1140,11 @@
   return id;
 }
 
 //------------------------------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
   // trivially, perhaps with a single cast.  The unique_input method
   // does all this and more, by reducing such tributaries to 'this'.)

@@ -2046,17 +2046,17 @@
 }
 #endif
 
 
 //=============================================================================
-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
 }
 
 const RegMask &GotoNode::out_RegMask() const {
   return RegMask::Empty;

@@ -2114,11 +2114,11 @@
 }
 
 //------------------------------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
 }
 

@@ -2159,11 +2159,11 @@
 
 //=============================================================================
 //------------------------------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
   const Type** f = TypeTuple::fields(_size);
   for( uint i = 0; i < _size; i++ ) f[i] = Type::CONTROL;

@@ -2203,11 +2203,11 @@
 }
 
 
 //------------------------------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;
   // If we remove the last CatchProj and elide the Catch/CatchProj, then we
   // also remove any exception table entry.  Thus we must know the call

@@ -2246,11 +2246,11 @@
 #endif
 
 //=============================================================================
 //------------------------------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.
   // If the CatchProj is optimized away, then we just carry the
   // exception oop through.

@@ -2262,11 +2262,11 @@
 }
 
 //=============================================================================
 //------------------------------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();
 }
 
 //------------------------------Ideal------------------------------------------
< prev index next >