< prev index next >

src/hotspot/share/opto/loopnode.hpp

Print this page

        

*** 553,563 **** // Useful for unrolling loops with NO array accesses. bool policy_peel_only( PhaseIdealLoop *phase ) const; // Return TRUE or FALSE if the loop should be unswitched -- clone // loop with an invariant test ! bool policy_unswitching( PhaseIdealLoop *phase ) const; // Micro-benchmark spamming. Remove empty loops. bool policy_do_remove_empty_loop( PhaseIdealLoop *phase ); // Convert one iteration loop into normal code. --- 553,563 ---- // Useful for unrolling loops with NO array accesses. bool policy_peel_only( PhaseIdealLoop *phase ) const; // Return TRUE or FALSE if the loop should be unswitched -- clone // loop with an invariant test ! bool policy_unswitching(PhaseIdealLoop *phase, bool shenandoah_opts = false) const; // Micro-benchmark spamming. Remove empty loops. bool policy_do_remove_empty_loop( PhaseIdealLoop *phase ); // Convert one iteration loop into normal code.
*** 860,871 **** // loop tree, not the root. IdealLoopTree *sort( IdealLoopTree *loop, IdealLoopTree *innermost ); // Place Data nodes in some loop nest void build_loop_early( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ); ! void build_loop_late ( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ); ! void build_loop_late_post ( Node* n ); void verify_strip_mined_scheduling(Node *n, Node* least); // Array of immediate dominance info for each CFG node indexed by node idx private: uint _idom_size; --- 860,871 ---- // loop tree, not the root. IdealLoopTree *sort( IdealLoopTree *loop, IdealLoopTree *innermost ); // Place Data nodes in some loop nest void build_loop_early( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ); ! void build_loop_late(VectorSet &visited, Node_List &worklist, Node_Stack &nstack, bool verify_strip_mined); ! void build_loop_late_post(Node* n, bool verify_strip_mined); void verify_strip_mined_scheduling(Node *n, Node* least); // Array of immediate dominance info for each CFG node indexed by node idx private: uint _idom_size;
*** 921,961 **** 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) { --- 921,961 ---- 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) {
*** 1080,1089 **** --- 1080,1093 ---- static ProjNode* clone_predicate(ProjNode* predicate_proj, Node* new_entry, Deoptimization::DeoptReason reason, PhaseIdealLoop* loop_phase, PhaseIterGVN* igvn); + static void clone_loop_predicates_fix_mem(ProjNode* dom_proj , ProjNode* proj, + PhaseIdealLoop* loop_phase, + PhaseIterGVN* igvn ); + static Node* clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check, PhaseIdealLoop* loop_phase, PhaseIterGVN* igvn); Node* clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check);
*** 1166,1179 **** // LoopNode* create_reserve_version_of_loop(IdealLoopTree *loop, CountedLoopReserveKit* lk); // Clone loop with an invariant test (that does not exit) and // insert a clone of the test that selects which version to // execute. ! void do_unswitching (IdealLoopTree *loop, Node_List &old_new); // Find candidate "if" for unswitching ! IfNode* find_unswitching_candidate(const IdealLoopTree *loop) const; // Range Check Elimination uses this function! // Constrain the main loop iterations so the affine function: // low_limit <= scale_con * I + offset < upper_limit // always holds true. That is, either increase the number of iterations in --- 1170,1183 ---- // LoopNode* create_reserve_version_of_loop(IdealLoopTree *loop, CountedLoopReserveKit* lk); // Clone loop with an invariant test (that does not exit) and // insert a clone of the test that selects which version to // execute. ! void do_unswitching(IdealLoopTree *loop, Node_List &old_new, bool shenandoah_opts = false); // Find candidate "if" for unswitching ! IfNode* find_unswitching_candidate(const IdealLoopTree *loop, bool shenandoah_opts) const; // Range Check Elimination uses this function! // Constrain the main loop iterations so the affine function: // low_limit <= scale_con * I + offset < upper_limit // always holds true. That is, either increase the number of iterations in
*** 1261,1270 **** --- 1265,1276 ---- // Split Node 'n' through merge point Node *split_thru_region( Node *n, Node *region ); // Split Node 'n' through merge point if there is enough win. Node *split_thru_phi( Node *n, Node *region, int policy ); + void split_mem_thru_phi(Node*, Node* r, Node* phi); + // Found an If getting its condition-code input from a Phi in the // same block. Split thru the Region. void do_split_if( Node *iff ); // Conversion of fill/copy patterns into intrisic versions
*** 1287,1298 **** --- 1293,1306 ---- 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; }
*** 1303,1313 **** #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; --- 1311,1320 ----
*** 1315,1324 **** --- 1322,1334 ---- // 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. //
< prev index next >