859   void insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_new, bool peel_only );
 860   // If Node n lives in the back_ctrl block, we clone a private version of n
 861   // in preheader_ctrl block and return that, otherwise return n.
 862   Node *clone_up_backedge_goo( Node *back_ctrl, Node *preheader_ctrl, Node *n, VectorSet &visited, Node_Stack &clones );
 863 
 864   // Take steps to maximally unroll the loop.  Peel any odd iterations, then
 865   // unroll to do double iterations.  The next round of major loop transforms
 866   // will repeat till the doubled loop body does all remaining iterations in 1
 867   // pass.
 868   void do_maximally_unroll( IdealLoopTree *loop, Node_List &old_new );
 869 
 870   // Unroll the loop body one step - make each trip do 2 iterations.
 871   void do_unroll( IdealLoopTree *loop, Node_List &old_new, bool adjust_min_trip );
 872 
 873   // Return true if exp is a constant times an induction var
 874   bool is_scaled_iv(Node* exp, Node* iv, int* p_scale);
 875 
 876   // Return true if exp is a scaled induction var plus (or minus) constant
 877   bool is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale, Node** p_offset, int depth = 0);
 878 
 879   // Return true if proj is for "proj->[region->..]call_uct"
 880   static bool is_uncommon_trap_proj(ProjNode* proj, Deoptimization::DeoptReason reason);
 881   // Return true for    "if(test)-> proj -> ...
 882   //                          |
 883   //                          V
 884   //                      other_proj->[region->..]call_uct"
 885   static bool is_uncommon_trap_if_pattern(ProjNode* proj, Deoptimization::DeoptReason reason);
 886   // Create a new if above the uncommon_trap_if_pattern for the predicate to be promoted
 887   ProjNode* create_new_if_for_predicate(ProjNode* cont_proj, Node* new_entry,
 888                                         Deoptimization::DeoptReason reason);
 889   void register_control(Node* n, IdealLoopTree *loop, Node* pred);
 890 
 891   // Clone loop predicates to cloned loops (peeled, unswitched)
 892   static ProjNode* clone_predicate(ProjNode* predicate_proj, Node* new_entry,
 893                                    Deoptimization::DeoptReason reason,
 894                                    PhaseIdealLoop* loop_phase,
 895                                    PhaseIterGVN* igvn);
 896 
 897   static Node* clone_loop_predicates(Node* old_entry, Node* new_entry,
 898                                          bool clone_limit_check,
 899                                          PhaseIdealLoop* loop_phase,
 900                                          PhaseIterGVN* igvn);
 901   Node* clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check);
 902 
 903   static Node* skip_loop_predicates(Node* entry);
 904 
 905   // Find a good location to insert a predicate

 859   void insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_new, bool peel_only );
 860   // If Node n lives in the back_ctrl block, we clone a private version of n
 861   // in preheader_ctrl block and return that, otherwise return n.
 862   Node *clone_up_backedge_goo( Node *back_ctrl, Node *preheader_ctrl, Node *n, VectorSet &visited, Node_Stack &clones );
 863 
 864   // Take steps to maximally unroll the loop.  Peel any odd iterations, then
 865   // unroll to do double iterations.  The next round of major loop transforms
 866   // will repeat till the doubled loop body does all remaining iterations in 1
 867   // pass.
 868   void do_maximally_unroll( IdealLoopTree *loop, Node_List &old_new );
 869 
 870   // Unroll the loop body one step - make each trip do 2 iterations.
 871   void do_unroll( IdealLoopTree *loop, Node_List &old_new, bool adjust_min_trip );
 872 
 873   // Return true if exp is a constant times an induction var
 874   bool is_scaled_iv(Node* exp, Node* iv, int* p_scale);
 875 
 876   // Return true if exp is a scaled induction var plus (or minus) constant
 877   bool is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale, Node** p_offset, int depth = 0);
 878 







 879   // Create a new if above the uncommon_trap_if_pattern for the predicate to be promoted
 880   ProjNode* create_new_if_for_predicate(ProjNode* cont_proj, Node* new_entry,
 881                                         Deoptimization::DeoptReason reason);
 882   void register_control(Node* n, IdealLoopTree *loop, Node* pred);
 883 
 884   // Clone loop predicates to cloned loops (peeled, unswitched)
 885   static ProjNode* clone_predicate(ProjNode* predicate_proj, Node* new_entry,
 886                                    Deoptimization::DeoptReason reason,
 887                                    PhaseIdealLoop* loop_phase,
 888                                    PhaseIterGVN* igvn);
 889 
 890   static Node* clone_loop_predicates(Node* old_entry, Node* new_entry,
 891                                          bool clone_limit_check,
 892                                          PhaseIdealLoop* loop_phase,
 893                                          PhaseIterGVN* igvn);
 894   Node* clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check);
 895 
 896   static Node* skip_loop_predicates(Node* entry);
 897 
 898   // Find a good location to insert a predicate