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 UnswitchedLoopSelector;
48 class VectorSet;
49 class VSharedData;
50 class Invariance;
51 struct small_cache;
52
53 //
54 // I D E A L I Z E D L O O P S
55 //
56 // Idealized loops are the set of loops I perform more interesting
57 // transformations on, beyond simple hoisting.
58
59 //------------------------------LoopNode---------------------------------------
60 // Simple loop header. Fall in path on left, loop-back path on right.
61 class LoopNode : public RegionNode {
62 // Size is bigger to hold the flags. However, the flags do not change
63 // the semantics so it does not appear in the hash & cmp functions.
64 virtual uint size_of() const { return sizeof(*this); }
65 protected:
68 enum { Normal=0, Pre=1, Main=2, Post=3, PreMainPostFlagsMask=3,
69 MainHasNoPreLoop = 1<<2,
70 HasExactTripCount = 1<<3,
71 InnerLoop = 1<<4,
72 PartialPeelLoop = 1<<5,
73 PartialPeelFailed = 1<<6,
74 WasSlpAnalyzed = 1<<7,
75 PassedSlpAnalysis = 1<<8,
76 DoUnrollOnly = 1<<9,
77 VectorizedLoop = 1<<10,
78 HasAtomicPostLoop = 1<<11,
79 StripMined = 1<<12,
80 SubwordLoop = 1<<13,
81 ProfileTripFailed = 1<<14,
82 LoopNestInnerLoop = 1<<15,
83 LoopNestLongOuterLoop = 1<<16,
84 MultiversionFastLoop = 1<<17,
85 MultiversionSlowLoop = 2<<17,
86 MultiversionDelayedSlowLoop = 3<<17,
87 MultiversionFlagsMask = 3<<17,
88 };
89 char _unswitch_count;
90 enum { _unswitch_max=3 };
91
92 // Expected trip count from profile data
93 float _profile_trip_cnt;
94
95 public:
96 // Names for edge indices
97 enum { Self=0, EntryControl, LoopBackControl };
98
99 bool is_inner_loop() const { return _loop_flags & InnerLoop; }
100 void set_inner_loop() { _loop_flags |= InnerLoop; }
101
102 bool is_vectorized_loop() const { return _loop_flags & VectorizedLoop; }
103 bool is_partial_peel_loop() const { return _loop_flags & PartialPeelLoop; }
104 void set_partial_peel_loop() { _loop_flags |= PartialPeelLoop; }
105 bool partial_peel_has_failed() const { return _loop_flags & PartialPeelFailed; }
106 bool is_strip_mined() const { return _loop_flags & StripMined; }
107 bool is_profile_trip_failed() const { return _loop_flags & ProfileTripFailed; }
108 bool is_subword_loop() const { return _loop_flags & SubwordLoop; }
109 bool is_loop_nest_inner_loop() const { return _loop_flags & LoopNestInnerLoop; }
110 bool is_loop_nest_outer_loop() const { return _loop_flags & LoopNestLongOuterLoop; }
111
112 void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
113 void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
114 void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }
115 void mark_do_unroll_only() { _loop_flags |= DoUnrollOnly; }
116 void mark_loop_vectorized() { _loop_flags |= VectorizedLoop; }
117 void mark_has_atomic_post_loop() { _loop_flags |= HasAtomicPostLoop; }
118 void mark_strip_mined() { _loop_flags |= StripMined; }
119 void clear_strip_mined() { _loop_flags &= ~StripMined; }
120 void mark_profile_trip_failed() { _loop_flags |= ProfileTripFailed; }
121 void mark_subword_loop() { _loop_flags |= SubwordLoop; }
122 void mark_loop_nest_inner_loop() { _loop_flags |= LoopNestInnerLoop; }
123 void mark_loop_nest_outer_loop() { _loop_flags |= LoopNestLongOuterLoop; }
124
125 int unswitch_max() { return _unswitch_max; }
126 int unswitch_count() { return _unswitch_count; }
127
128 void set_unswitch_count(int val) {
129 assert (val <= unswitch_max(), "too many unswitches");
130 _unswitch_count = val;
131 }
132
133 void set_profile_trip_cnt(float ptc) { _profile_trip_cnt = ptc; }
134 float profile_trip_cnt() { return _profile_trip_cnt; }
135
136 #ifndef PRODUCT
137 uint _stress_peeling_attempts = 0;
138 #endif
139
140 LoopNode(Node *entry, Node *backedge)
141 : RegionNode(3), _loop_flags(0), _unswitch_count(0),
142 _profile_trip_cnt(COUNT_UNKNOWN) {
143 init_class_id(Class_Loop);
736 // Convert to counted loops where possible
737 void counted_loop( PhaseIdealLoop *phase );
738
739 // Check for Node being a loop-breaking test
740 Node *is_loop_exit(Node *iff) const;
741
742 // Remove simplistic dead code from loop body
743 void DCE_loop_body();
744
745 // Look for loop-exit tests with my 50/50 guesses from the Parsing stage.
746 // Replace with a 1-in-10 exit guess.
747 void adjust_loop_exit_prob( PhaseIdealLoop *phase );
748
749 // Return TRUE or FALSE if the loop should never be RCE'd or aligned.
750 // Useful for unrolling loops with NO array accesses.
751 bool policy_peel_only( PhaseIdealLoop *phase ) const;
752
753 // Return TRUE or FALSE if the loop should be unswitched -- clone
754 // loop with an invariant test
755 bool policy_unswitching( PhaseIdealLoop *phase ) const;
756
757 // Micro-benchmark spamming. Remove empty loops.
758 bool do_remove_empty_loop( PhaseIdealLoop *phase );
759
760 // Convert one-iteration loop into normal code.
761 bool do_one_iteration_loop( PhaseIdealLoop *phase );
762
763 // Return TRUE or FALSE if the loop should be peeled or not. Peel if we can
764 // move some loop-invariant test (usually a null-check) before the loop.
765 bool policy_peeling(PhaseIdealLoop *phase);
766
767 uint estimate_peeling(PhaseIdealLoop *phase);
768
769 // Return TRUE or FALSE if the loop should be maximally unrolled. Stash any
770 // known trip count in the counted loop node.
771 bool policy_maximally_unroll(PhaseIdealLoop *phase) const;
772
773 // Return TRUE or FALSE if the loop should be unrolled or not. Apply unroll
774 // if the loop is a counted loop and the loop body is small enough.
775 bool policy_unroll(PhaseIdealLoop *phase);
1546
1547 public:
1548 // Change the control input of expensive nodes to allow commoning by
1549 // IGVN when it is guaranteed to not result in a more frequent
1550 // execution of the expensive node. Return true if progress.
1551 bool process_expensive_nodes();
1552
1553 // Check whether node has become unreachable
1554 bool is_node_unreachable(Node *n) const {
1555 return !has_node(n) || n->is_unreachable(_igvn);
1556 }
1557
1558 // Eliminate range-checks and other trip-counter vs loop-invariant tests.
1559 void do_range_check(IdealLoopTree* loop);
1560
1561 // Clone loop with an invariant test (that does not exit) and
1562 // insert a clone of the test that selects which version to
1563 // execute.
1564 void do_unswitching(IdealLoopTree* loop, Node_List& old_new);
1565
1566 IfNode* find_unswitch_candidate(const IdealLoopTree* loop) const;
1567
1568 private:
1569 static bool has_control_dependencies_from_predicates(LoopNode* head);
1570 static void revert_to_normal_loop(const LoopNode* loop_head);
1571
1572 void hoist_invariant_check_casts(const IdealLoopTree* loop, const Node_List& old_new,
1573 const UnswitchedLoopSelector& unswitched_loop_selector);
1574 void add_unswitched_loop_version_bodies_to_igvn(IdealLoopTree* loop, const Node_List& old_new);
1575 static void increment_unswitch_counts(LoopNode* original_head, LoopNode* new_head);
1576 void remove_unswitch_candidate_from_loops(const Node_List& old_new, const UnswitchedLoopSelector& unswitched_loop_selector);
1577 #ifndef PRODUCT
1578 static void trace_loop_unswitching_count(IdealLoopTree* loop, LoopNode* original_head);
1579 static void trace_loop_unswitching_impossible(const LoopNode* original_head);
1580 static void trace_loop_unswitching_result(const UnswitchedLoopSelector& unswitched_loop_selector,
1581 const LoopNode* original_head, const LoopNode* new_head);
1582 static void trace_loop_multiversioning_result(const LoopSelector& loop_selector,
1583 const LoopNode* original_head, const LoopNode* new_head);
1584 #endif
1585
1586 public:
1587
1588 // Range Check Elimination uses this function!
1589 // Constrain the main loop iterations so the affine function:
1590 // low_limit <= scale_con * I + offset < upper_limit
1591 // always holds true. That is, either increase the number of iterations in
1592 // the pre-loop or the post-loop until the condition holds true in the main
1593 // loop. Scale_con, offset and limit are all loop invariant.
1594 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);
1595 // Helper function for add_constraint().
1596 Node* adjust_limit(bool reduce, Node* scale, Node* offset, Node* rc_limit, Node* old_limit, Node* pre_ctrl, bool round);
1597
1598 // Partially peel loop up through last_peel node.
1599 bool partial_peel( IdealLoopTree *loop, Node_List &old_new );
1600 bool duplicate_loop_backedge(IdealLoopTree *loop, Node_List &old_new);
1758 bool intrinsify_fill(IdealLoopTree* lpt);
1759 bool match_fill_loop(IdealLoopTree* lpt, Node*& store, Node*& store_value,
1760 Node*& shift, Node*& offset);
1761
1762 private:
1763 // Return a type based on condition control flow
1764 const TypeInt* filtered_type( Node *n, Node* n_ctrl);
1765 const TypeInt* filtered_type( Node *n ) { return filtered_type(n, nullptr); }
1766 // Helpers for filtered type
1767 const TypeInt* filtered_type_from_dominators( Node* val, Node *val_ctrl);
1768
1769 // Helper functions
1770 Node *spinup( Node *iff, Node *new_false, Node *new_true, Node *region, Node *phi, small_cache *cache );
1771 Node *find_use_block( Node *use, Node *def, Node *old_false, Node *new_false, Node *old_true, Node *new_true );
1772 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 );
1773 bool split_up( Node *n, Node *blk1, Node *blk2 );
1774
1775 Node* place_outside_loop(Node* useblock, IdealLoopTree* loop) const;
1776 Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
1777 void try_move_store_after_loop(Node* n);
1778 bool identical_backtoback_ifs(Node *n);
1779 bool can_split_if(Node *n_ctrl);
1780 bool cannot_split_division(const Node* n, const Node* region) const;
1781 static bool is_divisor_loop_phi(const Node* divisor, const Node* loop);
1782 bool loop_phi_backedge_type_contains_zero(const Node* phi_divisor, const Type* zero) const;
1783
1784 // Determine if a method is too big for a/another round of split-if, based on
1785 // a magic (approximate) ratio derived from the equally magic constant 35000,
1786 // previously used for this purpose (but without relating to the node limit).
1787 bool must_throttle_split_if() {
1788 uint threshold = C->max_node_limit() * 2 / 5;
1789 return C->live_nodes() > threshold;
1790 }
1791
1792 // A simplistic node request tracking mechanism, where
1793 // = UINT_MAX Request not valid or made final.
1794 // < UINT_MAX Nodes currently requested (estimate).
1795 uint _nodes_required;
1796
1797 enum { REQUIRE_MIN = 70 };
1798
1950 uint new_counter, Node_List& old_new, Node_List& worklist, Node_List*& split_if_set,
1951 Node_List*& split_bool_set, Node_List*& split_cex_set);
1952
1953 void finish_clone_loop(Node_List* split_if_set, Node_List* split_bool_set, Node_List* split_cex_set);
1954
1955 bool at_relevant_ctrl(Node* n, const Node* blk1, const Node* blk2);
1956
1957 bool clone_cmp_loadklass_down(Node* n, const Node* blk1, const Node* blk2);
1958 void clone_loadklass_nodes_at_cmp_index(const Node* n, Node* cmp, int i);
1959 bool clone_cmp_down(Node* n, const Node* blk1, const Node* blk2);
1960 void clone_template_assertion_expression_down(Node* node);
1961
1962 Node* similar_subtype_check(const Node* x, Node* r_in);
1963
1964 void update_addp_chain_base(Node* x, Node* old_base, Node* new_base);
1965
1966 bool can_move_to_inner_loop(Node* n, LoopNode* n_loop, Node* x);
1967
1968 void pin_array_access_nodes_dependent_on(Node* ctrl);
1969
1970 Node* ensure_node_and_inputs_are_above_pre_end(CountedLoopEndNode* pre_end, Node* node);
1971
1972 Node* new_assertion_predicate_opaque_init(Node* entry_control, Node* init, Node* int_zero);
1973
1974 bool try_make_short_running_loop(IdealLoopTree* loop, jint stride_con, const Node_List& range_checks, const uint iters_limit);
1975
1976 ConINode* intcon(jint i);
1977
1978 ConLNode* longcon(jlong i);
1979
1980 ConNode* makecon(const Type* t);
1981
1982 ConNode* integercon(jlong l, BasicType bt);
1983
1984 ConNode* zerocon(BasicType bt);
1985 };
1986
1987
1988 class AutoNodeBudget : public StackObj
1989 {
|
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 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); }
66 protected:
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 FlatArrays = 1<<18};
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 bool is_flat_arrays() const { return _loop_flags & FlatArrays; }
113
114 void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; }
115 void mark_was_slp() { _loop_flags |= WasSlpAnalyzed; }
116 void mark_passed_slp() { _loop_flags |= PassedSlpAnalysis; }
117 void mark_do_unroll_only() { _loop_flags |= DoUnrollOnly; }
118 void mark_loop_vectorized() { _loop_flags |= VectorizedLoop; }
119 void mark_has_atomic_post_loop() { _loop_flags |= HasAtomicPostLoop; }
120 void mark_strip_mined() { _loop_flags |= StripMined; }
121 void clear_strip_mined() { _loop_flags &= ~StripMined; }
122 void mark_profile_trip_failed() { _loop_flags |= ProfileTripFailed; }
123 void mark_subword_loop() { _loop_flags |= SubwordLoop; }
124 void mark_loop_nest_inner_loop() { _loop_flags |= LoopNestInnerLoop; }
125 void mark_loop_nest_outer_loop() { _loop_flags |= LoopNestLongOuterLoop; }
126 void mark_flat_arrays() { _loop_flags |= FlatArrays; }
127
128 int unswitch_max() { return _unswitch_max; }
129 int unswitch_count() { return _unswitch_count; }
130
131 void set_unswitch_count(int val) {
132 assert (val <= unswitch_max(), "too many unswitches");
133 _unswitch_count = val;
134 }
135
136 void set_profile_trip_cnt(float ptc) { _profile_trip_cnt = ptc; }
137 float profile_trip_cnt() { return _profile_trip_cnt; }
138
139 #ifndef PRODUCT
140 uint _stress_peeling_attempts = 0;
141 #endif
142
143 LoopNode(Node *entry, Node *backedge)
144 : RegionNode(3), _loop_flags(0), _unswitch_count(0),
145 _profile_trip_cnt(COUNT_UNKNOWN) {
146 init_class_id(Class_Loop);
739 // Convert to counted loops where possible
740 void counted_loop( PhaseIdealLoop *phase );
741
742 // Check for Node being a loop-breaking test
743 Node *is_loop_exit(Node *iff) const;
744
745 // Remove simplistic dead code from loop body
746 void DCE_loop_body();
747
748 // Look for loop-exit tests with my 50/50 guesses from the Parsing stage.
749 // Replace with a 1-in-10 exit guess.
750 void adjust_loop_exit_prob( PhaseIdealLoop *phase );
751
752 // Return TRUE or FALSE if the loop should never be RCE'd or aligned.
753 // Useful for unrolling loops with NO array accesses.
754 bool policy_peel_only( PhaseIdealLoop *phase ) const;
755
756 // Return TRUE or FALSE if the loop should be unswitched -- clone
757 // loop with an invariant test
758 bool policy_unswitching( PhaseIdealLoop *phase ) const;
759 bool no_unswitch_candidate() const;
760
761 // Micro-benchmark spamming. Remove empty loops.
762 bool do_remove_empty_loop( PhaseIdealLoop *phase );
763
764 // Convert one-iteration loop into normal code.
765 bool do_one_iteration_loop( PhaseIdealLoop *phase );
766
767 // Return TRUE or FALSE if the loop should be peeled or not. Peel if we can
768 // move some loop-invariant test (usually a null-check) before the loop.
769 bool policy_peeling(PhaseIdealLoop *phase);
770
771 uint estimate_peeling(PhaseIdealLoop *phase);
772
773 // Return TRUE or FALSE if the loop should be maximally unrolled. Stash any
774 // known trip count in the counted loop node.
775 bool policy_maximally_unroll(PhaseIdealLoop *phase) const;
776
777 // Return TRUE or FALSE if the loop should be unrolled or not. Apply unroll
778 // if the loop is a counted loop and the loop body is small enough.
779 bool policy_unroll(PhaseIdealLoop *phase);
1550
1551 public:
1552 // Change the control input of expensive nodes to allow commoning by
1553 // IGVN when it is guaranteed to not result in a more frequent
1554 // execution of the expensive node. Return true if progress.
1555 bool process_expensive_nodes();
1556
1557 // Check whether node has become unreachable
1558 bool is_node_unreachable(Node *n) const {
1559 return !has_node(n) || n->is_unreachable(_igvn);
1560 }
1561
1562 // Eliminate range-checks and other trip-counter vs loop-invariant tests.
1563 void do_range_check(IdealLoopTree* loop);
1564
1565 // Clone loop with an invariant test (that does not exit) and
1566 // insert a clone of the test that selects which version to
1567 // execute.
1568 void do_unswitching(IdealLoopTree* loop, Node_List& old_new);
1569
1570 IfNode* find_unswitch_candidates(const IdealLoopTree* loop, Node_List& flat_array_checks) const;
1571 IfNode* find_unswitch_candidate_from_idoms(const IdealLoopTree* loop) const;
1572
1573 private:
1574 static bool has_control_dependencies_from_predicates(LoopNode* head);
1575 static void revert_to_normal_loop(const LoopNode* loop_head);
1576
1577 void hoist_invariant_check_casts(const IdealLoopTree* loop, const Node_List& old_new,
1578 const UnswitchCandidate& unswitch_candidate, const IfNode* loop_selector);
1579 void add_unswitched_loop_version_bodies_to_igvn(IdealLoopTree* loop, const Node_List& old_new);
1580 static void increment_unswitch_counts(LoopNode* original_head, LoopNode* new_head);
1581 void remove_unswitch_candidate_from_loops(const Node_List& old_new, const UnswitchedLoopSelector& unswitched_loop_selector);
1582 #ifndef PRODUCT
1583 static void trace_loop_unswitching_count(IdealLoopTree* loop, LoopNode* original_head);
1584 static void trace_loop_unswitching_impossible(const LoopNode* original_head);
1585 static void trace_loop_unswitching_result(const UnswitchedLoopSelector& unswitched_loop_selector,
1586 const UnswitchCandidate& unswitch_candidate,
1587 const LoopNode* original_head, const LoopNode* new_head);
1588 static void trace_loop_multiversioning_result(const LoopSelector& loop_selector,
1589 const LoopNode* original_head, const LoopNode* new_head);
1590 #endif
1591
1592 public:
1593
1594 // Range Check Elimination uses this function!
1595 // Constrain the main loop iterations so the affine function:
1596 // low_limit <= scale_con * I + offset < upper_limit
1597 // always holds true. That is, either increase the number of iterations in
1598 // the pre-loop or the post-loop until the condition holds true in the main
1599 // loop. Scale_con, offset and limit are all loop invariant.
1600 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);
1601 // Helper function for add_constraint().
1602 Node* adjust_limit(bool reduce, Node* scale, Node* offset, Node* rc_limit, Node* old_limit, Node* pre_ctrl, bool round);
1603
1604 // Partially peel loop up through last_peel node.
1605 bool partial_peel( IdealLoopTree *loop, Node_List &old_new );
1606 bool duplicate_loop_backedge(IdealLoopTree *loop, Node_List &old_new);
1764 bool intrinsify_fill(IdealLoopTree* lpt);
1765 bool match_fill_loop(IdealLoopTree* lpt, Node*& store, Node*& store_value,
1766 Node*& shift, Node*& offset);
1767
1768 private:
1769 // Return a type based on condition control flow
1770 const TypeInt* filtered_type( Node *n, Node* n_ctrl);
1771 const TypeInt* filtered_type( Node *n ) { return filtered_type(n, nullptr); }
1772 // Helpers for filtered type
1773 const TypeInt* filtered_type_from_dominators( Node* val, Node *val_ctrl);
1774
1775 // Helper functions
1776 Node *spinup( Node *iff, Node *new_false, Node *new_true, Node *region, Node *phi, small_cache *cache );
1777 Node *find_use_block( Node *use, Node *def, Node *old_false, Node *new_false, Node *old_true, Node *new_true );
1778 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 );
1779 bool split_up( Node *n, Node *blk1, Node *blk2 );
1780
1781 Node* place_outside_loop(Node* useblock, IdealLoopTree* loop) const;
1782 Node* try_move_store_before_loop(Node* n, Node *n_ctrl);
1783 void try_move_store_after_loop(Node* n);
1784 void move_flat_array_check_out_of_loop(Node* n);
1785 bool identical_backtoback_ifs(Node *n);
1786 bool flat_array_element_type_check(Node *n);
1787 bool can_split_if(Node *n_ctrl);
1788 bool cannot_split_division(const Node* n, const Node* region) const;
1789 static bool is_divisor_loop_phi(const Node* divisor, const Node* loop);
1790 bool loop_phi_backedge_type_contains_zero(const Node* phi_divisor, const Type* zero) const;
1791
1792 // Determine if a method is too big for a/another round of split-if, based on
1793 // a magic (approximate) ratio derived from the equally magic constant 35000,
1794 // previously used for this purpose (but without relating to the node limit).
1795 bool must_throttle_split_if() {
1796 uint threshold = C->max_node_limit() * 2 / 5;
1797 return C->live_nodes() > threshold;
1798 }
1799
1800 // A simplistic node request tracking mechanism, where
1801 // = UINT_MAX Request not valid or made final.
1802 // < UINT_MAX Nodes currently requested (estimate).
1803 uint _nodes_required;
1804
1805 enum { REQUIRE_MIN = 70 };
1806
1958 uint new_counter, Node_List& old_new, Node_List& worklist, Node_List*& split_if_set,
1959 Node_List*& split_bool_set, Node_List*& split_cex_set);
1960
1961 void finish_clone_loop(Node_List* split_if_set, Node_List* split_bool_set, Node_List* split_cex_set);
1962
1963 bool at_relevant_ctrl(Node* n, const Node* blk1, const Node* blk2);
1964
1965 bool clone_cmp_loadklass_down(Node* n, const Node* blk1, const Node* blk2);
1966 void clone_loadklass_nodes_at_cmp_index(const Node* n, Node* cmp, int i);
1967 bool clone_cmp_down(Node* n, const Node* blk1, const Node* blk2);
1968 void clone_template_assertion_expression_down(Node* node);
1969
1970 Node* similar_subtype_check(const Node* x, Node* r_in);
1971
1972 void update_addp_chain_base(Node* x, Node* old_base, Node* new_base);
1973
1974 bool can_move_to_inner_loop(Node* n, LoopNode* n_loop, Node* x);
1975
1976 void pin_array_access_nodes_dependent_on(Node* ctrl);
1977
1978 void collect_flat_array_checks(const IdealLoopTree* loop, Node_List& flat_array_checks) const;
1979
1980 Node* ensure_node_and_inputs_are_above_pre_end(CountedLoopEndNode* pre_end, Node* node);
1981
1982 Node* new_assertion_predicate_opaque_init(Node* entry_control, Node* init, Node* int_zero);
1983
1984 bool try_make_short_running_loop(IdealLoopTree* loop, jint stride_con, const Node_List& range_checks, const uint iters_limit);
1985
1986 ConINode* intcon(jint i);
1987
1988 ConLNode* longcon(jlong i);
1989
1990 ConNode* makecon(const Type* t);
1991
1992 ConNode* integercon(jlong l, BasicType bt);
1993
1994 ConNode* zerocon(BasicType bt);
1995 };
1996
1997
1998 class AutoNodeBudget : public StackObj
1999 {
|