jdk8-mips64-public/hotspot: comparison src/share/vm/opto/escape.cpp

-:a6eef545f1a2
+:e69a66a1457b
 add_node(C->top(), PointsToNode::JavaObject, PointsToNode::GlobalEscape,true);
 // Add ConP(#NULL) and ConN(#NULL) nodes.
 Node* oop_null = igvn->zerocon(T_OBJECT);
 _oop_null = oop_null->_idx;
-assert(_oop_null < C->unique(), "should be created already");
+assert(_oop_null < nodes_size(), "should be created already");
 add_node(oop_null, PointsToNode::JavaObject, PointsToNode::NoEscape, true);
 if (UseCompressedOops) {
 Node* noop_null = igvn->zerocon(T_NARROWOOP);
 _noop_null = noop_null->_idx;
-assert(_noop_null < C->unique(), "should be created already");
+assert(_noop_null < nodes_size(), "should be created already");
 add_node(noop_null, PointsToNode::JavaObject, PointsToNode::NoEscape, true);
+} else {
+_noop_null = _oop_null; // Should be initialized
 }
 }
 void ConnectionGraph::add_pointsto_edge(uint from_i, uint to_i) {
 PointsToNode *f = ptnode_adr(from_i);
 add_edge(f, to_i, PointsToNode::FieldEdge);
 }
 void ConnectionGraph::set_escape_state(uint ni, PointsToNode::EscapeState es) {
+// Don't change non-escaping state of NULL pointer.
+if (ni == _noop_null || ni == _oop_null)
+return;
 PointsToNode *npt = ptnode_adr(ni);
 PointsToNode::EscapeState old_es = npt->escape_state();
 if (es > old_es)
 npt->set_escape_state(es);
 }
 if (pes > es)
 es = pes;
 }
 if (orig_es != es) {
 // cache the computed escape state
-assert(es != PointsToNode::UnknownEscape, "should have computed an escape state");
+assert(es > orig_es, "should have computed an escape state");
-ptnode_adr(idx)->set_escape_state(es);
+set_escape_state(idx, es);
 } // orig_es could be PointsToNode::UnknownEscape
 return es;
 }
 VectorSet* ConnectionGraph::PointsTo(Node * n) {
 PointsToNode::EdgeType et = ptt->edge_type(e);
 if (et == PointsToNode::PointsToEdge) {
 add_pointsto_edge(ni, etgt);
 if(etgt == _phantom_object) {
 // Special case - field set outside (globally escaping).
-ptn->set_escape_state(PointsToNode::GlobalEscape);
+set_escape_state(ni, PointsToNode::GlobalEscape);
 }
 } else if (et == PointsToNode::DeferredEdge) {
 deferred_edges->append(etgt);
 } else {
 assert(false,"invalid connection graph");
 uint e_cnt = ptn->edge_count();
 for (uint ei = 0; ei < e_cnt; ei++) {
 uint npi = ptn->edge_target(ei);
 PointsToNode *np = ptnode_adr(npi);
 if (np->escape_state() < PointsToNode::GlobalEscape) {
-np->set_escape_state(PointsToNode::GlobalEscape);
+set_escape_state(npi, PointsToNode::GlobalEscape);
 worklist.push(npi);
 }
 }
 }
 uint e_cnt = ptn->edge_count();
 for (uint ei = 0; ei < e_cnt; ei++) {
 uint npi = ptn->edge_target(ei);
 PointsToNode *np = ptnode_adr(npi);
 if (np->escape_state() < PointsToNode::ArgEscape) {
-np->set_escape_state(PointsToNode::ArgEscape);
+set_escape_state(npi, PointsToNode::ArgEscape);
 worklist.push(npi);
 }
 }
 }
 if (ptnode_adr(nk)->escape_state() == PointsToNode::NoEscape)
 worklist.push(nk);
 }
 // mark all nodes reachable from NoEscape nodes
 while(worklist.length() > 0) {
-PointsToNode* ptn = ptnode_adr(worklist.pop());
+uint nk = worklist.pop();
-if (ptn->node_type() == PointsToNode::JavaObject)
+PointsToNode* ptn = ptnode_adr(nk);
-has_non_escaping_obj = true; // Non GlobalEscape
+if (ptn->node_type() == PointsToNode::JavaObject &&
+!(nk == _noop_null || nk == _oop_null))
+has_non_escaping_obj = true; // Non Escape
 Node* n = ptn->_node;
 if (n->is_Allocate() && ptn->_scalar_replaceable ) {
 // Push scalar replaceable allocations on alloc_worklist
 // for processing in split_unique_types().
 alloc_worklist.append(n);
 uint e_cnt = ptn->edge_count();
 for (uint ei = 0; ei < e_cnt; ei++) {
 uint npi = ptn->edge_target(ei);
 PointsToNode *np = ptnode_adr(npi);
 if (np->escape_state() < PointsToNode::NoEscape) {
-np->set_escape_state(PointsToNode::NoEscape);
+set_escape_state(npi, PointsToNode::NoEscape);
 worklist.push(npi);
 }
 }
 }
 _collecting = false;
 assert(C->unique() == nodes_size(), "there should be no new ideal nodes during ConnectionGraph build");
+assert(ptnode_adr(_oop_null)->escape_state() == PointsToNode::NoEscape, "sanity");
+if (UseCompressedOops) {
+assert(ptnode_adr(_noop_null)->escape_state() == PointsToNode::NoEscape, "sanity");
+}
 if (EliminateLocks) {
 // Mark locks before changing ideal graph.
 int cnt = C->macro_count();
 for( int i=0; i < cnt; i++ ) {

Mercurial > jdk8-mips64-public > hotspot / file comparison

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

src/share/vm/opto/escape.cpp