src/hotspot/share/opto/loopnode.hpp

rev 52710 : Upstream/backport Shenandoah to JDK11u

*** 923,963 ****
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(NULL),
      _verify_only(true) {
!     build_and_optimize(false, false);
    }
  
    // build the loop tree and perform any requested optimizations
!   void build_and_optimize(bool do_split_if, bool skip_loop_opts, bool last_round = false);
  
    // 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));
    }
    Node *dom_lca_internal( Node *n1, Node *n2 ) const;
  
    // Compute the Ideal Node to Loop mapping
!   PhaseIdealLoop( PhaseIterGVN &igvn, bool do_split_ifs, bool skip_loop_opts = false, bool last_round = false) :
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(NULL),
      _verify_only(false) {
!     build_and_optimize(do_split_ifs, skip_loop_opts, last_round);
    }
  
    // Verify that verify_me made the same decisions as a fresh run.
    PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify_me) :
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(verify_me),
      _verify_only(false) {
!     build_and_optimize(false, false);
    }
  
    // Build and verify the loop tree without modifying the graph.  This
    // is useful to verify that all inputs properly dominate their uses.
    static void verify(PhaseIterGVN& igvn) {
--- 923,963 ----
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(NULL),
      _verify_only(true) {
!     build_and_optimize(LoopOptsVerify);
    }
  
    // build the loop tree and perform any requested optimizations
!   void build_and_optimize(LoopOptsMode mode);
  
    // 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));
    }
    Node *dom_lca_internal( Node *n1, Node *n2 ) const;
  
    // Compute the Ideal Node to Loop mapping
!   PhaseIdealLoop( PhaseIterGVN &igvn, LoopOptsMode mode) :
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(NULL),
      _verify_only(false) {
!       build_and_optimize(mode);
    }
  
    // Verify that verify_me made the same decisions as a fresh run.
    PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify_me) :
      PhaseTransform(Ideal_Loop),
      _igvn(igvn),
      _dom_lca_tags(arena()), // Thread::resource_area
      _verify_me(verify_me),
      _verify_only(false) {
!     build_and_optimize(LoopOptsVerify);
    }
  
    // Build and verify the loop tree without modifying the graph.  This
    // is useful to verify that all inputs properly dominate their uses.
    static void verify(PhaseIterGVN& igvn) {
*** 1289,1300 ****
--- 1289,1302 ----
    bool split_up( Node *n, Node *blk1, Node *blk2 );
    void sink_use( Node *use, Node *post_loop );
    Node *place_near_use( Node *useblock ) const;
    Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
    void try_move_store_after_loop(Node* n);
+ public:
    bool identical_backtoback_ifs(Node *n);
    bool can_split_if(Node *n_ctrl);
+ private:
  
    bool _created_loop_node;
  public:
    void set_created_loop_node() { _created_loop_node = true; }
    bool created_loop_node()     { return _created_loop_node; }
*** 1305,1315 ****
  #endif
  
  #ifndef PRODUCT
    void dump( ) const;
    void dump( IdealLoopTree *loop, uint rpo_idx, Node_List &rpo_list ) const;
-   void rpo( Node *start, Node_Stack &stk, VectorSet &visited, Node_List &rpo_list ) const;
    void verify() const;          // Major slow  :-)
    void verify_compare( Node *n, const PhaseIdealLoop *loop_verify, VectorSet &visited ) const;
    IdealLoopTree *get_loop_idx(Node* n) const {
      // Dead nodes have no loop, so return the top level loop instead
      return _nodes[n->_idx] ? (IdealLoopTree*)_nodes[n->_idx] : _ltree_root;
--- 1307,1316 ----
*** 1317,1326 ****
--- 1318,1330 ----
    // Print some stats
    static void print_statistics();
    static int _loop_invokes;     // Count of PhaseIdealLoop invokes
    static int _loop_work;        // Sum of PhaseIdealLoop x _unique
  #endif
+   void rpo( Node *start, Node_Stack &stk, VectorSet &visited, Node_List &rpo_list ) const;
+ 
+   PhaseIterGVN& igvn() { return _igvn; }
  };
  
  // This kit may be used for making of a reserved copy of a loop before this loop
  //  goes under non-reversible changes.
  //