truffle: src/share/vm/opto/escape.cpp comparison

comparison src/share/vm/opto/escape.cpp @ 1100:f96a1a986f7b

6895383: JCK test throws NPE for method compiled with Escape Analysis Summary: Add missing checks for MemBar nodes in EA. Reviewed-by: never

author	kvn
date	Wed, 09 Dec 2009 16:40:45 -0800
parents	7ef1d2e14917
children	7fee0a6cc6d4

comparison

equal deleted inserted replaced

-:c5d3d979ae27
+:f96a1a986f7b
 if (un != NULL) {
 result = un;
 } else {
 break;
 }
+} else if (result->is_ClearArray()) {
+if (!ClearArrayNode::step_through(&result, (uint)tinst->instance_id(), phase)) {
+// Can not bypass initialization of the instance
+// we are looking for.
+break;
+}
+// Otherwise skip it (the call updated 'result' value).
 } else if (result->Opcode() == Op_SCMemProj) {
 assert(result->in(0)->is_LoadStore(), "sanity");
 const Type *at = phase->type(result->in(0)->in(MemNode::Address));
 if (at != Type::TOP) {
 assert (at->isa_ptr() != NULL, "pointer type required.");
 }
 }
 // the result is either MemNode, PhiNode, InitializeNode.
 return result;
 }
 //
 //  Convert the types of unescaped object to instance types where possible,
 //  propagate the new type information through the graph, and update memory
 //  edges and MergeMem inputs to reflect the new type.
 //    90  LoadP    _ 120  30   ... alias_index=6
 //   100  LoadP    _  80  20   ... alias_index=4
 //
 void ConnectionGraph::split_unique_types(GrowableArray<Node *>  &alloc_worklist) {
 GrowableArray<Node *>  memnode_worklist;
-GrowableArray<Node *>  mergemem_worklist;
 GrowableArray<PhiNode *>  orig_phis;
 PhaseGVN  *igvn = _compile->initial_gvn();
 uint new_index_start = (uint) _compile->num_alias_types();
 VectorSet visited(Thread::current()->resource_area());
 VectorSet ptset(Thread::current()->resource_area());
 if (addp2 != NULL) {
 assert(alloc->is_AllocateArray(),"array allocation was expected");
 alloc_worklist.append_if_missing(addp2);
 }
 alloc_worklist.append_if_missing(use);
-} else if (use->is_Initialize()) {
+} else if (use->is_MemBar()) {
 memnode_worklist.append_if_missing(use);
 }
 }
 }
 } else if (n->is_AddP()) {
 ptset.Clear();
 PointsTo(ptset, get_addp_base(n), igvn);
 assert(ptset.Size() == 1, "AddP address is unique");
 uint elem = ptset.getelem(); // Allocation node's index
-if (elem == _phantom_object)
+if (elem == _phantom_object) {
+assert(false, "escaped allocation");
 continue; // Assume the value was set outside this method.
+}
 Node *base = get_map(elem);  // CheckCastPP node
-if (!split_AddP(n, base, igvn)) continue; // wrong type
+if (!split_AddP(n, base, igvn)) continue; // wrong type from dead path
 tinst = igvn->type(base)->isa_oopptr();
 } else if (n->is_Phi() ||
 n->is_CheckCastPP() ||
 n->is_EncodeP() ||
 n->is_DecodeN() ||
 }
 ptset.Clear();
 PointsTo(ptset, n, igvn);
 if (ptset.Size() == 1) {
 uint elem = ptset.getelem(); // Allocation node's index
-if (elem == _phantom_object)
+if (elem == _phantom_object) {
+assert(false, "escaped allocation");
 continue; // Assume the value was set outside this method.
+}
 Node *val = get_map(elem);   // CheckCastPP node
 TypeNode *tn = n->as_Type();
 tinst = igvn->type(val)->isa_oopptr();
 assert(tinst != NULL && tinst->is_known_instance() &&
 (uint)tinst->instance_id() == elem , "instance type expected.");
 tn_t = tn_type->make_ptr()->isa_oopptr();
 } else {
 tn_t = tn_type->isa_oopptr();
 }
