src/share/vm/opto/escape.cpp

*** 213,232 ****
  
  void ConnectionGraph::PointsTo(VectorSet &ptset, Node * n, PhaseTransform *phase) {
    VectorSet visited(Thread::current()->resource_area());
    GrowableArray<uint>  worklist;
  
    n = n->uncast();
    PointsToNode  npt = _nodes->at_grow(n->_idx);
  
    // If we have a JavaObject, return just that object
    if (npt.node_type() == PointsToNode::JavaObject) {
      ptset.set(n->_idx);
      return;
    }
    assert(npt._node != NULL, "unregistered node");
! 
    worklist.push(n->_idx);
    while(worklist.length() > 0) {
      int ni = worklist.pop();
      PointsToNode pn = _nodes->at_grow(ni);
      if (!visited.test_set(ni)) {
--- 213,242 ----
  
  void ConnectionGraph::PointsTo(VectorSet &ptset, Node * n, PhaseTransform *phase) {
    VectorSet visited(Thread::current()->resource_area());
    GrowableArray<uint>  worklist;
  
+ #ifdef ASSERT
+   Node *orig_n = n;
+ #endif
+ 
    n = n->uncast();
    PointsToNode  npt = _nodes->at_grow(n->_idx);
  
    // If we have a JavaObject, return just that object
    if (npt.node_type() == PointsToNode::JavaObject) {
      ptset.set(n->_idx);
      return;
    }
+ #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);
    while(worklist.length() > 0) {
      int ni = worklist.pop();
      PointsToNode pn = _nodes->at_grow(ni);
      if (!visited.test_set(ni)) {
*** 264,283 ****
  
    uint i = 0;
    PointsToNode *ptn = ptnode_adr(ni);
  
    // Mark current edges as visited and move deferred edges to separate array.
!   for (; i < ptn->edge_count(); i++) {
      uint t = ptn->edge_target(i);
  #ifdef ASSERT
      assert(!visited->test_set(t), "expecting no duplications");
  #else
      visited->set(t);
  #endif
      if (ptn->edge_type(i) == PointsToNode::DeferredEdge) {
        ptn->remove_edge(t, PointsToNode::DeferredEdge);
        deferred_edges->append(t);
      }
    }
    for (int next = 0; next < deferred_edges->length(); ++next) {
      uint t = deferred_edges->at(next);
      PointsToNode *ptt = ptnode_adr(t);
--- 274,295 ----
  
    uint i = 0;
    PointsToNode *ptn = ptnode_adr(ni);
  
    // Mark current edges as visited and move deferred edges to separate array.
!   while (i < ptn->edge_count()) {
      uint t = ptn->edge_target(i);
  #ifdef ASSERT
      assert(!visited->test_set(t), "expecting no duplications");
  #else
      visited->set(t);
  #endif
      if (ptn->edge_type(i) == PointsToNode::DeferredEdge) {
        ptn->remove_edge(t, PointsToNode::DeferredEdge);
        deferred_edges->append(t);
+     } else {
+       i++;
      }
    }
    for (int next = 0; next < deferred_edges->length(); ++next) {
      uint t = deferred_edges->at(next);
      PointsToNode *ptt = ptnode_adr(t);
*** 1714,1723 ****
--- 1726,1737 ----
        add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
        break;
      }
      case Op_CastPP:
      case Op_CheckCastPP:
+     case Op_EncodeP:
+     case Op_DecodeN:
      {
        add_node(n, PointsToNode::LocalVar, PointsToNode::UnknownEscape, false);
        int ti = n->in(1)->_idx;
        PointsToNode::NodeType nt = _nodes->adr_at(ti)->node_type();
        if (nt == PointsToNode::UnknownType) {
*** 1741,1756 ****
          es = PointsToNode::GlobalEscape;
  
        add_node(n, PointsToNode::JavaObject, es, true);
        break;
      }
-     case Op_CreateEx:
-     {
-       // assume that all exception objects globally escape
-       add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
-       break;
-     }
      case Op_ConN:
      {
        // assume all narrow oop constants globally escape except for null
        PointsToNode::EscapeState es;
        if (phase->type(n) == TypeNarrowOop::NULL_PTR)
--- 1755,1764 ----
*** 1759,1768 ****
--- 1767,1782 ----
          es = PointsToNode::GlobalEscape;
  
        add_node(n, PointsToNode::JavaObject, es, true);
        break;
      }
+     case Op_CreateEx:
+     {
+       // assume that all exception objects globally escape
+       add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
+       break;
+     }
      case Op_LoadKlass:
      {
        add_node(n, PointsToNode::JavaObject, PointsToNode::GlobalEscape, true);
        break;
      }
*** 1974,1987 ****
      {
        assert(false, "Op_LoadKlass");
        break;
      }
      case Op_LoadP:
      {
        const Type *t = phase->type(n);
  #ifdef ASSERT
!       if (t->isa_ptr() == NULL)
          assert(false, "Op_LoadP");
  #endif
  
        Node* adr = n->in(MemNode::Address)->uncast();
        const Type *adr_type = phase->type(adr);
--- 1988,2002 ----
      {
        assert(false, "Op_LoadKlass");
        break;
      }
      case Op_LoadP:
+     case Op_LoadN:
      {
        const Type *t = phase->type(n);
  #ifdef ASSERT
!       if (!t->isa_narrowoop() && t->isa_ptr() == NULL)
          assert(false, "Op_LoadP");
  #endif
  
        Node* adr = n->in(MemNode::Address)->uncast();
        const Type *adr_type = phase->type(adr);
*** 2058,2072 ****
--- 2073,2092 ----
        }
        _processed.set(n->_idx);
        break;
      }
      case Op_StoreP:
+     case Op_StoreN:
      case Op_StorePConditional:
      case Op_CompareAndSwapP:
+     case Op_CompareAndSwapN:
      {
        Node *adr = n->in(MemNode::Address);
        const Type *adr_type = phase->type(adr);
+       if (adr_type->isa_narrowoop()) {
+         adr_type = adr_type->is_narrowoop()->make_oopptr();
+       }
  #ifdef ASSERT
        if (!adr_type->isa_oopptr())
          assert(phase->type(adr) == TypeRawPtr::NOTNULL, "Op_StoreP");
  #endif