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

comparison src/share/vm/opto/memnode.cpp @ 85:f3b3fe64f59f

6692301: Side effect in NumberFormat tests with -server -Xcomp Summary: Optimization in CmpPNode::sub() removed the valid compare instruction because of false positive answer from detect_dominating_control(). Reviewed-by: jrose, sgoldman

author	kvn
date	Tue, 15 Apr 2008 10:49:32 -0700
parents	de93acbb64fc
children	ec73d88d5b43

comparison

equal deleted inserted replaced

-:6e085831cad7
+:f3b3fe64f59f
 // let the subclass continue analyzing...
 return NULL;
 }
 // Helper function for proving some simple control dominations.
-// Attempt to prove that control input 'dom' dominates (or equals) 'sub'.
+// Attempt to prove that all control inputs of 'dom' dominate 'sub'.
 // Already assumes that 'dom' is available at 'sub', and that 'sub'
 // is not a constant (dominated by the method's StartNode).
 // Used by MemNode::find_previous_store to prove that the
 // control input of a memory operation predates (dominates)
 // an allocation it wants to look past.
-bool MemNode::detect_dominating_control(Node* dom, Node* sub) {
+bool MemNode::all_controls_dominate(Node* dom, Node* sub) {
-if (dom == NULL)      return false;
+if (dom == NULL || dom->is_top() || sub == NULL || sub->is_top())
-if (dom->is_Proj())   dom = dom->in(0);
+return false; // Conservative answer for dead code
-if (dom->is_Start())  return true; // anything inside the method
-if (dom->is_Root())   return true; // dom 'controls' a constant
+// Check 'dom'.
-int cnt = 20;                      // detect cycle or too much effort
+dom = dom->find_exact_control(dom);
-while (sub != NULL) {              // walk 'sub' up the chain to 'dom'
+if (dom == NULL || dom->is_top())
-if (--cnt < 0)   return false;   // in a cycle or too complex
+return false; // Conservative answer for dead code
-if (sub == dom)  return true;
-if (sub->is_Start())  return false;
+if (dom->is_Start() || dom->is_Root() || dom == sub)
-if (sub->is_Root())   return false;
+return true;
-Node* up = sub->in(0);
-if (sub == up && sub->is_Region()) {
+// 'dom' dominates 'sub' if its control edge and control edges
-for (uint i = 1; i < sub->req(); i++) {
+// of all its inputs dominate or equal to sub's control edge.
-Node* in = sub->in(i);
-if (in != NULL && !in->is_top() && in != sub) {
+// Currently 'sub' is either Allocate, Initialize or Start nodes.
-up = in; break;            // take any path on the way up to 'dom'
+assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start(), "expecting only these nodes");
+// Get control edge of 'sub'.
+sub = sub->find_exact_control(sub->in(0));
+if (sub == NULL || sub->is_top())
+return false; // Conservative answer for dead code
+assert(sub->is_CFG(), "expecting control");
+if (sub == dom)
+return true;
+if (sub->is_Start() || sub->is_Root())
+return false;
+{
+// Check all control edges of 'dom'.
+ResourceMark rm;
+Arena* arena = Thread::current()->resource_area();
+Node_List nlist(arena);
+Unique_Node_List dom_list(arena);
+dom_list.push(dom);
+bool only_dominating_controls = false;
+for (uint next = 0; next < dom_list.size(); next++) {
+Node* n = dom_list.at(next);
+if (!n->is_CFG() && n->pinned()) {
+// Check only own control edge for pinned non-control nodes.
+n = n->find_exact_control(n->in(0));
+if (n == NULL || n->is_top())
+return false; // Conservative answer for dead code
+assert(n->is_CFG(), "expecting control");
+}
+if (n->is_Start() || n->is_Root()) {
+only_dominating_controls = true;
+} else if (n->is_CFG()) {
+if (n->dominates(sub, nlist))
+only_dominating_controls = true;
+else
+return false;
+} else {
+// First, own control edge.
+Node* m = n->find_exact_control(n->in(0));
+if (m == NULL)
+continue;
+if (m->is_top())
+return false; // Conservative answer for dead code
+dom_list.push(m);
+// Now, the rest of edges.
+uint cnt = n->req();
+for (uint i = 1; i < cnt; i++) {
+m = n->find_exact_control(n->in(i));
+if (m == NULL || m->is_top())
+continue;
+dom_list.push(m);
 }
 }
 }
-if (sub == up)  return false;    // some kind of tight cycle
+return only_dominating_controls;
-sub = up;
+}
-}
-return false;
 }
 //---------------------detect_ptr_independence---------------------------------
 // Used by MemNode::find_previous_store to prove that two base
 // pointers are never equal.
 return (p1 != p2) && p1->is_Con() && p2->is_Con();
 } else if (a1 != NULL && a2 != NULL) {    // both allocations
 return (a1 != a2);
 } else if (a1 != NULL) {                  // one allocation a1
 // (Note:  p2->is_Con implies p2->in(0)->is_Root, which dominates.)
-return detect_dominating_control(p2->in(0), a1->in(0));
+return all_controls_dominate(p2, a1);
 } else { //(a2 != NULL)                   // one allocation a2
-return detect_dominating_control(p1->in(0), a2->in(0));
+return all_controls_dominate(p1, a2);
 }
 return false;
 }
 bool known_independent = false;
 if (alloc == st_alloc)
 known_identical = true;
 else if (alloc != NULL)
 known_independent = true;
-else if (ctrl != NULL &&
+else if (all_controls_dominate(this, st_alloc))
-detect_dominating_control(ctrl, st_alloc->in(0)))
 known_independent = true;
 if (known_independent) {
 // The bases are provably independent: Either they are
 // manifestly distinct allocations, or else the control
 if (in(MemNode::Control) != NULL) {
 intptr_t ignore = 0;
 Node*    base   = AddPNode::Ideal_base_and_offset(address, phase, ignore);
 if (base != NULL
 && phase->type(base)->higher_equal(TypePtr::NOTNULL)
-&& detect_dominating_control(base->in(0), phase->C->start())) {
+&& all_controls_dominate(base, phase->C->start())) {
 // A method-invariant, non-null address (constant or 'this' argument).
 set_req(MemNode::Control, NULL);
 }
 }
 // If we already know that the enclosing memory op is pinned right after
 // 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::detect_dominating_control(ctl, this->in(0)))
+if (!MemNode::all_controls_dominate(n, this))
 return false;                  // failed to prove a good control
 }
 // Check data edges for possible dependencies on 'this'.

Mercurial > hg > truffle

comparison src/share/vm/opto/memnode.cpp @ 85:f3b3fe64f59f