*** old/src/share/vm/opto/cfgnode.cpp	Wed Jul 20 14:06:31 2011
--- new/src/share/vm/opto/cfgnode.cpp	Wed Jul 20 14:06:31 2011

*** 1347,1367 ****
--- 1347,1359 ----
  //------------------------------split_once-------------------------------------
  // Helper for split_flow_path
  static void split_once(PhaseIterGVN *igvn, Node *phi, Node *val, Node *n, Node *newn) {
    igvn->hash_delete(n);         // Remove from hash before hacking edges
  
    Node* predicate_proj = NULL;
    uint j = 1;
    for (uint i = phi->req()-1; i > 0; i--) {
      if (phi->in(i) == val) {   // Found a path with val?
        if (n->is_Region()) {
          Node* proj = PhaseIdealLoop::find_predicate(n->in(i));
          if (proj != NULL) {
            assert(predicate_proj == NULL, "only one predicate entry expected");
            predicate_proj = proj;
          }
        }
        // Add to NEW Region/Phi, no DU info
        newn->set_req( j++, n->in(i) );
        // Remove from OLD Region/Phi
        n->del_req(i);
      }

*** 1369,1383 ****
--- 1361,1370 ----
  
    // Register the new node but do not transform it.  Cannot transform until the
    // entire Region/Phi conglomerate has been hacked as a single huge transform.
    igvn->register_new_node_with_optimizer( newn );
  
    // Clone loop predicates
    if (predicate_proj != NULL) {
      newn = igvn->clone_loop_predicates(predicate_proj, newn, !n->is_CountedLoop());
    }
  
    // Now I can point to the new node.
    n->add_req(newn);
    igvn->_worklist.push(n);
  }
  

*** 1402,1428 ****
--- 1389,1419 ----
    if( i >= phi->req() )         // Only split for constants
      return NULL;
  
    Node *val = phi->in(i);       // Constant to split for
    uint hit = 0;                 // Number of times it occurs
+   Node *r = phi->region();
  
    for( ; i < phi->req(); i++ ){ // Count occurrences of constant
      Node *n = phi->in(i);
      if( !n ) return NULL;
      if( phase->type(n) == Type::TOP ) return NULL;
!     if( phi->in(i) == val ) {
        hit++;
+       if (PhaseIdealLoop::find_predicate(r->in(i)) != NULL) {
+         return NULL;            // don't split loop entry path
        }
+     }
+   }
  
    if( hit <= 1 ||               // Make sure we find 2 or more
        hit == phi->req()-1 )     // and not ALL the same value
      return NULL;
  
    // Now start splitting out the flow paths that merge the same value.
    // Split first the RegionNode.
    PhaseIterGVN *igvn = phase->is_IterGVN();
    Node *r = phi->region();
    RegionNode *newr = new (phase->C, hit+1) RegionNode(hit+1);
    split_once(igvn, phi, val, r, newr);
  
    // Now split all other Phis than this one
    for (DUIterator_Fast kmax, k = r->fast_outs(kmax); k < kmax; k++) {