hotspot/src/share/vm/opto/macro.cpp
changeset 2029 4ba79339bc0c
parent 1677 f632e4c20c3e
child 2110 40e42c95ac39
child 2105 347008ce7984
equal deleted inserted replaced
2028:04fa713b25f9 2029:4ba79339bc0c
   950   Node* i_o  = alloc->in(TypeFunc::I_O);
   950   Node* i_o  = alloc->in(TypeFunc::I_O);
   951   Node* size_in_bytes     = alloc->in(AllocateNode::AllocSize);
   951   Node* size_in_bytes     = alloc->in(AllocateNode::AllocSize);
   952   Node* klass_node        = alloc->in(AllocateNode::KlassNode);
   952   Node* klass_node        = alloc->in(AllocateNode::KlassNode);
   953   Node* initial_slow_test = alloc->in(AllocateNode::InitialTest);
   953   Node* initial_slow_test = alloc->in(AllocateNode::InitialTest);
   954 
   954 
   955   // With escape analysis, the entire memory state was needed to be able to
       
   956   // eliminate the allocation.  Since the allocations cannot be eliminated,
       
   957   // optimize it to the raw slice.
       
   958   if (mem->is_MergeMem()) {
       
   959     mem = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw);
       
   960   }
       
   961 
       
   962   assert(ctrl != NULL, "must have control");
   955   assert(ctrl != NULL, "must have control");
   963   // We need a Region and corresponding Phi's to merge the slow-path and fast-path results.
   956   // We need a Region and corresponding Phi's to merge the slow-path and fast-path results.
   964   // they will not be used if "always_slow" is set
   957   // they will not be used if "always_slow" is set
   965   enum { slow_result_path = 1, fast_result_path = 2 };
   958   enum { slow_result_path = 1, fast_result_path = 2 };
   966   Node *result_region;
   959   Node *result_region;
  1014   }
  1007   }
  1015 
  1008 
  1016   Node *slow_mem = mem;  // save the current memory state for slow path
  1009   Node *slow_mem = mem;  // save the current memory state for slow path
  1017   // generate the fast allocation code unless we know that the initial test will always go slow
  1010   // generate the fast allocation code unless we know that the initial test will always go slow
  1018   if (!always_slow) {
  1011   if (!always_slow) {
       
  1012     // Fast path modifies only raw memory.
       
  1013     if (mem->is_MergeMem()) {
       
  1014       mem = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw);
       
  1015     }
       
  1016 
  1019     Node* eden_top_adr;
  1017     Node* eden_top_adr;
  1020     Node* eden_end_adr;
  1018     Node* eden_end_adr;
  1021 
  1019 
  1022     set_eden_pointers(eden_top_adr, eden_end_adr);
  1020     set_eden_pointers(eden_top_adr, eden_end_adr);
  1023 
  1021 
  1236       _igvn._worklist.push(use);
  1234       _igvn._worklist.push(use);
  1237       // back up iterator
  1235       // back up iterator
  1238       --i;
  1236       --i;
  1239     }
  1237     }
  1240   }
  1238   }
  1241 
       
  1242   mem = result_phi_rawmem;
       
  1243 
  1239 
  1244   // An allocate node has separate i_o projections for the uses on the control and i_o paths
  1240   // An allocate node has separate i_o projections for the uses on the control and i_o paths
  1245   // Replace uses of the control i_o projection with result_phi_i_o (unless we are only generating a slow call)
  1241   // Replace uses of the control i_o projection with result_phi_i_o (unless we are only generating a slow call)
  1246   if (_ioproj_fallthrough == NULL) {
  1242   if (_ioproj_fallthrough == NULL) {
  1247     _ioproj_fallthrough = new (C, 1) ProjNode(call, TypeFunc::I_O);
  1243     _ioproj_fallthrough = new (C, 1) ProjNode(call, TypeFunc::I_O);