*** old/src/share/vm/opto/graphKit.cpp	Mon May  6 18:14:22 2013
--- new/src/share/vm/opto/graphKit.cpp	Mon May  6 18:14:22 2013

*** 331,340 ****
--- 331,341 ----
    JVMState* ex_jvms = ex_map->_jvms;
    assert(ex_jvms->same_calls_as(phi_map->_jvms), "consistent call chains");
    assert(ex_jvms->stkoff() == phi_map->_jvms->stkoff(), "matching locals");
    assert(ex_jvms->sp() == phi_map->_jvms->sp(), "matching stack sizes");
    assert(ex_jvms->monoff() == phi_map->_jvms->monoff(), "matching JVMS");
+   assert(ex_jvms->scloff() == phi_map->_jvms->scloff(), "matching scalar replaced objects");
    assert(ex_map->req() == phi_map->req(), "matching maps");
    uint tos = ex_jvms->stkoff() + ex_jvms->sp();
    Node*         hidden_merge_mark = root();
    Node*         region  = phi_map->control();
    MergeMemNode* phi_mem = phi_map->merged_memory();

*** 407,417 ****
--- 408,418 ----
          phi_map->set_req(i, dst);
          // Prepare to append interesting stuff onto the new phi:
          while (dst->req() > orig_width)  dst->del_req(dst->req()-1);
        } else {
          assert(dst->is_Phi(), "nobody else uses a hidden region");
!         phi = (PhiNode*)dst;
!         phi = dst->as_Phi();
        }
        if (add_multiple && src->in(0) == ex_control) {
          // Both are phis.
          add_n_reqs(dst, src);
        } else {

*** 1436,1446 ****
--- 1437,1452 ----
    if (require_atomic_access && bt == T_LONG) {
      ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t);
    } else {
      ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt);
    }
!   return _gvn.transform(ld);
!   ld = _gvn.transform(ld);
+   if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) {
+     // Improve graph before escape analysis and boxing elimination.
+     record_for_igvn(ld);
+   }
+   return ld;
  }
  
  Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt,
                                  int adr_idx,
                                  bool require_atomic_access) {

*** 3142,3152 ****
--- 3148,3158 ----
    // since GC and deoptimization can happened.
    Node *mem = reset_memory();
    set_all_memory(mem); // Create new memory state
  
    AllocateNode* alloc
!     = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
                             control(), mem, i_o(),
                             size, klass_node,
                             initial_slow_test);
  
    return set_output_for_allocation(alloc, oop_type);

*** 3283,3293 ****
--- 3289,3299 ----
    Node *mem = reset_memory();
    set_all_memory(mem); // Create new memory state
  
    // Create the AllocateArrayNode and its result projections
    AllocateArrayNode* alloc
!     = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
                                  control(), mem, i_o(),
                                  size, klass_node,
                                  initial_slow_test,
                                  length);
  

*** 3324,3337 ****
--- 3330,3342 ----
  // Given an oop pointer or raw pointer, see if it feeds from an AllocateNode.
  AllocateNode* AllocateNode::Ideal_allocation(Node* ptr, PhaseTransform* phase) {
    if (ptr == NULL) {     // reduce dumb test in callers
      return NULL;
    }
!   if (ptr->is_CheckCastPP()) {  // strip a raw-to-oop cast
      ptr = ptr->in(1);
!   ptr = ptr->uncast();  // strip a raw-to-oop cast
    if (ptr == NULL)  return NULL;
    }
+ 
    if (ptr->is_Proj()) {
      Node* allo = ptr->in(0);
      if (allo != NULL && allo->is_Allocate()) {
        return allo->as_Allocate();
      }

*** 3372,3394 ****
--- 3377,3386 ----
      }
    }
    return NULL;
  }
  
  // Trace Allocate -> Proj[Parm] -> MemBarStoreStore
  MemBarStoreStoreNode* AllocateNode::storestore() {
    ProjNode* rawoop = proj_out(AllocateNode::RawAddress);
    if (rawoop == NULL)  return NULL;
    for (DUIterator_Fast imax, i = rawoop->fast_outs(imax); i < imax; i++) {
      Node* storestore = rawoop->fast_out(i);
      if (storestore->is_MemBarStoreStore()) {
        return storestore->as_MemBarStoreStore();
      }
    }
    return NULL;
  }
  
  //----------------------------- loop predicates ---------------------------
  
  //------------------------------add_predicate_impl----------------------------
  void GraphKit::add_predicate_impl(Deoptimization::DeoptReason reason, int nargs) {
    // Too many traps seen?