-if (tn_t != NULL &&
+if (tn_t != NULL && tinst->klass()->is_subtype_of(tn_t->klass())) {
-tinst->cast_to_instance_id(TypeOopPtr::InstanceBot)->higher_equal(tn_t)) {
 if (tn_type->isa_narrowoop()) {
 tn_type = tinst->make_narrowoop();
 } else {
 tn_type = tinst;
 }
 igvn->set_type(tn, tn_type);
 tn->set_type(tn_type);
 igvn->hash_insert(tn);
 record_for_optimizer(n);
 } else {
-continue; // wrong type
+assert(tn_type == TypePtr::NULL_PTR ||
+tn_t != NULL && !tinst->klass()->is_subtype_of(tn_t->klass()),
+"unexpected type");
+continue; // Skip dead path with different type
 }
 }
 } else {
+debug_only(n->dump();)
+assert(false, "EA: unexpected node");
 continue;
 }
-// push users on appropriate worklist
+// push allocation's users on appropriate worklist
 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
 Node *use = n->fast_out(i);
 if(use->is_Mem() && use->in(MemNode::Address) == n) {
+// Load/store to instance's field
 memnode_worklist.append_if_missing(use);
-} else if (use->is_Initialize()) {
+} else if (use->is_MemBar()) {
 memnode_worklist.append_if_missing(use);
-} else if (use->is_MergeMem()) {
-mergemem_worklist.append_if_missing(use);
-} else if (use->is_SafePoint() && tinst != NULL) {
-// Look for MergeMem nodes for calls which reference unique allocation
-// (through CheckCastPP nodes) even for debug info.
-Node* m = use->in(TypeFunc::Memory);
-uint iid = tinst->instance_id();
-while (m->is_Proj() && m->in(0)->is_SafePoint() &&
-m->in(0) != use && !m->in(0)->_idx != iid) {
-m = m->in(0)->in(TypeFunc::Memory);
-}
-if (m->is_MergeMem()) {
-mergemem_worklist.append_if_missing(m);
-}
 } else if (use->is_AddP() && use->outcnt() > 0) { // No dead nodes
 Node* addp2 = find_second_addp(use, n);
 if (addp2 != NULL) {
 alloc_worklist.append_if_missing(addp2);
 }
 use->is_CheckCastPP() ||
 use->is_EncodeP() ||
 use->is_DecodeN() ||
 (use->is_ConstraintCast() && use->Opcode() == Op_CastPP)) {
 alloc_worklist.append_if_missing(use);
+#ifdef ASSERT
+} else if (use->is_Mem()) {
+assert(use->in(MemNode::Address) != n, "EA: missing allocation reference path");
+} else if (use->is_MergeMem()) {
+assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
+} else if (use->is_SafePoint()) {
+// Look for MergeMem nodes for calls which reference unique allocation
+// (through CheckCastPP nodes) even for debug info.
+Node* m = use->in(TypeFunc::Memory);
+if (m->is_MergeMem()) {
+assert(_mergemem_worklist.contains(m->as_MergeMem()), "EA: missing MergeMem node in the worklist");
+}
+} else {
+uint op = use->Opcode();
+if (!(op == Op_CmpP || op == Op_Conv2B ||
+op == Op_CastP2X || op == Op_StoreCM ||
+op == Op_FastLock || op == Op_AryEq || op == Op_StrComp ||
+op == Op_StrEquals || op == Op_StrIndexOf)) {
+n->dump();
+use->dump();
+assert(false, "EA: missing allocation reference path");
+}
+#endif
 }
 }
 }
 // New alias types were created in split_AddP().
 while (memnode_worklist.length() != 0) {
 Node *n = memnode_worklist.pop();
 if (visited.test_set(n->_idx))
 continue;
-if (n->is_Phi()) {
+if (n->is_Phi() || n->is_ClearArray()) {
-assert(n->as_Phi()->adr_type() != TypePtr::BOTTOM, "narrow memory slice required");
+// we don't need to do anything, but the users must be pushed
-// we don't need to do anything, but the users must be pushed if we haven't processed
+} else if (n->is_MemBar()) { // Initialize, MemBar nodes
-// this Phi before
+// we don't need to do anything, but the users must be pushed
-} else if (n->is_Initialize()) {
+n = n->as_MemBar()->proj_out(TypeFunc::Memory);
-// we don't need to do anything, but the users of the memory projection must be pushed
-n = n->as_Initialize()->proj_out(TypeFunc::Memory);
 if (n == NULL)
 continue;
 } else {
 assert(n->is_Mem(), "memory node required.");
 Node *addr = n->in(MemNode::Address);
 }
 }
 // push user on appropriate worklist
 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
 Node *use = n->fast_out(i);
-if (use->is_Phi()) {
+if (use->is_Phi() || use->is_ClearArray()) {
 memnode_worklist.append_if_missing(use);
 } else if(use->is_Mem() && use->in(MemNode::Memory) == n) {
+if (use->Opcode() == Op_StoreCM) // Ignore cardmark stores
+continue;
 memnode_worklist.append_if_missing(use);
-} else if (use->is_Initialize()) {
+} else if (use->is_MemBar()) {
 memnode_worklist.append_if_missing(use);
+#ifdef ASSERT
+} else if(use->is_Mem()) {
+assert(use->in(MemNode::Memory) != n, "EA: missing memory path");
 } else if (use->is_MergeMem()) {
-mergemem_worklist.append_if_missing(use);
+assert(_mergemem_worklist.contains(use->as_MergeMem()), "EA: missing MergeMem node in the worklist");
+} else {
+uint op = use->Opcode();
+if (!(op == Op_StoreCM ||
+(op == Op_CallLeaf && use->as_CallLeaf()->_name != NULL &&
+strcmp(use->as_CallLeaf()->_name, "g1_wb_pre") == 0) ||
+op == Op_AryEq || op == Op_StrComp ||
+op == Op_StrEquals || op == Op_StrIndexOf)) {
+n->dump();
+use->dump();
+assert(false, "EA: missing memory path");
+}
+#endif
 }
 }
 }
 //  Phase 3:  Process MergeMem nodes from mergemem_worklist.
