src/hotspot/share/opto/loopnode.hpp

BarrierSetC2_enhancements

*** 682,695 ****
--- 682,697 ----
    int is_postvisited( Node *n ) const { assert( is_visited(n), "" ); return _preorders[n->_idx]&1; }
  
    // Mark as post visited
    void set_postvisited( Node *n ) { assert( !is_postvisited( n ), "" ); _preorders[n->_idx] |= 1; }
  
+ public:
    // Set/get control node out.  Set lower bit to distinguish from IdealLoopTree
    // Returns true if "n" is a data node, false if it's a control node.
    bool has_ctrl( Node *n ) const { return ((intptr_t)_nodes[n->_idx]) & 1; }
  
+ private:
    // clear out dead code after build_loop_late
    Node_List _deadlist;
  
    // Support for faster execution of get_late_ctrl()/dom_lca()
    // when a node has many uses and dominator depth is deep.
***************
*** 734,743 ****
--- 736,747 ----
                              IdealLoopTree* outer_loop, LoopNode* outer_main_head,
                              uint dd_main_head);
  
  public:
  
+   PhaseIterGVN &igvn() const { return _igvn; }
+ 
    static bool is_canonical_loop_entry(CountedLoopNode* cl);
  
    bool has_node( Node* n ) const {
      guarantee(n != NULL, "No Node.");
      return _nodes[n->_idx] != NULL;
***************
*** 787,797 ****
        assert (n->is_CFG(), "must be a CFG node");
        return n;
      }
    }
  
- private:
    Node *get_ctrl_no_update_helper(Node *i) const {
      assert(has_ctrl(i), "should be control, not loop");
      return (Node*)(((intptr_t)_nodes[i->_idx]) & ~1);
    }
  
--- 791,800 ----
***************
*** 820,830 ****
    }
    // Lazy-dazy update of 'get_ctrl' and 'idom_at' mechanisms.  Replace
    // the 'old_node' with 'new_node'.  Kill old-node.  Add a reference
    // from old_node to new_node to support the lazy update.  Reference
    // replaces loop reference, since that is not needed for dead node.
- public:
    void lazy_update(Node *old_node, Node *new_node) {
      assert(old_node != new_node, "no cycles please");
      // Re-use the side array slot for this node to provide the
      // forwarding pointer.
      _nodes.map(old_node->_idx, (Node*)((intptr_t)new_node + 1));
--- 823,832 ----
***************
*** 854,863 ****
--- 856,866 ----
    uint _idom_size;
    Node **_idom;                 // Array of immediate dominators
    uint *_dom_depth;           // Used for fast LCA test
    GrowableArray<uint>* _dom_stk; // For recomputation of dom depth
  
+ public:
    Node* idom_no_update(Node* d) const {
      assert(d->_idx < _idom_size, "oob");
      Node* n = _idom[d->_idx];
      assert(n != NULL,"Bad immediate dominator info.");
      while (n->in(0) == NULL) {  // Skip dead CFG nodes
***************
*** 901,911 ****
    }
  
    // build the loop tree and perform any requested optimizations
    void build_and_optimize(bool do_split_if, bool skip_loop_opts);
  
- public:
    // Dominators for the sea of nodes
    void Dominators();
    Node *dom_lca( Node *n1, Node *n2 ) const {
      return find_non_split_ctrl(dom_lca_internal(n1, n2));
    }
--- 904,913 ----
***************
*** 958,967 ****
--- 960,971 ----
      if (!has_node(n))  return _ltree_root;
      assert(!has_ctrl(n), "");
      return (IdealLoopTree*)_nodes[n->_idx];
    }
  
+   IdealLoopTree *ltree_root() const { return _ltree_root; }
+ 
    // Is 'n' a (nested) member of 'loop'?
    int is_member( const IdealLoopTree *loop, Node *n ) const {
      return loop->is_member(get_loop(n)); }
  
    // This is the basic building block of the loop optimizations.  It clones an