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

comparison src/share/vm/opto/escape.cpp @ 1634:60a14ad85270

6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP Summary: Execute IGVN optimization before and after Escape Analysis Reviewed-by: never

author	kvn
date	Fri, 02 Jul 2010 17:30:30 -0700
parents	c18cbe5936b8
children	5867d89c129b

comparison

equal deleted inserted replaced

-:65b0c03b165d
+:60a14ad85270
 else
 _node->dump();
 }
 #endif
-ConnectionGraph::ConnectionGraph(Compile * C) :
+ConnectionGraph::ConnectionGraph(Compile * C, PhaseIterGVN *igvn) :
 _nodes(C->comp_arena(), C->unique(), C->unique(), PointsToNode()),
 _processed(C->comp_arena()),
 _collecting(true),
 _compile(C),
+_igvn(igvn),
 _node_map(C->comp_arena()) {
 _phantom_object = C->top()->_idx,
 add_node(C->top(), PointsToNode::JavaObject, PointsToNode::GlobalEscape,true);
 // Add ConP(#NULL) and ConN(#NULL) nodes.
-PhaseGVN* igvn = C->initial_gvn();
 Node* oop_null = igvn->zerocon(T_OBJECT);
 _oop_null = oop_null->_idx;
 assert(_oop_null < C->unique(), "should be created already");
 add_node(oop_null, PointsToNode::JavaObject, PointsToNode::NoEscape, true);
 if (done)
 _processed.set(n->_idx);
 }