-//            Walk each memory moving the first node encountered of each
+//            Walk each memory slice moving the first node encountered of each
 //            instance type to the the input corresponding to its alias index.
-while (mergemem_worklist.length() != 0) {
+uint length = _mergemem_worklist.length();
-Node *n = mergemem_worklist.pop();
+for( uint next = 0; next < length; ++next ) {
-assert(n->is_MergeMem(), "MergeMem node required.");
+MergeMemNode* nmm = _mergemem_worklist.at(next);
-if (visited.test_set(n->_idx))
+assert(!visited.test_set(nmm->_idx), "should not be visited before");
-continue;
-MergeMemNode *nmm = n->as_MergeMem();
 // Note: we don't want to use MergeMemStream here because we only want to
-//  scan inputs which exist at the start, not ones we add during processing.
+// scan inputs which exist at the start, not ones we add during processing.
+// Note 2: MergeMem may already contains instance memory slices added
+// during find_inst_mem() call when memory nodes were processed above.
+igvn->hash_delete(nmm);
 uint nslices = nmm->req();
-igvn->hash_delete(nmm);
 for (uint i = Compile::AliasIdxRaw+1; i < nslices; i++) {
 Node* mem = nmm->in(i);
 Node* cur = NULL;
 if (mem == NULL || mem->is_top())
 continue;
 nmm->set_memory_at(ni, result);
 }
 }
 igvn->hash_insert(nmm);
 record_for_optimizer(nmm);
-// Propagate new memory slices to following MergeMem nodes.
-for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
-Node *use = n->fast_out(i);
-if (use->is_Call()) {
-CallNode* in = use->as_Call();
-if (in->proj_out(TypeFunc::Memory) != NULL) {
-Node* m = in->proj_out(TypeFunc::Memory);
-for (DUIterator_Fast jmax, j = m->fast_outs(jmax); j < jmax; j++) {
-Node* mm = m->fast_out(j);
-if (mm->is_MergeMem()) {
-mergemem_worklist.append_if_missing(mm);
-}
-}
-}
-if (use->is_Allocate()) {
-use = use->as_Allocate()->initialization();
-if (use == NULL) {
-continue;
-}
-}
-}
-if (use->is_Initialize()) {
-InitializeNode* in = use->as_Initialize();
-if (in->proj_out(TypeFunc::Memory) != NULL) {
-Node* m = in->proj_out(TypeFunc::Memory);
-for (DUIterator_Fast jmax, j = m->fast_outs(jmax); j < jmax; j++) {
-Node* mm = m->fast_out(j);
-if (mm->is_MergeMem()) {
-mergemem_worklist.append_if_missing(mm);
-}
-}
-}
-}
-}
 }
 //  Phase 4:  Update the inputs of non-instance memory Phis and
 //            the Memory input of memnodes
 // First update the inputs of any non-instance Phi's from
 // for an escape status. See process_call_result() below.
 if (n->is_Allocate() || n->is_CallStaticJava() &&
 ptnode_adr(n->_idx)->node_type() == PointsToNode::JavaObject) {
 has_allocations = true;
 }
