jdk-sandbox: comparison src/hotspot/share/opto/memnode.cpp

equal deleted inserted replaced

-:c8d42aa9359a
+:0f882d53c204
 // "simple enough" to be folded into an object initialization.
 // Attempts to prove that a store's initial value 'n' can be captured
 // within the initialization without creating a vicious cycle, such as:
 //     { Foo p = new Foo(); p.next = p; }
 // True for constants and parameters and small combinations thereof.
-bool InitializeNode::detect_init_independence(Node* n, int& count) {
+bool InitializeNode::detect_init_independence(Node* value, PhaseGVN* phase) {
-if (n == NULL)      return true;   // (can this really happen?)
+ResourceMark rm;
-if (n->is_Proj())   n = n->in(0);
+Unique_Node_List worklist;
-if (n == this)      return false;  // found a cycle
+worklist.push(value);
-if (n->is_Con())    return true;
-if (n->is_Start())  return true;   // params, etc., are OK
+uint complexity_limit = 20;
-if (n->is_Root())   return true;   // even better
+for (uint j = 0; j < worklist.size(); j++) {
+if (j >= complexity_limit) {
-Node* ctl = n->in(0);
+return false;  // Bail out if processed too many nodes
-if (ctl != NULL && !ctl->is_top()) {
+}
-if (ctl->is_Proj())  ctl = ctl->in(0);
-if (ctl == this)  return false;
+Node* n = worklist.at(j);
+if (n == NULL)      continue;   // (can this really happen?)
-// If we already know that the enclosing memory op is pinned right after
+if (n->is_Proj())   n = n->in(0);
-// the init, then any control flow that the store has picked up
+if (n == this)      return false;  // found a cycle
-// must have preceded the init, or else be equal to the init.
+if (n->is_Con())    continue;
-// Even after loop optimizations (which might change control edges)
+if (n->is_Start())  continue;   // params, etc., are OK
-// a store is never pinned *before* the availability of its inputs.
+if (n->is_Root())   continue;   // even better
-if (!MemNode::all_controls_dominate(n, this))
-return false;                  // failed to prove a good control
+// There cannot be any dependency if 'n' is a CFG node that dominates the current allocation
-}
+if (n->is_CFG() && phase->is_dominator(n, allocation())) {
+continue;
-// Check data edges for possible dependencies on 'this'.
+}
-if ((count += 1) > 20)  return false;  // complexity limit
-for (uint i = 1; i < n->req(); i++) {
+Node* ctl = n->in(0);
-Node* m = n->in(i);
+if (ctl != NULL && !ctl->is_top()) {
-if (m == NULL || m == n || m->is_top())  continue;
+if (ctl->is_Proj())  ctl = ctl->in(0);
-uint first_i = n->find_edge(m);
+if (ctl == this)  return false;
-if (i != first_i)  continue;  // process duplicate edge just once
-if (!detect_init_independence(m, count)) {
+// If we already know that the enclosing memory op is pinned right after
-return false;
+// the init, then any control flow that the store has picked up
+// must have preceded the init, or else be equal to the init.
+// Even after loop optimizations (which might change control edges)
+// a store is never pinned *before* the availability of its inputs.
+if (!MemNode::all_controls_dominate(n, this))
+return false;                  // failed to prove a good control
+}
+// Check data edges for possible dependencies on 'this'.
+for (uint i = 1; i < n->req(); i++) {
+Node* m = n->in(i);
+if (m == NULL || m == n || m->is_top())  continue;
+// Only process data inputs once
+worklist.push(m);
 }
 }
 return true;
 }
 // Here are all the checks a Store must pass before it can be moved into
 // an initialization.  Returns zero if a check fails.
 // On success, returns the (constant) offset to which the store applies,
 // within the initialized memory.
-intptr_t InitializeNode::can_capture_store(StoreNode* st, PhaseTransform* phase, bool can_reshape) {
+intptr_t InitializeNode::can_capture_store(StoreNode* st, PhaseGVN* phase, bool can_reshape) {
 const int FAIL = 0;
 if (st->req() != MemNode::ValueIn + 1)
 return FAIL;                // an inscrutable StoreNode (card mark?)
 Node* ctl = st->in(MemNode::Control);
 if (!(ctl != NULL && ctl->is_Proj() && ctl->in(0) == this))
 int size_in_bytes = st->memory_size();
 if ((size_in_bytes != 0) && (offset % size_in_bytes) != 0) {
 return FAIL;                // mismatched access
 }
 Node* val = st->in(MemNode::ValueIn);
-int complexity_count = 0;
-if (!detect_init_independence(val, complexity_count))
+if (!detect_init_independence(val, phase))
 return FAIL;                // stored value must be 'simple enough'
 // The Store can be captured only if nothing after the allocation
 // and before the Store is using the memory location that the store
 // overwrites.
 //   rawstore2 = (StoreC alloc.Control alloc.Memory (+ rawoop 14) 2)
 //   init = (Initialize alloc.Control alloc.Memory rawoop
 //                      rawstore1 rawstore2)
 //
 Node* InitializeNode::capture_store(StoreNode* st, intptr_t start,
-PhaseTransform* phase, bool can_reshape) {
+PhaseGVN* phase, bool can_reshape) {
 assert(stores_are_sane(phase), "");
 if (start < 0)  return NULL;
 assert(can_capture_store(st, phase, can_reshape) == start, "sanity");

changeset 58751	0f882d53c204
parent 58516	d376d86b0a01
child 58759	4242e35767b5