-PointsToNode::EscapeState ConnectionGraph::escape_state(Node *n, PhaseTransform *phase) {
+PointsToNode::EscapeState ConnectionGraph::escape_state(Node *n) {
 uint idx = n->_idx;
 PointsToNode::EscapeState es;
 // If we are still collecting or there were no non-escaping allocations
 // we don't know the answer yet
 // PointsTo() calls n->uncast() which can return a new ideal node.
 if (n->uncast()->_idx >= nodes_size())
 return PointsToNode::UnknownEscape;
+PointsToNode::EscapeState orig_es = es;
 // compute max escape state of anything this node could point to
 VectorSet ptset(Thread::current()->resource_area());
-PointsTo(ptset, n, phase);
+PointsTo(ptset, n);
 for(VectorSetI i(&ptset); i.test() && es != PointsToNode::GlobalEscape; ++i) {
 uint pt = i.elem;
 PointsToNode::EscapeState pes = ptnode_adr(pt)->escape_state();
 if (pes > es)
 es = pes;
 }
-// cache the computed escape state
+if (orig_es != es) {
-assert(es != PointsToNode::UnknownEscape, "should have computed an escape state");
+// cache the computed escape state
-ptnode_adr(idx)->set_escape_state(es);
+assert(es != PointsToNode::UnknownEscape, "should have computed an escape state");
+ptnode_adr(idx)->set_escape_state(es);
+} // orig_es could be PointsToNode::UnknownEscape
 return es;
 }
-void ConnectionGraph::PointsTo(VectorSet &ptset, Node * n, PhaseTransform *phase) {
+void ConnectionGraph::PointsTo(VectorSet &ptset, Node * n) {
 VectorSet visited(Thread::current()->resource_area());
 GrowableArray<uint>  worklist;
 #ifdef ASSERT
 Node *orig_n = n;
 //
 void ConnectionGraph::split_unique_types(GrowableArray<Node *>  &alloc_worklist) {
 GrowableArray<Node *>  memnode_worklist;
 GrowableArray<PhiNode *>  orig_phis;
-PhaseGVN  *igvn = _compile->initial_gvn();
+PhaseGVN  *igvn = _igvn;
 uint new_index_start = (uint) _compile->num_alias_types();
 Arena* arena = Thread::current()->resource_area();
 VectorSet visited(arena);
 VectorSet ptset(arena);
 const TypeOopPtr* tinst = NULL;
 if (n->is_Call()) {
 CallNode *alloc = n->as_Call();
 // copy escape information to call node
 PointsToNode* ptn = ptnode_adr(alloc->_idx);
-PointsToNode::EscapeState es = escape_state(alloc, igvn);
+PointsToNode::EscapeState es = escape_state(alloc);
 // We have an allocation or call which returns a Java object,
 // see if it is unescaped.
 if (es != PointsToNode::NoEscape || !ptn->_scalar_replaceable)
 continue;
 }
 }
 }
 } else if (n->is_AddP()) {
 ptset.Clear();
-PointsTo(ptset, get_addp_base(n), igvn);
+PointsTo(ptset, get_addp_base(n));
 assert(ptset.Size() == 1, "AddP address is unique");
 uint elem = ptset.getelem(); // Allocation node's index
 if (elem == _phantom_object) {
 assert(false, "escaped allocation");
 continue; // Assume the value was set outside this method.
 if (visited.test_set(n->_idx)) {
 assert(n->is_Phi(), "loops only through Phi's");
 continue;  // already processed
 }
 ptset.Clear();
-PointsTo(ptset, n, igvn);
+PointsTo(ptset, n);
 if (ptset.Size() == 1) {
 uint elem = ptset.getelem(); // Allocation node's index
 if (elem == _phantom_object) {
 assert(false, "escaped allocation");
 continue; // Assume the value was set outside this method.
 }
 }
 return false;
 }
+void ConnectionGraph::do_analysis(Compile *C, PhaseIterGVN *igvn) {
+// Add ConP#NULL and ConN#NULL nodes before ConnectionGraph construction
+// to create space for them in ConnectionGraph::_nodes[].
+Node* oop_null = igvn->zerocon(T_OBJECT);
+Node* noop_null = igvn->zerocon(T_NARROWOOP);
+ConnectionGraph* congraph = new(C->comp_arena()) ConnectionGraph(C, igvn);
+// Perform escape analysis
+if (congraph->compute_escape()) {
+// There are non escaping objects.
+C->set_congraph(congraph);
+}
+// Cleanup.
+if (oop_null->outcnt() == 0)
+igvn->hash_delete(oop_null);
+if (noop_null->outcnt() == 0)
+igvn->hash_delete(noop_null);
+}
 bool ConnectionGraph::compute_escape() {
 Compile* C = _compile;
 // 1. Populate Connection Graph (CG) with Ideal nodes.
 if (C->root() != NULL) {
 worklist_init.push(C->root());
 }
 GrowableArray<int> cg_worklist;
-PhaseGVN* igvn = C->initial_gvn();
+PhaseGVN* igvn = _igvn;
 bool has_allocations = false;
 // Push all useful nodes onto CG list and set their type.
 for( uint next = 0; next < worklist_init.size(); ++next ) {
 Node* n = worklist_init.at(next);
 }
 _collecting = false;
 assert(C->unique() == nodes_size(), "there should be no new ideal nodes during ConnectionGraph build");
+#ifndef PRODUCT
+if (PrintEscapeAnalysis) {
+dump(); // Dump ConnectionGraph
+}
+#endif
 bool has_scalar_replaceable_candidates = alloc_worklist.length() > 0;
 if ( has_scalar_replaceable_candidates &&
 C->AliasLevel() >= 3 && EliminateAllocations ) {
 // Now use the escape information to create unique types for
 // scalar replaceable objects.
 split_unique_types(alloc_worklist);
 if (C->failing())  return false;
-// Clean up after split unique types.
-ResourceMark rm;
-PhaseRemoveUseless pru(C->initial_gvn(), C->for_igvn());
 C->print_method("After Escape Analysis", 2);
 #ifdef ASSERT
 } else if (Verbose && (PrintEscapeAnalysis || PrintEliminateAllocations)) {
 Compile* C = _compile;
 int offset = ptn->offset();
 Node* base = get_addp_base(n);
 ptset.Clear();
-PointsTo(ptset, base, phase);
+PointsTo(ptset, base);
 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
 // pointer to the base (with offset) is passed as argument.
 //
 arg = get_addp_base(arg);
 }
 ptset.Clear();
-PointsTo(ptset, arg, phase);
+PointsTo(ptset, arg);
 for( VectorSetI j(&ptset); j.test(); ++j ) {
 uint pt = j.elem;
 set_escape_state(pt, PointsToNode::ArgEscape);
 }
 }
 set_escape_state(arg->_idx, PointsToNode::ArgEscape);
 copy_dependencies = true;
 }
 ptset.Clear();
-PointsTo(ptset, arg, phase);
+PointsTo(ptset, arg);
 for( VectorSetI j(&ptset); j.test(); ++j ) {
 uint pt = j.elem;
 if (global_escapes) {
 //The argument global escapes, mark everything it could point to
 set_escape_state(pt, PointsToNode::GlobalEscape);
 const Type* at = d->field_at(i);
 if (at->isa_oopptr() != NULL) {
 Node *arg = call->in(i)->uncast();
 set_escape_state(arg->_idx, PointsToNode::GlobalEscape);
 ptset.Clear();
-PointsTo(ptset, arg, phase);
+PointsTo(ptset, arg);
 for( VectorSetI j(&ptset); j.test(); ++j ) {
 uint pt = j.elem;
 set_escape_state(pt, PointsToNode::GlobalEscape);
 }
 }
 case Op_AddP:
 {
 Node *base = get_addp_base(n);
 // Create a field edge to this node from everything base could point to.
 VectorSet ptset(Thread::current()->resource_area());
-PointsTo(ptset, base, phase);
+PointsTo(ptset, base);
 for( VectorSetI i(&ptset); i.test(); ++i ) {
 uint pt = i.elem;
 add_field_edge(pt, n_idx, address_offset(n, phase));
 }
 break;
 }
 // For everything "adr_base" could point to, create a deferred edge from
 // this node to each field with the same offset.
 VectorSet ptset(Thread::current()->resource_area());
-PointsTo(ptset, adr_base, phase);
+PointsTo(ptset, adr_base);
 int offset = address_offset(adr, phase);
 for( VectorSetI i(&ptset); i.test(); ++i ) {
 uint pt = i.elem;
 add_deferred_edge_to_fields(n_idx, pt, offset);
 }
 Node *adr_base = get_addp_base(adr);
 Node *val = n->in(MemNode::ValueIn)->uncast();
 // For everything "adr_base" could point to, create a deferred edge
 // to "val" from each field with the same offset.
 VectorSet ptset(Thread::current()->resource_area());
-PointsTo(ptset, adr_base, phase);
+PointsTo(ptset, adr_base);
 for( VectorSetI i(&ptset); i.test(); ++i ) {
 uint pt = i.elem;
 add_edge_from_fields(pt, val->_idx, address_offset(adr, phase));
 }
 break;
 }
 }
 #ifndef PRODUCT
 void ConnectionGraph::dump() {
-PhaseGVN  *igvn = _compile->initial_gvn();
 bool first = true;
 uint size = nodes_size();
 for (uint ni = 0; ni < size; ni++) {
 PointsToNode *ptn = ptnode_adr(ni);
 PointsToNode::NodeType ptn_type = ptn->node_type();
 if (ptn_type != PointsToNode::JavaObject || ptn->_node == NULL)
 continue;
-PointsToNode::EscapeState es = escape_state(ptn->_node, igvn);
+PointsToNode::EscapeState es = escape_state(ptn->_node);
 if (ptn->_node->is_Allocate() && (es == PointsToNode::NoEscape || Verbose)) {
 if (first) {
 tty->cr();
 tty->print("======== Connection graph for ");
 _compile->method()->print_short_name();

Mercurial > hg > truffle

comparison src/share/vm/opto/escape.cpp @ 1634:60a14ad85270