-if(n->is_AddP())
+if(n->is_AddP()) {
-cg_worklist.append(n->_idx);
+// Collect address nodes which directly reference an allocation.
+// Use them during stage 3 below to build initial connection graph
+// field edges. Other field edges could be added after StoreP/LoadP
+// nodes are processed during stage 4 below.
+Node* base = get_addp_base(n);
+if(base->is_Proj() && base->in(0)->is_Allocate()) {
+cg_worklist.append(n->_idx);
+}
+} else if (n->is_MergeMem()) {
+// Collect all MergeMem nodes to add memory slices for
+// scalar replaceable objects in split_unique_types().
+_mergemem_worklist.append(n->as_MergeMem());
+}
 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
 Node* m = n->fast_out(i);   // Get user
 worklist_init.push(m);
 }
 }
 if (ptn->node_type() != PointsToNode::UnknownType)
 cg_worklist.append(n->_idx); // Collect CG nodes
 }
 }
-VectorSet ptset(Thread::current()->resource_area());
+Arena* arena = Thread::current()->resource_area();
+VectorSet ptset(arena);
 GrowableArray<uint>  deferred_edges;
-VectorSet visited(Thread::current()->resource_area());
+VectorSet visited(arena);
-// 5. Remove deferred edges from the graph and collect
+// 5. Remove deferred edges from the graph and adjust
-//    information needed for type splitting.
+//    escape state of nonescaping objects.
 cg_length = cg_worklist.length();
 for( uint next = 0; next < cg_length; ++next ) {
 int ni = cg_worklist.at(next);
 PointsToNode* ptn = ptnode_adr(ni);
 PointsToNode::NodeType nt = ptn->node_type();
 if (nt == PointsToNode::LocalVar || nt == PointsToNode::Field) {
 remove_deferred(ni, &deferred_edges, &visited);
 Node *n = ptn->_node;
 if (n->is_AddP()) {
-// Search for objects which are not scalar replaceable.
+// Search for objects which are not scalar replaceable
-// Mark their escape state as ArgEscape to propagate the state
+// and adjust their escape state.
-// to referenced objects.
+verify_escape_state(ni, ptset, igvn);
-// Note: currently there are no difference in compiler optimizations
-// for ArgEscape objects and NoEscape objects which are not
-// scalar replaceable.
-int offset = ptn->offset();
-Node *base = get_addp_base(n);
-ptset.Clear();
-PointsTo(ptset, base, igvn);
-int ptset_size = ptset.Size();
-// Check if a field's initializing value is recorded and add
-// a corresponding NULL field's value if it is not recorded.
-// Connection Graph does not record a default initialization by NULL
-// captured by Initialize node.
-//
-// Note: it will disable scalar replacement in some cases:
-//
-//    Point p[] = new Point[1];
-//    p[0] = new Point(); // Will be not scalar replaced
-//
-// but it will save us from incorrect optimizations in next cases:
-//
-//    Point p[] = new Point[1];
-//    if ( x ) p[0] = new Point(); // Will be not scalar replaced
-//
-// Without a control flow analysis we can't distinguish above cases.
-//
-if (offset != Type::OffsetBot && ptset_size == 1) {
-uint elem = ptset.getelem(); // Allocation node's index
-// It does not matter if it is not Allocation node since
-// only non-escaping allocations are scalar replaced.
-if (ptnode_adr(elem)->_node->is_Allocate() &&
-ptnode_adr(elem)->escape_state() == PointsToNode::NoEscape) {
-AllocateNode* alloc = ptnode_adr(elem)->_node->as_Allocate();
-InitializeNode* ini = alloc->initialization();
-Node* value = NULL;
-if (ini != NULL) {
-BasicType ft = UseCompressedOops ? T_NARROWOOP : T_OBJECT;
-Node* store = ini->find_captured_store(offset, type2aelembytes(ft), igvn);
-if (store != NULL && store->is_Store())
-value = store->in(MemNode::ValueIn);
-}
-if (value == NULL || value != ptnode_adr(value->_idx)->_node) {
-// A field's initializing value was not recorded. Add NULL.
-uint null_idx = UseCompressedOops ? _noop_null : _oop_null;
-add_pointsto_edge(ni, null_idx);
-}
-}
-}
-// An object is not scalar replaceable if the field which may point
-// to it has unknown offset (unknown element of an array of objects).
-//
-if (offset == Type::OffsetBot) {
-uint e_cnt = ptn->edge_count();
-for (uint ei = 0; ei < e_cnt; ei++) {
-uint npi = ptn->edge_target(ei);
-set_escape_state(npi, PointsToNode::ArgEscape);
-ptnode_adr(npi)->_scalar_replaceable = false;
-}
-}
-// Currently an object is not scalar replaceable if a LoadStore node
-// access its field since the field value is unknown after it.
-//
-bool has_LoadStore = false;
-for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
-Node *use = n->fast_out(i);
-if (use->is_LoadStore()) {
-has_LoadStore = true;
-break;
-}
-}
-// An object is not scalar replaceable if the address points
-// to unknown field (unknown element for arrays, offset is OffsetBot).
-//
-// Or the address may point to more then one object. This may produce
-// the false positive result (set scalar_replaceable to false)
-// since the flow-insensitive escape analysis can't separate
-// the case when stores overwrite the field's value from the case
-// when stores happened on different control branches.
-//
-if (ptset_size > 1 || ptset_size != 0 &&
-(has_LoadStore || offset == Type::OffsetBot)) {
-for( VectorSetI j(&ptset); j.test(); ++j ) {
-set_escape_state(j.elem, PointsToNode::ArgEscape);
-ptnode_adr(j.elem)->_scalar_replaceable = false;
-}
-}
 }
 }
 }
 // 6. Propagate escape states.
 #endif
 }
 return has_non_escaping_obj;
 }
