src/hotspot/share/opto/phaseX.cpp

*** 1223,22 ***
  }
  
  //------------------------------transform--------------------------------------
  // Non-recursive: idealize Node 'n' with respect to its inputs and its value
  Node *PhaseIterGVN::transform( Node *n ) {
-   if (_delay_transform) {
-     // Register the node but don't optimize for now
-     register_new_node_with_optimizer(n);
-     return n;
-   }
- 
    // If brand new node, make space in type array, and give it a type.
    ensure_type_or_null(n);
    if (type_or_null(n) == NULL) {
      set_type_bottom(n);
    }
  
    return transform_old(n);
  }
  
  Node *PhaseIterGVN::transform_old(Node* n) {
    NOT_PRODUCT(set_transforms());
--- 1223,22 ---
  }
  
  //------------------------------transform--------------------------------------
  // Non-recursive: idealize Node 'n' with respect to its inputs and its value
  Node *PhaseIterGVN::transform( Node *n ) {
    // If brand new node, make space in type array, and give it a type.
    ensure_type_or_null(n);
    if (type_or_null(n) == NULL) {
      set_type_bottom(n);
    }
  
+   if (_delay_transform) {
+     // Add the node to the worklist but don't optimize for now
+     _worklist.push(n);
+     return n;
+   }
+ 
    return transform_old(n);
  }
  
  Node *PhaseIterGVN::transform_old(Node* n) {
    NOT_PRODUCT(set_transforms());

*** 1502,10 ***
--- 1502,23 ---
    }
  #endif
    temp->destruct(this);     // reuse the _idx of this little guy
  }
  
+ void PhaseIterGVN::replace_in_uses(Node* n, Node* m) {
+   assert(n != NULL, "sanity");
+   for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
+     Node* u = n->fast_out(i);
+     if (u != n) {
+       rehash_node_delayed(u);
+       int nb = u->replace_edge(n, m);
+       --i, imax -= nb;
+     }
+   }
+   assert(n->outcnt() == 0, "all uses must be deleted");
+ }
+ 
  //------------------------------add_users_to_worklist--------------------------
  void PhaseIterGVN::add_users_to_worklist0( Node *n ) {
    for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
      _worklist.push(n->fast_out(i));  // Push on worklist
    }

*** 1602,10 ***
--- 1615,19 ---
            }
          }
        }
      }
  
+     // Inline type nodes can have other inline types as users. If an input gets
+     // updated, make sure that inline type users get a chance for optimization.
+     if (use->is_InlineType()) {
+       for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) {
+         Node* u = use->fast_out(i2);
+         if (u->is_InlineType())
+           _worklist.push(u);
+       }
+     }
      // If changed Cast input, check Phi users for simple cycles
      if (use->is_ConstraintCast()) {
        for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) {
          Node* u = use->fast_out(i2);
          if (u->is_Phi())

*** 1657,10 ***
--- 1679,18 ---
  
      if (use_op == Op_Initialize) {
        Node* imem = use->as_Initialize()->proj_out_or_null(TypeFunc::Memory);
        if (imem != NULL)  add_users_to_worklist0(imem);
      }
+     if (use_op == Op_CastP2X) {
+       for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) {
+         Node* u = use->fast_out(i2);
+         if (u->Opcode() == Op_AndX) {
+           _worklist.push(u);
+         }
+       }
+     }
      // Loading the java mirror from a Klass requires two loads and the type
      // of the mirror load depends on the type of 'n'. See LoadNode::Value().
      //   LoadBarrier?(LoadP(LoadP(AddP(foo:Klass, #java_mirror))))
      BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
      bool has_load_barrier_nodes = bs->has_load_barrier_nodes();

*** 1681,10 ***
--- 1711,21 ---
            }
            _worklist.push(u);
          }
        }
      }
+ 
+     // Give CallStaticJavaNode::remove_useless_allocation a chance to run
+     if (use->is_Region()) {
+       Node* c = use;
+       do {
+         c = c->unique_ctrl_out_or_null();
+       } while (c != NULL && c->is_Region());
+       if (c != NULL && c->is_CallStaticJava() && c->as_CallStaticJava()->uncommon_trap_request() != 0) {
+         _worklist.push(c);
+       }
+     }
      if (use->Opcode() == Op_OpaqueZeroTripGuard) {
        assert(use->outcnt() <= 1, "OpaqueZeroTripGuard can't be shared");
        if (use->outcnt() == 1) {
          Node* cmp = use->unique_out();
          _worklist.push(cmp);

*** 1903,10 ***
--- 1944,11 ---
  void PhaseCCP::push_more_uses(Unique_Node_List& worklist, Node* parent, const Node* use) const {
    push_phis(worklist, use);
    push_catch(worklist, use);
    push_cmpu(worklist, use);
    push_counted_loop_phi(worklist, parent, use);
+   push_cast(worklist, use);
    push_loadp(worklist, use);
    push_and(worklist, parent, use);
    push_cast_ii(worklist, parent, use);
    push_opaque_zero_trip_guard(worklist, use);
  }

*** 1964,10 ***
--- 2006,22 ---
        worklist.push(phi);
      }
    }
  }
  
+ void PhaseCCP::push_cast(Unique_Node_List& worklist, const Node* use) {
+   uint use_op = use->Opcode();
+   if (use_op == Op_CastP2X) {
+     for (DUIterator_Fast i2max, i2 = use->fast_outs(i2max); i2 < i2max; i2++) {
+       Node* u = use->fast_out(i2);
+       if (u->Opcode() == Op_AndX) {
+         worklist.push(u);
+       }
+     }
+   }
+ }
+ 
  // Loading the java mirror from a Klass requires two loads and the type of the mirror load depends on the type of 'n'.
  // See LoadNode::Value().
  void PhaseCCP::push_loadp(Unique_Node_List& worklist, const Node* use) const {
    BarrierSetC2* barrier_set = BarrierSet::barrier_set()->barrier_set_c2();
    bool has_load_barrier_nodes = barrier_set->has_load_barrier_nodes();