26 #define SHARE_OPTO_LOOPNODE_HPP
27
28 #include "opto/cfgnode.hpp"
29 #include "opto/multnode.hpp"
30 #include "opto/phaseX.hpp"
31 #include "opto/predicates.hpp"
32 #include "opto/subnode.hpp"
33 #include "opto/type.hpp"
34 #include "utilities/checkedCast.hpp"
35
36 class CmpNode;
37 class BaseCountedLoopEndNode;
38 class CountedLoopNode;
39 class IdealLoopTree;
40 class LoopNode;
41 class Node;
42 class OuterStripMinedLoopEndNode;
43 class PredicateBlock;
44 class PathFrequency;
45 class PhaseIdealLoop;
46 class LoopSelector;
47 class ReachabilityFenceNode;
48 class UnswitchedLoopSelector;
49 class VectorSet;
50 class VSharedData;
51 class Invariance;
52 struct small_cache;
53
54 //
55 // I D E A L I Z E D L O O P S
56 //
57 // Idealized loops are the set of loops I perform more interesting
58 // transformations on, beyond simple hoisting.
59
60 //------------------------------LoopNode---------------------------------------
61 // Simple loop header. Fall in path on left, loop-back path on right.
62 class LoopNode : public RegionNode {
63 // Size is bigger to hold the flags. However, the flags do not change
64 // the semantics so it does not appear in the hash & cmp functions.
65 virtual uint size_of() const { return sizeof(*this); }
69 enum { Normal=0, Pre=1, Main=2, Post=3, PreMainPostFlagsMask=3,
70 MainHasNoPreLoop = 1<<2,
71 HasExactTripCount = 1<<3,
72 InnerLoop = 1<<4,
73 PartialPeelLoop = 1<<5,
74 PartialPeelFailed = 1<<6,
75 WasSlpAnalyzed = 1<<7,
76 PassedSlpAnalysis = 1<<8,
77 DoUnrollOnly = 1<<9,
78 VectorizedLoop = 1<<10,
79 HasAtomicPostLoop = 1<<11,
80 StripMined = 1<<12,
81 SubwordLoop = 1<<13,
82 ProfileTripFailed = 1<<14,
83 LoopNestInnerLoop = 1<<15,
84 LoopNestLongOuterLoop = 1<<16,
85 MultiversionFastLoop = 1<<17,
86 MultiversionSlowLoop = 2<<17,
87 MultiversionDelayedSlowLoop = 3<<17,
88 MultiversionFlagsMask = 3<<17,
89 };
90 char _unswitch_count;
91 enum { _unswitch_max=3 };
92
93 // Expected trip count from profile data
94 float _profile_trip_cnt;
95
96 public:
97 // Names for edge indices
98 enum { Self=0, EntryControl, LoopBackControl };
99
100 bool is_inner_loop() const { return _loop_flags & InnerLoop; }
101 void set_inner_loop() { _loop_flags |= InnerLoop; }
102
103 bool is_vectorized_loop() const { return _loop_flags & VectorizedLoop; }
104 bool is_partial_peel_loop() const { return _loop_flags & PartialPeelLoop; }
105 void set_partial_peel_loop() { _loop_flags |= PartialPeelLoop; }
106 bool partial_peel_has_failed() const { return _loop_flags & PartialPeelFailed; }
107 bool is_strip_mined() const { return _loop_flags & StripMined; }
108 bool is_profile_trip_failed() const { return _loop_flags & ProfileTripFailed; }
109 bool is_subword_loop() const { return _loop_flags & SubwordLoop; }
110 bool is_loop_nest_inner_loop() const { return _loop_flags & LoopNestInnerLoop; }
111 bool is_loop_nest_outer_loop() const { return _loop_flags & LoopNestLongOuterLoop; }
112
113 void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
114 void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
115 void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }
116 void mark_do_unroll_only() { _loop_flags |= DoUnrollOnly; }
117 void mark_loop_vectorized() { _loop_flags |= VectorizedLoop; }
118 void mark_has_atomic_post_loop() { _loop_flags |= HasAtomicPostLoop; }
119 void mark_strip_mined() { _loop_flags |= StripMined; }
120 void clear_strip_mined() { _loop_flags &= ~StripMined; }
121 void mark_profile_trip_failed() { _loop_flags |= ProfileTripFailed; }
122 void mark_subword_loop() { _loop_flags |= SubwordLoop; }
123 void mark_loop_nest_inner_loop() { _loop_flags |= LoopNestInnerLoop; }
124 void mark_loop_nest_outer_loop() { _loop_flags |= LoopNestLongOuterLoop; }
125
126 int unswitch_max() { return _unswitch_max; }
127 int unswitch_count() { return _unswitch_count; }
128
129 void set_unswitch_count(int val) {
130 assert (val <= unswitch_max(), "too many unswitches");
131 _unswitch_count = val;
132 }
133
134 void set_profile_trip_cnt(float ptc) { _profile_trip_cnt = ptc; }
135 float profile_trip_cnt() { return _profile_trip_cnt; }
136
137 #ifndef PRODUCT
138 uint _stress_peeling_attempts = 0;
139 #endif
140
141 LoopNode(Node *entry, Node *backedge)
142 : RegionNode(3), _loop_flags(0), _unswitch_count(0),
143 _profile_trip_cnt(COUNT_UNKNOWN) {
144 init_class_id(Class_Loop);
722 // Check for Node being a loop-breaking test
723 Node *is_loop_exit(Node *iff) const;
724
725 // Return unique loop-exit projection or null if the loop has multiple exits.
726 IfFalseNode* unique_loop_exit_proj_or_null();
727
728 // Remove simplistic dead code from loop body
729 void DCE_loop_body();
730
731 // Look for loop-exit tests with my 50/50 guesses from the Parsing stage.
732 // Replace with a 1-in-10 exit guess.
733 void adjust_loop_exit_prob( PhaseIdealLoop *phase );
734
735 // Return TRUE or FALSE if the loop should never be RCE'd or aligned.
736 // Useful for unrolling loops with NO array accesses.
737 bool policy_peel_only( PhaseIdealLoop *phase ) const;
738
739 // Return TRUE or FALSE if the loop should be unswitched -- clone
740 // loop with an invariant test
741 bool policy_unswitching( PhaseIdealLoop *phase ) const;
742
743 // Micro-benchmark spamming. Remove empty loops.
744 bool do_remove_empty_loop( PhaseIdealLoop *phase );
745
746 // Convert one-iteration loop into normal code.
747 bool do_one_iteration_loop( PhaseIdealLoop *phase );
748
749 // Return TRUE or FALSE if the loop should be peeled or not. Peel if we can
750 // move some loop-invariant test (usually a null-check) before the loop.
751 bool policy_peeling(PhaseIdealLoop *phase);
752
753 uint estimate_peeling(PhaseIdealLoop *phase);
754
755 // Return TRUE or FALSE if the loop should be maximally unrolled. Stash any
756 // known trip count in the counted loop node.
757 bool policy_maximally_unroll(PhaseIdealLoop *phase) const;
758
759 // Return TRUE or FALSE if the loop should be unrolled or not. Apply unroll
760 // if the loop is a counted loop and the loop body is small enough.
761 bool policy_unroll(PhaseIdealLoop *phase);
1646
1647 public:
1648 // Change the control input of expensive nodes to allow commoning by
1649 // IGVN when it is guaranteed to not result in a more frequent
1650 // execution of the expensive node. Return true if progress.
1651 bool process_expensive_nodes();
1652
1653 // Check whether node has become unreachable
1654 bool is_node_unreachable(Node *n) const {
1655 return !has_node(n) || n->is_unreachable(_igvn);
1656 }
1657
1658 // Eliminate range-checks and other trip-counter vs loop-invariant tests.
1659 void do_range_check(IdealLoopTree* loop);
1660
1661 // Clone loop with an invariant test (that does not exit) and
1662 // insert a clone of the test that selects which version to
1663 // execute.
1664 void do_unswitching(IdealLoopTree* loop, Node_List& old_new);
1665
1666 IfNode* find_unswitch_candidate(const IdealLoopTree* loop) const;
1667
1668 private:
1669 static bool has_control_dependencies_from_predicates(LoopNode* head);
1670 static void revert_to_normal_loop(const LoopNode* loop_head);
1671
1672 void hoist_invariant_check_casts(const IdealLoopTree* loop, const Node_List& old_new,
1673 const UnswitchedLoopSelector& unswitched_loop_selector);
1674 void add_unswitched_loop_version_bodies_to_igvn(IdealLoopTree* loop, const Node_List& old_new);
1675 static void increment_unswitch_counts(LoopNode* original_head, LoopNode* new_head);
1676 void remove_unswitch_candidate_from_loops(const Node_List& old_new, const UnswitchedLoopSelector& unswitched_loop_selector);
1677 #ifndef PRODUCT
1678 static void trace_loop_unswitching_count(IdealLoopTree* loop, LoopNode* original_head);
1679 static void trace_loop_unswitching_impossible(const LoopNode* original_head);
1680 static void trace_loop_unswitching_result(const UnswitchedLoopSelector& unswitched_loop_selector,
1681 const LoopNode* original_head, const LoopNode* new_head);
1682 static void trace_loop_multiversioning_result(const LoopSelector& loop_selector,
1683 const LoopNode* original_head, const LoopNode* new_head);
1684 #endif
1685
1686 public:
1687
1688 // Range Check Elimination uses this function!
1689 // Constrain the main loop iterations so the affine function:
1690 // low_limit <= scale_con * I + offset < upper_limit
1691 // always holds true. That is, either increase the number of iterations in
1692 // the pre-loop or the post-loop until the condition holds true in the main
1693 // loop. Scale_con, offset and limit are all loop invariant.
1694 void add_constraint(jlong stride_con, jlong scale_con, Node* offset, Node* low_limit, Node* upper_limit, Node* pre_ctrl, Node** pre_limit, Node** main_limit);
1695 // Helper function for add_constraint().
1696 Node* adjust_limit(bool reduce, Node* scale, Node* offset, Node* rc_limit, Node* old_limit, Node* pre_ctrl, bool round);
1697
1698 // Partially peel loop up through last_peel node.
1699 bool partial_peel( IdealLoopTree *loop, Node_List &old_new );
1700 bool duplicate_loop_backedge(IdealLoopTree *loop, Node_List &old_new);
1852 void split_thru_phi_yank_old_nodes(Node* n, Node* region);
1853
1854 public:
1855
1856 // Conversion of fill/copy patterns into intrinsic versions
1857 bool do_intrinsify_fill();
1858 bool intrinsify_fill(IdealLoopTree* lpt);
1859 bool match_fill_loop(IdealLoopTree* lpt, Node*& store, Node*& store_value,
1860 Node*& shift, Node*& offset);
1861
1862 private:
1863 // Helper functions
1864 Node *spinup( Node *iff, Node *new_false, Node *new_true, Node *region, Node *phi, small_cache *cache );
1865 Node *find_use_block( Node *use, Node *def, Node *old_false, Node *new_false, Node *old_true, Node *new_true );
1866 void handle_use( Node *use, Node *def, small_cache *cache, Node *region_dom, Node *new_false, Node *new_true, Node *old_false, Node *old_true );
1867 bool split_up( Node *n, Node *blk1, Node *blk2 );
1868
1869 Node* place_outside_loop(Node* useblock, IdealLoopTree* loop) const;
1870 Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
1871 void try_move_store_after_loop(Node* n);
1872 bool identical_backtoback_ifs(Node *n);
1873 bool can_split_if(Node *n_ctrl);
1874 bool cannot_split_division(const Node* n, const Node* region) const;
1875 static bool is_divisor_loop_phi(const Node* divisor, const Node* loop);
1876 bool loop_phi_backedge_type_contains_zero(const Node* phi_divisor, const Type* zero) const;
1877
1878 // Determine if a method is too big for a/another round of split-if, based on
1879 // a magic (approximate) ratio derived from the equally magic constant 35000,
1880 // previously used for this purpose (but without relating to the node limit).
1881 bool must_throttle_split_if() {
1882 uint threshold = C->max_node_limit() * 2 / 5;
1883 return C->live_nodes() > threshold;
1884 }
1885
1886 // A simplistic node request tracking mechanism, where
1887 // = UINT_MAX Request not valid or made final.
1888 // < UINT_MAX Nodes currently requested (estimate).
1889 uint _nodes_required;
1890
1891 enum { REQUIRE_MIN = 70 };
1892
2043 uint new_counter, Node_List& old_new, Node_List& worklist, Node_List*& split_if_set,
2044 Node_List*& split_bool_set, Node_List*& split_cex_set);
2045
2046 void finish_clone_loop(Node_List* split_if_set, Node_List* split_bool_set, Node_List* split_cex_set);
2047
2048 bool at_relevant_ctrl(Node* n, const Node* blk1, const Node* blk2);
2049
2050 bool clone_cmp_loadklass_down(Node* n, const Node* blk1, const Node* blk2);
2051 void clone_loadklass_nodes_at_cmp_index(const Node* n, Node* cmp, int i);
2052 bool clone_cmp_down(Node* n, const Node* blk1, const Node* blk2);
2053 void clone_template_assertion_expression_down(Node* node);
2054
2055 Node* similar_subtype_check(const Node* x, Node* r_in);
2056
2057 void update_addp_chain_base(Node* x, Node* old_base, Node* new_base);
2058
2059 bool can_move_to_inner_loop(Node* n, LoopNode* n_loop, Node* x);
2060
2061 void pin_nodes_dependent_on(Node* ctrl, bool old_iff_is_rangecheck);
2062
2063 Node* ensure_node_and_inputs_are_above_pre_end(CountedLoopEndNode* pre_end, Node* node);
2064
2065 Node* new_assertion_predicate_opaque_init(Node* entry_control, Node* init, Node* int_zero);
2066
2067 bool try_make_short_running_loop(IdealLoopTree* loop, jint stride_con, const Node_List& range_checks, const uint iters_limit);
2068
2069 ConINode* intcon(jint i);
2070
2071 ConLNode* longcon(jlong i);
2072
2073 ConNode* makecon(const Type* t);
2074
2075 ConNode* integercon(jlong l, BasicType bt);
2076
2077 ConNode* zerocon(BasicType bt);
2078 };
2079
2080 class CountedLoopConverter {
2081 friend class PhaseIdealLoop;
2082
|
26 #define SHARE_OPTO_LOOPNODE_HPP
27
28 #include "opto/cfgnode.hpp"
29 #include "opto/multnode.hpp"
30 #include "opto/phaseX.hpp"
31 #include "opto/predicates.hpp"
32 #include "opto/subnode.hpp"
33 #include "opto/type.hpp"
34 #include "utilities/checkedCast.hpp"
35
36 class CmpNode;
37 class BaseCountedLoopEndNode;
38 class CountedLoopNode;
39 class IdealLoopTree;
40 class LoopNode;
41 class Node;
42 class OuterStripMinedLoopEndNode;
43 class PredicateBlock;
44 class PathFrequency;
45 class PhaseIdealLoop;
46 class UnswitchCandidate;
47 class LoopSelector;
48 class ReachabilityFenceNode;
49 class UnswitchedLoopSelector;
50 class VectorSet;
51 class VSharedData;
52 class Invariance;
53 struct small_cache;
54
55 //
56 // I D E A L I Z E D L O O P S
57 //
58 // Idealized loops are the set of loops I perform more interesting
59 // transformations on, beyond simple hoisting.
60
61 //------------------------------LoopNode---------------------------------------
62 // Simple loop header. Fall in path on left, loop-back path on right.
63 class LoopNode : public RegionNode {
64 // Size is bigger to hold the flags. However, the flags do not change
65 // the semantics so it does not appear in the hash & cmp functions.
66 virtual uint size_of() const { return sizeof(*this); }
70 enum { Normal=0, Pre=1, Main=2, Post=3, PreMainPostFlagsMask=3,
71 MainHasNoPreLoop = 1<<2,
72 HasExactTripCount = 1<<3,
73 InnerLoop = 1<<4,
74 PartialPeelLoop = 1<<5,
75 PartialPeelFailed = 1<<6,
76 WasSlpAnalyzed = 1<<7,
77 PassedSlpAnalysis = 1<<8,
78 DoUnrollOnly = 1<<9,
79 VectorizedLoop = 1<<10,
80 HasAtomicPostLoop = 1<<11,
81 StripMined = 1<<12,
82 SubwordLoop = 1<<13,
83 ProfileTripFailed = 1<<14,
84 LoopNestInnerLoop = 1<<15,
85 LoopNestLongOuterLoop = 1<<16,
86 MultiversionFastLoop = 1<<17,
87 MultiversionSlowLoop = 2<<17,
88 MultiversionDelayedSlowLoop = 3<<17,
89 MultiversionFlagsMask = 3<<17,
90 FlatArrays = 1<<18};
91 char _unswitch_count;
92 enum { _unswitch_max=3 };
93
94 // Expected trip count from profile data
95 float _profile_trip_cnt;
96
97 public:
98 // Names for edge indices
99 enum { Self=0, EntryControl, LoopBackControl };
100
101 bool is_inner_loop() const { return _loop_flags & InnerLoop; }
102 void set_inner_loop() { _loop_flags |= InnerLoop; }
103
104 bool is_vectorized_loop() const { return _loop_flags & VectorizedLoop; }
105 bool is_partial_peel_loop() const { return _loop_flags & PartialPeelLoop; }
106 void set_partial_peel_loop() { _loop_flags |= PartialPeelLoop; }
107 bool partial_peel_has_failed() const { return _loop_flags & PartialPeelFailed; }
108 bool is_strip_mined() const { return _loop_flags & StripMined; }
109 bool is_profile_trip_failed() const { return _loop_flags & ProfileTripFailed; }
110 bool is_subword_loop() const { return _loop_flags & SubwordLoop; }
111 bool is_loop_nest_inner_loop() const { return _loop_flags & LoopNestInnerLoop; }
112 bool is_loop_nest_outer_loop() const { return _loop_flags & LoopNestLongOuterLoop; }
113 bool is_flat_arrays() const { return _loop_flags & FlatArrays; }
114
115 void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
116 void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
117 void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }
118 void mark_do_unroll_only() { _loop_flags |= DoUnrollOnly; }
119 void mark_loop_vectorized() { _loop_flags |= VectorizedLoop; }
120 void mark_has_atomic_post_loop() { _loop_flags |= HasAtomicPostLoop; }
121 void mark_strip_mined() { _loop_flags |= StripMined; }
122 void clear_strip_mined() { _loop_flags &= ~StripMined; }
123 void mark_profile_trip_failed() { _loop_flags |= ProfileTripFailed; }
124 void mark_subword_loop() { _loop_flags |= SubwordLoop; }
125 void mark_loop_nest_inner_loop() { _loop_flags |= LoopNestInnerLoop; }
126 void mark_loop_nest_outer_loop() { _loop_flags |= LoopNestLongOuterLoop; }
127 void mark_flat_arrays() { _loop_flags |= FlatArrays; }
128
129 int unswitch_max() { return _unswitch_max; }
130 int unswitch_count() { return _unswitch_count; }
131
132 void set_unswitch_count(int val) {
133 assert (val <= unswitch_max(), "too many unswitches");
134 _unswitch_count = val;
135 }
136
137 void set_profile_trip_cnt(float ptc) { _profile_trip_cnt = ptc; }
138 float profile_trip_cnt() { return _profile_trip_cnt; }
139
140 #ifndef PRODUCT
141 uint _stress_peeling_attempts = 0;
142 #endif
143
144 LoopNode(Node *entry, Node *backedge)
145 : RegionNode(3), _loop_flags(0), _unswitch_count(0),
146 _profile_trip_cnt(COUNT_UNKNOWN) {
147 init_class_id(Class_Loop);
725 // Check for Node being a loop-breaking test
726 Node *is_loop_exit(Node *iff) const;
727
728 // Return unique loop-exit projection or null if the loop has multiple exits.
729 IfFalseNode* unique_loop_exit_proj_or_null();
730
731 // Remove simplistic dead code from loop body
732 void DCE_loop_body();
733
734 // Look for loop-exit tests with my 50/50 guesses from the Parsing stage.
735 // Replace with a 1-in-10 exit guess.
736 void adjust_loop_exit_prob( PhaseIdealLoop *phase );
737
738 // Return TRUE or FALSE if the loop should never be RCE'd or aligned.
739 // Useful for unrolling loops with NO array accesses.
740 bool policy_peel_only( PhaseIdealLoop *phase ) const;
741
742 // Return TRUE or FALSE if the loop should be unswitched -- clone
743 // loop with an invariant test
744 bool policy_unswitching( PhaseIdealLoop *phase ) const;
745 bool no_unswitch_candidate() const;
746
747 // Micro-benchmark spamming. Remove empty loops.
748 bool do_remove_empty_loop( PhaseIdealLoop *phase );
749
750 // Convert one-iteration loop into normal code.
751 bool do_one_iteration_loop( PhaseIdealLoop *phase );
752
753 // Return TRUE or FALSE if the loop should be peeled or not. Peel if we can
754 // move some loop-invariant test (usually a null-check) before the loop.
755 bool policy_peeling(PhaseIdealLoop *phase);
756
757 uint estimate_peeling(PhaseIdealLoop *phase);
758
759 // Return TRUE or FALSE if the loop should be maximally unrolled. Stash any
760 // known trip count in the counted loop node.
761 bool policy_maximally_unroll(PhaseIdealLoop *phase) const;
762
763 // Return TRUE or FALSE if the loop should be unrolled or not. Apply unroll
764 // if the loop is a counted loop and the loop body is small enough.
765 bool policy_unroll(PhaseIdealLoop *phase);
1650
1651 public:
1652 // Change the control input of expensive nodes to allow commoning by
1653 // IGVN when it is guaranteed to not result in a more frequent
1654 // execution of the expensive node. Return true if progress.
1655 bool process_expensive_nodes();
1656
1657 // Check whether node has become unreachable
1658 bool is_node_unreachable(Node *n) const {
1659 return !has_node(n) || n->is_unreachable(_igvn);
1660 }
1661
1662 // Eliminate range-checks and other trip-counter vs loop-invariant tests.
1663 void do_range_check(IdealLoopTree* loop);
1664
1665 // Clone loop with an invariant test (that does not exit) and
1666 // insert a clone of the test that selects which version to
1667 // execute.
1668 void do_unswitching(IdealLoopTree* loop, Node_List& old_new);
1669
1670 IfNode* find_unswitch_candidates(const IdealLoopTree* loop, Node_List& flat_array_checks) const;
1671 IfNode* find_unswitch_candidate_from_idoms(const IdealLoopTree* loop) const;
1672
1673 private:
1674 static bool has_control_dependencies_from_predicates(LoopNode* head);
1675 static void revert_to_normal_loop(const LoopNode* loop_head);
1676
1677 void hoist_invariant_check_casts(const IdealLoopTree* loop, const Node_List& old_new,
1678 const UnswitchCandidate& unswitch_candidate, const IfNode* loop_selector);
1679 void add_unswitched_loop_version_bodies_to_igvn(IdealLoopTree* loop, const Node_List& old_new);
1680 static void increment_unswitch_counts(LoopNode* original_head, LoopNode* new_head);
1681 void remove_unswitch_candidate_from_loops(const Node_List& old_new, const UnswitchedLoopSelector& unswitched_loop_selector);
1682 #ifndef PRODUCT
1683 static void trace_loop_unswitching_count(IdealLoopTree* loop, LoopNode* original_head);
1684 static void trace_loop_unswitching_impossible(const LoopNode* original_head);
1685 static void trace_loop_unswitching_result(const UnswitchedLoopSelector& unswitched_loop_selector,
1686 const UnswitchCandidate& unswitch_candidate,
1687 const LoopNode* original_head, const LoopNode* new_head);
1688 static void trace_loop_multiversioning_result(const LoopSelector& loop_selector,
1689 const LoopNode* original_head, const LoopNode* new_head);
1690 #endif
1691
1692 public:
1693
1694 // Range Check Elimination uses this function!
1695 // Constrain the main loop iterations so the affine function:
1696 // low_limit <= scale_con * I + offset < upper_limit
1697 // always holds true. That is, either increase the number of iterations in
1698 // the pre-loop or the post-loop until the condition holds true in the main
1699 // loop. Scale_con, offset and limit are all loop invariant.
1700 void add_constraint(jlong stride_con, jlong scale_con, Node* offset, Node* low_limit, Node* upper_limit, Node* pre_ctrl, Node** pre_limit, Node** main_limit);
1701 // Helper function for add_constraint().
1702 Node* adjust_limit(bool reduce, Node* scale, Node* offset, Node* rc_limit, Node* old_limit, Node* pre_ctrl, bool round);
1703
1704 // Partially peel loop up through last_peel node.
1705 bool partial_peel( IdealLoopTree *loop, Node_List &old_new );
1706 bool duplicate_loop_backedge(IdealLoopTree *loop, Node_List &old_new);
1858 void split_thru_phi_yank_old_nodes(Node* n, Node* region);
1859
1860 public:
1861
1862 // Conversion of fill/copy patterns into intrinsic versions
1863 bool do_intrinsify_fill();
1864 bool intrinsify_fill(IdealLoopTree* lpt);
1865 bool match_fill_loop(IdealLoopTree* lpt, Node*& store, Node*& store_value,
1866 Node*& shift, Node*& offset);
1867
1868 private:
1869 // Helper functions
1870 Node *spinup( Node *iff, Node *new_false, Node *new_true, Node *region, Node *phi, small_cache *cache );
1871 Node *find_use_block( Node *use, Node *def, Node *old_false, Node *new_false, Node *old_true, Node *new_true );
1872 void handle_use( Node *use, Node *def, small_cache *cache, Node *region_dom, Node *new_false, Node *new_true, Node *old_false, Node *old_true );
1873 bool split_up( Node *n, Node *blk1, Node *blk2 );
1874
1875 Node* place_outside_loop(Node* useblock, IdealLoopTree* loop) const;
1876 Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
1877 void try_move_store_after_loop(Node* n);
1878 void move_flat_array_check_out_of_loop(Node* n);
1879 bool identical_backtoback_ifs(Node *n);
1880 bool flat_array_element_type_check(Node *n);
1881 bool can_split_if(Node *n_ctrl);
1882 bool cannot_split_division(const Node* n, const Node* region) const;
1883 static bool is_divisor_loop_phi(const Node* divisor, const Node* loop);
1884 bool loop_phi_backedge_type_contains_zero(const Node* phi_divisor, const Type* zero) const;
1885
1886 // Determine if a method is too big for a/another round of split-if, based on
1887 // a magic (approximate) ratio derived from the equally magic constant 35000,
1888 // previously used for this purpose (but without relating to the node limit).
1889 bool must_throttle_split_if() {
1890 uint threshold = C->max_node_limit() * 2 / 5;
1891 return C->live_nodes() > threshold;
1892 }
1893
1894 // A simplistic node request tracking mechanism, where
1895 // = UINT_MAX Request not valid or made final.
1896 // < UINT_MAX Nodes currently requested (estimate).
1897 uint _nodes_required;
1898
1899 enum { REQUIRE_MIN = 70 };
1900
2051 uint new_counter, Node_List& old_new, Node_List& worklist, Node_List*& split_if_set,
2052 Node_List*& split_bool_set, Node_List*& split_cex_set);
2053
2054 void finish_clone_loop(Node_List* split_if_set, Node_List* split_bool_set, Node_List* split_cex_set);
2055
2056 bool at_relevant_ctrl(Node* n, const Node* blk1, const Node* blk2);
2057
2058 bool clone_cmp_loadklass_down(Node* n, const Node* blk1, const Node* blk2);
2059 void clone_loadklass_nodes_at_cmp_index(const Node* n, Node* cmp, int i);
2060 bool clone_cmp_down(Node* n, const Node* blk1, const Node* blk2);
2061 void clone_template_assertion_expression_down(Node* node);
2062
2063 Node* similar_subtype_check(const Node* x, Node* r_in);
2064
2065 void update_addp_chain_base(Node* x, Node* old_base, Node* new_base);
2066
2067 bool can_move_to_inner_loop(Node* n, LoopNode* n_loop, Node* x);
2068
2069 void pin_nodes_dependent_on(Node* ctrl, bool old_iff_is_rangecheck);
2070
2071 void collect_flat_array_checks(const IdealLoopTree* loop, Node_List& flat_array_checks) const;
2072
2073 Node* ensure_node_and_inputs_are_above_pre_end(CountedLoopEndNode* pre_end, Node* node);
2074
2075 Node* new_assertion_predicate_opaque_init(Node* entry_control, Node* init, Node* int_zero);
2076
2077 bool try_make_short_running_loop(IdealLoopTree* loop, jint stride_con, const Node_List& range_checks, const uint iters_limit);
2078
2079 ConINode* intcon(jint i);
2080
2081 ConLNode* longcon(jlong i);
2082
2083 ConNode* makecon(const Type* t);
2084
2085 ConNode* integercon(jlong l, BasicType bt);
2086
2087 ConNode* zerocon(BasicType bt);
2088 };
2089
2090 class CountedLoopConverter {
2091 friend class PhaseIdealLoop;
2092
|