+// Search for objects which are not scalar replaceable.
+void ConnectionGraph::verify_escape_state(int nidx, VectorSet& ptset, PhaseTransform* phase) {
+PointsToNode* ptn = ptnode_adr(nidx);
+Node* n = ptn->_node;
+assert(n->is_AddP(), "Should be called for AddP nodes only");
+// Search for objects which are not scalar replaceable.
+// Mark their escape state as ArgEscape to propagate the state
+// to referenced objects.
+// Note: currently there are no difference in compiler optimizations
+// for ArgEscape objects and NoEscape objects which are not
+// scalar replaceable.
+Compile* C = _compile;
+int offset = ptn->offset();
+Node* base = get_addp_base(n);
+ptset.Clear();
+PointsTo(ptset, base, phase);
+int ptset_size = ptset.Size();
+// Check if a oop field's initializing value is recorded and add
+// a corresponding NULL field's value if it is not recorded.
+// Connection Graph does not record a default initialization by NULL
+// captured by Initialize node.
+//
+// Note: it will disable scalar replacement in some cases:
+//
+//    Point p[] = new Point[1];
+//    p[0] = new Point(); // Will be not scalar replaced
+//
+// but it will save us from incorrect optimizations in next cases:
+//
+//    Point p[] = new Point[1];
+//    if ( x ) p[0] = new Point(); // Will be not scalar replaced
+//
+// Do a simple control flow analysis to distinguish above cases.
+//
+if (offset != Type::OffsetBot && ptset_size == 1) {
+uint elem = ptset.getelem(); // Allocation node's index
+// It does not matter if it is not Allocation node since
+// only non-escaping allocations are scalar replaced.
+if (ptnode_adr(elem)->_node->is_Allocate() &&
+ptnode_adr(elem)->escape_state() == PointsToNode::NoEscape) {
+AllocateNode* alloc = ptnode_adr(elem)->_node->as_Allocate();
+InitializeNode* ini = alloc->initialization();
+// Check only oop fields.
+const Type* adr_type = n->as_AddP()->bottom_type();
+BasicType basic_field_type = T_INT;
+if (adr_type->isa_instptr()) {
+ciField* field = C->alias_type(adr_type->isa_instptr())->field();
+if (field != NULL) {
+basic_field_type = field->layout_type();
+} else {
+// Ignore non field load (for example, klass load)
+}
+} else if (adr_type->isa_aryptr()) {
+const Type* elemtype = adr_type->isa_aryptr()->elem();
+basic_field_type = elemtype->array_element_basic_type();
+} else {
+// Raw pointers are used for initializing stores so skip it.
+assert(adr_type->isa_rawptr() && base->is_Proj() &&
+(base->in(0) == alloc),"unexpected pointer type");
+}
+if (basic_field_type == T_OBJECT ||
+basic_field_type == T_NARROWOOP ||
+basic_field_type == T_ARRAY) {
+Node* value = NULL;
+if (ini != NULL) {
+BasicType ft = UseCompressedOops ? T_NARROWOOP : T_OBJECT;
+Node* store = ini->find_captured_store(offset, type2aelembytes(ft), phase);
+if (store != NULL && store->is_Store()) {
+value = store->in(MemNode::ValueIn);
+} else if (ptn->edge_count() > 0) { // Are there oop stores?
+// Check for a store which follows allocation without branches.
+// For example, a volatile field store is not collected
+// by Initialize node. TODO: it would be nice to use idom() here.
+for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
+store = n->fast_out(i);
+if (store->is_Store() && store->in(0) != NULL) {
+Node* ctrl = store->in(0);
+while(!(ctrl == ini || ctrl == alloc || ctrl == NULL ||
+ctrl == C->root() || ctrl == C->top() || ctrl->is_Region() ||
+ctrl->is_IfTrue() || ctrl->is_IfFalse())) {
+ctrl = ctrl->in(0);
+}
+if (ctrl == ini || ctrl == alloc) {
+value = store->in(MemNode::ValueIn);
+break;
+}
+}
+}
+}
+}
+if (value == NULL || value != ptnode_adr(value->_idx)->_node) {
+// A field's initializing value was not recorded. Add NULL.
+uint null_idx = UseCompressedOops ? _noop_null : _oop_null;
+add_pointsto_edge(nidx, null_idx);
+}
+}
+}
+}
+// An object is not scalar replaceable if the field which may point
+// to it has unknown offset (unknown element of an array of objects).
+//
+if (offset == Type::OffsetBot) {
+uint e_cnt = ptn->edge_count();
+for (uint ei = 0; ei < e_cnt; ei++) {
+uint npi = ptn->edge_target(ei);
+set_escape_state(npi, PointsToNode::ArgEscape);
+ptnode_adr(npi)->_scalar_replaceable = false;
+}
+}
+// Currently an object is not scalar replaceable if a LoadStore node
+// access its field since the field value is unknown after it.
+//
+bool has_LoadStore = false;
+for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
+Node *use = n->fast_out(i);
+if (use->is_LoadStore()) {
+has_LoadStore = true;
+break;
+}
+}
+// An object is not scalar replaceable if the address points
+// to unknown field (unknown element for arrays, offset is OffsetBot).
+//
+// Or the address may point to more then one object. This may produce
+// the false positive result (set scalar_replaceable to false)
+// since the flow-insensitive escape analysis can't separate
+// the case when stores overwrite the field's value from the case
+// when stores happened on different control branches.
+//
+if (ptset_size > 1 || ptset_size != 0 &&
+(has_LoadStore || offset == Type::OffsetBot)) {
+for( VectorSetI j(&ptset); j.test(); ++j ) {
+set_escape_state(j.elem, PointsToNode::ArgEscape);
+ptnode_adr(j.elem)->_scalar_replaceable = false;
+}
+}
+}
 void ConnectionGraph::process_call_arguments(CallNode *call, PhaseTransform *phase) {
 switch (call->Opcode()) {
 #ifdef ASSERT
 case Op_Allocate:
 case Op_Lock:
 case Op_Unlock:
 assert(false, "should be done already");
 break;
 #endif
+case Op_CallLeaf:
 case Op_CallLeafNoFP:
 {
 // Stub calls, objects do not escape but they are not scale replaceable.
 // Adjust escape state for outgoing arguments.
 const TypeTuple * d = call->tf()->domain();
 VectorSet ptset(Thread::current()->resource_area());
 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
 const Type* at = d->field_at(i);
 Node *arg = call->in(i)->uncast();
 const Type *aat = phase->type(arg);
-if (!arg->is_top() && at->isa_ptr() && aat->isa_ptr()) {
+if (!arg->is_top() && at->isa_ptr() && aat->isa_ptr() &&
+ptnode_adr(arg->_idx)->escape_state() < PointsToNode::ArgEscape) {
 assert(aat == Type::TOP || aat == TypePtr::NULL_PTR ||
 aat->isa_ptr() != NULL, "expecting an Ptr");
+#ifdef ASSERT
+if (!(call->Opcode() == Op_CallLeafNoFP &&
+call->as_CallLeaf()->_name != NULL &&
+(strstr(call->as_CallLeaf()->_name, "arraycopy")  != 0) ||
+call->as_CallLeaf()->_name != NULL &&
+(strcmp(call->as_CallLeaf()->_name, "g1_wb_pre")  == 0 ||
+strcmp(call->as_CallLeaf()->_name, "g1_wb_post") == 0 ))
+) {
+call->dump();
+assert(false, "EA: unexpected CallLeaf");
+}
+#endif
 set_escape_state(arg->_idx, PointsToNode::ArgEscape);
 if (arg->is_AddP()) {
 //
 // The inline_native_clone() case when the arraycopy stub is called
 // after the allocation before Initialize and CheckCastPP nodes.
 VectorSet ptset(Thread::current()->resource_area());
 bool copy_dependencies = false;
 for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
 const Type* at = d->field_at(i);
 int k = i - TypeFunc::Parms;
+Node *arg = call->in(i)->uncast();
-if (at->isa_oopptr() != NULL) {
-Node *arg = call->in(i)->uncast();
+if (at->isa_oopptr() != NULL &&
+ptnode_adr(arg->_idx)->escape_state() < PointsToNode::ArgEscape) {
 bool global_escapes = false;
 bool fields_escapes = false;
 if (!call_analyzer->is_arg_stack(k)) {
 // The argument global escapes, mark everything it could point to
 // Put Lock and Unlock nodes on IGVN worklist to process them during
 // the first IGVN optimization when escape information is still available.
 record_for_optimizer(n);
 _processed.set(n->_idx);
 } else {
-// Have to process call's arguments first.
+// Don't mark as processed since call's arguments have to be processed.
 PointsToNode::NodeType nt = PointsToNode::UnknownType;
+PointsToNode::EscapeState es = PointsToNode::UnknownEscape;
 // Check if a call returns an object.
 const TypeTuple *r = n->as_Call()->tf()->range();
-if (n->is_CallStaticJava() && r->cnt() > TypeFunc::Parms &&
+if (r->cnt() > TypeFunc::Parms &&
+r->field_at(TypeFunc::Parms)->isa_ptr() &&
 n->as_Call()->proj_out(TypeFunc::Parms) != NULL) {
-// Note:  use isa_ptr() instead of isa_oopptr() here because
+nt = PointsToNode::JavaObject;
-//        the _multianewarray functions return a TypeRawPtr.
+if (!n->is_CallStaticJava()) {
-if (r->field_at(TypeFunc::Parms)->isa_ptr() != NULL) {
+// Since the called mathod is statically unknown assume
-nt = PointsToNode::JavaObject;
+// the worst case that the returned value globally escapes.
-}
+es = PointsToNode::GlobalEscape;
 }
-add_node(n, nt, PointsToNode::UnknownEscape, false);
+}
+add_node(n, nt, es, false);
 }
 return;
 }
 // Using isa_ptr() instead of isa_oopptr() for LoadP and Phi because
 _delayed_worklist.push(n);
 break;
 }
 case Op_Proj:
 {
-// we are only interested in the result projection from a call
+// we are only interested in the oop result projection from a call
 if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() ) {
-add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
+const TypeTuple *r = n->in(0)->as_Call()->tf()->range();
-process_call_result(n->as_Proj(), phase);
+assert(r->cnt() > TypeFunc::Parms, "sanity");
-if (!_processed.test(n->_idx)) {
+if (r->field_at(TypeFunc::Parms)->isa_ptr() != NULL) {
-// The call's result may need to be processed later if the call
+add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
-// returns it's argument and the argument is not processed yet.
+int ti = n->in(0)->_idx;
-_delayed_worklist.push(n);
+// The call may not be registered yet (since not all its inputs are registered)
-}
+// if this is the projection from backbranch edge of Phi.
-} else {
+if (ptnode_adr(ti)->node_type() != PointsToNode::UnknownType) {
-_processed.set(n->_idx);
+process_call_result(n->as_Proj(), phase);
 }
+if (!_processed.test(n->_idx)) {
+// The call's result may need to be processed later if the call
+// returns it's argument and the argument is not processed yet.
+_delayed_worklist.push(n);
+}
+break;
+}
+}
+_processed.set(n->_idx);
 break;
 }
 case Op_Return:
 {
 if( n->req() > TypeFunc::Parms &&
 _processed.set(n->_idx);
 return;
 }
 break;
 }
+case Op_AryEq:
+case Op_StrComp:
+case Op_StrEquals:
+case Op_StrIndexOf:
+{
+// char[] arrays passed to string intrinsics are not scalar replaceable.
+add_node(n, PointsToNode::UnknownType, PointsToNode::UnknownEscape, false);
+break;
+}
 case Op_ThreadLocal:
 {
 add_node(n, PointsToNode::JavaObject, PointsToNode::ArgEscape, true);
 break;
 }
 return;
 }
 void ConnectionGraph::build_connection_graph(Node *n, PhaseTransform *phase) {
 uint n_idx = n->_idx;
+assert(ptnode_adr(n_idx)->_node != NULL, "node should be registered");
 // Don't set processed bit for AddP, LoadP, StoreP since
 // they may need more then one pass to process.
 if (_processed.test(n_idx))
 return; // No need to redefine node's state.
 case Op_CheckCastPP:
 case Op_EncodeP:
 case Op_DecodeN:
 {
 int ti = n->in(1)->_idx;
+assert(ptnode_adr(ti)->node_type() != PointsToNode::UnknownType, "all nodes should be registered");
 if (ptnode_adr(ti)->node_type() == PointsToNode::JavaObject) {
 add_pointsto_edge(n_idx, ti);
 } else {
 add_deferred_edge(n_idx, ti);
 }
 if (t->make_ptr() == NULL)
 assert(false, "Op_LoadP");
 #endif
 Node* adr = n->in(MemNode::Address)->uncast();
-const Type *adr_type = phase->type(adr);
 Node* adr_base;
 if (adr->is_AddP()) {
 adr_base = get_addp_base(adr);
 } else {
 adr_base = adr;
 _processed.set(n_idx);
 break;
 }
 case Op_Proj:
 {
-// we are only interested in the result projection from a call
+// we are only interested in the oop result projection from a call
 if (n->as_Proj()->_con == TypeFunc::Parms && n->in(0)->is_Call() ) {
-process_call_result(n->as_Proj(), phase);
+assert(ptnode_adr(n->in(0)->_idx)->node_type() != PointsToNode::UnknownType,
-assert(_processed.test(n_idx), "all call results should be processed");
+"all nodes should be registered");
-} else {
+const TypeTuple *r = n->in(0)->as_Call()->tf()->range();
-assert(false, "Op_Proj");
+assert(r->cnt() > TypeFunc::Parms, "sanity");
-}
+if (r->field_at(TypeFunc::Parms)->isa_ptr() != NULL) {
+process_call_result(n->as_Proj(), phase);
+assert(_processed.test(n_idx), "all call results should be processed");
+break;
+}
+}
+assert(false, "Op_Proj");
 break;
 }
 case Op_Return:
 {
 #ifdef ASSERT
 !phase->type(n->in(TypeFunc::Parms))->isa_oopptr() ) {
 assert(false, "Op_Return");
 }
 #endif
 int ti = n->in(TypeFunc::Parms)->_idx;
+assert(ptnode_adr(ti)->node_type() != PointsToNode::UnknownType, "node should be registered");
 if (ptnode_adr(ti)->node_type() == PointsToNode::JavaObject) {
 add_pointsto_edge(n_idx, ti);
 } else {
 add_deferred_edge(n_idx, ti);
 }
 uint pt = i.elem;
 add_edge_from_fields(pt, val->_idx, address_offset(adr, phase));
 }
 break;
 }
+case Op_AryEq:
+case Op_StrComp:
+case Op_StrEquals:
+case Op_StrIndexOf:
+{
+// char[] arrays passed to string intrinsic do not escape but
+// they are not scalar replaceable. Adjust escape state for them.
+// Start from in(2) edge since in(1) is memory edge.
+for (uint i = 2; i < n->req(); i++) {
+Node* adr = n->in(i)->uncast();
+const Type *at = phase->type(adr);
+if (!adr->is_top() && at->isa_ptr()) {
+assert(at == Type::TOP || at == TypePtr::NULL_PTR ||
+at->isa_ptr() != NULL, "expecting an Ptr");
+if (adr->is_AddP()) {
+adr = get_addp_base(adr);
+}
+// Mark as ArgEscape everything "adr" could point to.
+set_escape_state(adr->_idx, PointsToNode::ArgEscape);
+}
+}
+_processed.set(n_idx);
+break;
+}
 case Op_ThreadLocal:
 {
 assert(false, "Op_ThreadLocal");
 break;
 }
 default:
-;
+// This method should be called only for EA specific nodes.
-// nothing to do
+ShouldNotReachHere();
 }
 }
 #ifndef PRODUCT
 void ConnectionGraph::dump() {

Mercurial > hg > truffle

comparison src/share/vm/opto/escape.cpp @ 1100:f96a1a986f7b