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

-:194c9fdee631
+:3763ca6579b7
 /*
-* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #endif
 ConnectionGraph::ConnectionGraph(Compile * C, PhaseIterGVN *igvn) :
 _nodes(C->comp_arena(), C->unique(), C->unique(), PointsToNode()),
 _processed(C->comp_arena()),
+pt_ptset(C->comp_arena()),
+pt_visited(C->comp_arena()),
+pt_worklist(C->comp_arena(), 4, 0, 0),
 _collecting(true),
 _progress(false),
 _compile(C),
 _igvn(igvn),
 _node_map(C->comp_arena()) {
 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());
+for(VectorSetI i(PointsTo(n)); i.test() && es != PointsToNode::GlobalEscape; ++i) {
-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;
 }
 ptnode_adr(idx)->set_escape_state(es);
 } // orig_es could be PointsToNode::UnknownEscape
 return es;
 }
-void ConnectionGraph::PointsTo(VectorSet &ptset, Node * n) {
+VectorSet* ConnectionGraph::PointsTo(Node * n) {
-VectorSet visited(Thread::current()->resource_area());
+pt_ptset.Reset();
-GrowableArray<uint>  worklist;
+pt_visited.Reset();
+pt_worklist.clear();
 #ifdef ASSERT
 Node *orig_n = n;
 #endif
 n = n->uncast();
 PointsToNode* npt = ptnode_adr(n->_idx);
 // If we have a JavaObject, return just that object
 if (npt->node_type() == PointsToNode::JavaObject) {
-ptset.set(n->_idx);
+pt_ptset.set(n->_idx);
-return;
+return &pt_ptset;
 }
 #ifdef ASSERT
 if (npt->_node == NULL) {
 if (orig_n != n)
 orig_n->dump();
 n->dump();
 assert(npt->_node != NULL, "unregistered node");
 }
 #endif
-worklist.push(n->_idx);
+pt_worklist.push(n->_idx);
-while(worklist.length() > 0) {
+while(pt_worklist.length() > 0) {
-int ni = worklist.pop();
+int ni = pt_worklist.pop();
-if (visited.test_set(ni))
+if (pt_visited.test_set(ni))
 continue;
 PointsToNode* pn = ptnode_adr(ni);
 // ensure that all inputs of a Phi have been processed
 assert(!_collecting || !pn->_node->is_Phi() || _processed.test(ni),"");
 uint e_cnt = pn->edge_count();
 for (uint e = 0; e < e_cnt; e++) {
 uint etgt = pn->edge_target(e);
 PointsToNode::EdgeType et = pn->edge_type(e);
 if (et == PointsToNode::PointsToEdge) {
-ptset.set(etgt);
+pt_ptset.set(etgt);
 edges_processed++;
 } else if (et == PointsToNode::DeferredEdge) {
-worklist.push(etgt);
+pt_worklist.push(etgt);
 edges_processed++;
 } else {
 assert(false,"neither PointsToEdge or DeferredEdge");
 }
 }
 if (edges_processed == 0) {
 // no deferred or pointsto edges found.  Assume the value was set
 // outside this method.  Add the phantom object to the pointsto set.
-ptset.set(_phantom_object);
+pt_ptset.set(_phantom_object);
 }
 }
+return &pt_ptset;
 }
 void ConnectionGraph::remove_deferred(uint ni, GrowableArray<uint>* deferred_edges, VectorSet* visited) {
 // This method is most expensive during ConnectionGraph construction.
 // Reuse vectorSet and an additional growable array for deferred edges.
 deferred_edges->clear();
-visited->Clear();
+visited->Reset();
 visited->set(ni);
 PointsToNode *ptn = ptnode_adr(ni);
 // Mark current edges as visited and move deferred edges to separate array.
 PhaseIterGVN  *igvn = _igvn;
 uint new_index_start = (uint) _compile->num_alias_types();
 Arena* arena = Thread::current()->resource_area();
 VectorSet visited(arena);
-VectorSet ptset(arena);
 //  Phase 1:  Process possible allocations from alloc_worklist.
 //  Create instance types for the CheckCastPP for allocations where possible.
 //
 memnode_worklist.append_if_missing(use);
 }
 }
 }
 } else if (n->is_AddP()) {
-ptset.Clear();
+VectorSet* ptset = PointsTo(get_addp_base(n));
-PointsTo(ptset, get_addp_base(n));
+assert(ptset->Size() == 1, "AddP address is unique");
-assert(ptset.Size() == 1, "AddP address is unique");
+uint elem = ptset->getelem(); // Allocation node's index
-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.
 }
 Node *base = get_map(elem);  // CheckCastPP node
 (n->is_ConstraintCast() && n->Opcode() == Op_CastPP)) {
 if (visited.test_set(n->_idx)) {
 assert(n->is_Phi(), "loops only through Phi's");
 continue;  // already processed
 }
-ptset.Clear();
+VectorSet* ptset = PointsTo(n);
-PointsTo(ptset, n);
+if (ptset->Size() == 1) {
-if (ptset.Size() == 1) {
+uint elem = ptset->getelem(); // Allocation node's index
-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.
 }
 Node *val = get_map(elem);   // CheckCastPP node
 }
 // Update the memory inputs of MemNodes with the value we computed
 // in Phase 2 and move stores memory users to corresponding memory slices.
 #ifdef ASSERT
-visited.Clear();
+visited.Reset();
 Node_Stack old_mems(arena, _compile->unique() >> 2);
 #endif
 for (uint i = 0; i < nodes_size(); i++) {
 Node *nmem = get_map(i);
 if (nmem != NULL) {
 return false;
 }
 #undef CG_BUILD_ITER_LIMIT
 Arena* arena = Thread::current()->resource_area();
-VectorSet ptset(arena);
 VectorSet visited(arena);
 worklist.clear();
 // 5. Remove deferred edges from the graph and adjust
 //    escape state of nonescaping objects.
 remove_deferred(ni, &worklist, &visited);
 Node *n = ptn->_node;
 if (n->is_AddP()) {
 // Search for objects which are not scalar replaceable
 // and adjust their escape state.
-verify_escape_state(ni, ptset, igvn);
+adjust_escape_state(ni, igvn);
 }
 }
 }
 // 6. Propagate escape states.
 #endif
 }
 return has_non_escaping_obj;
 }
-// Search for objects which are not scalar replaceable.
+// Adjust escape state after Connection Graph is built.
-void ConnectionGraph::verify_escape_state(int nidx, VectorSet& ptset, PhaseTransform* phase) {
+void ConnectionGraph::adjust_escape_state(int nidx, 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
 Compile* C = _compile;
 int offset = ptn->offset();
 Node* base = get_addp_base(n);
-ptset.Clear();
+VectorSet* ptset = PointsTo(base);
-PointsTo(ptset, base);
+int ptset_size = ptset->Size();
-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.
 //    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
+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();
 // 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 ) {
+for( VectorSetI j(ptset); j.test(); ++j ) {
 set_escape_state(j.elem, PointsToNode::ArgEscape);
 ptnode_adr(j.elem)->_scalar_replaceable = false;
 }
 }
 }
 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() &&
 // Set AddP's base (Allocate) as not scalar replaceable since
 // pointer to the base (with offset) is passed as argument.
 //
 arg = get_addp_base(arg);
 }
-ptset.Clear();
+for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
-PointsTo(ptset, arg);
-for( VectorSetI j(&ptset); j.test(); ++j ) {
 uint pt = j.elem;
 set_escape_state(pt, PointsToNode::ArgEscape);
 }
 }
 }
 ciMethod *meth = call->as_CallJava()->method();
 BCEscapeAnalyzer *call_analyzer = (meth !=NULL) ? meth->get_bcea() : NULL;
 // fall-through if not a Java method or no analyzer information
 if (call_analyzer != NULL) {
 const TypeTuple * d = call->tf()->domain();
-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();
 }
 set_escape_state(arg->_idx, PointsToNode::ArgEscape);
 copy_dependencies = true;
 }
-ptset.Clear();
+for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
-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);
 } else {
 // or some other type of call, assume the worst case: all arguments
 // globally escape.
 {
 // 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);
 if (at->isa_oopptr() != NULL) {
 Node *arg = call->in(i)->uncast();
 set_escape_state(arg->_idx, PointsToNode::GlobalEscape);
-ptset.Clear();
+for( VectorSetI j(PointsTo(arg)); j.test(); ++j ) {
-PointsTo(ptset, arg);
-for( VectorSetI j(&ptset); j.test(); ++j ) {
 uint pt = j.elem;
 set_escape_state(pt, PointsToNode::GlobalEscape);
 }
 }
 }
 switch (n->Opcode()) {
 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());
+for( VectorSetI i(PointsTo(base)); i.test(); ++i ) {
-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;
 }
 adr_base = adr;
 }
 // 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);
 int offset = address_offset(adr, phase);
-for( VectorSetI i(&ptset); i.test(); ++i ) {
+for( VectorSetI i(PointsTo(adr_base)); i.test(); ++i ) {
 uint pt = i.elem;
 add_deferred_edge_to_fields(n_idx, pt, offset);
 }
 break;
 }
 assert(adr->is_AddP(), "expecting an AddP");
 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());
+for( VectorSetI i(PointsTo(adr_base)); i.test(); ++i ) {
-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;
 }

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

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

src/share/vm/opto/escape.cpp