Mercurial > hg > truffle
annotate src/share/vm/opto/loopnode.hpp @ 14649:f6301b007a16
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | de6a9e811145 |
| children | 4ca6dc0799b6 5b8e0f84f00f |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
14223
de6a9e811145
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12956
diff
changeset
|
2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1303
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1303
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1303
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OPTO_LOOPNODE_HPP |
| 26 #define SHARE_VM_OPTO_LOOPNODE_HPP | |
| 27 | |
| 28 #include "opto/cfgnode.hpp" | |
| 29 #include "opto/multnode.hpp" | |
| 30 #include "opto/phaseX.hpp" | |
| 31 #include "opto/subnode.hpp" | |
| 32 #include "opto/type.hpp" | |
| 33 | |
| 0 | 34 class CmpNode; |
| 35 class CountedLoopEndNode; | |
| 36 class CountedLoopNode; | |
| 37 class IdealLoopTree; | |
| 38 class LoopNode; | |
| 39 class Node; | |
| 40 class PhaseIdealLoop; | |
| 41 class VectorSet; | |
| 1172 | 42 class Invariance; |
| 0 | 43 struct small_cache; |
| 44 | |
| 45 // | |
| 46 // I D E A L I Z E D L O O P S | |
| 47 // | |
| 48 // Idealized loops are the set of loops I perform more interesting | |
| 49 // transformations on, beyond simple hoisting. | |
| 50 | |
| 51 //------------------------------LoopNode--------------------------------------- | |
| 52 // Simple loop header. Fall in path on left, loop-back path on right. | |
| 53 class LoopNode : public RegionNode { | |
| 54 // Size is bigger to hold the flags. However, the flags do not change | |
| 55 // the semantics so it does not appear in the hash & cmp functions. | |
| 56 virtual uint size_of() const { return sizeof(*this); } | |
| 57 protected: | |
| 58 short _loop_flags; | |
| 59 // Names for flag bitfields | |
| 2465 | 60 enum { Normal=0, Pre=1, Main=2, Post=3, PreMainPostFlagsMask=3, |
| 61 MainHasNoPreLoop=4, | |
| 62 HasExactTripCount=8, | |
| 63 InnerLoop=16, | |
| 64 PartialPeelLoop=32, | |
| 65 PartialPeelFailed=64 }; | |
| 0 | 66 char _unswitch_count; |
| 67 enum { _unswitch_max=3 }; | |
| 68 | |
| 69 public: | |
| 70 // Names for edge indices | |
| 71 enum { Self=0, EntryControl, LoopBackControl }; | |
| 72 | |
| 2465 | 73 int is_inner_loop() const { return _loop_flags & InnerLoop; } |
| 74 void set_inner_loop() { _loop_flags |= InnerLoop; } | |
| 0 | 75 |
| 2465 | 76 int is_partial_peel_loop() const { return _loop_flags & PartialPeelLoop; } |
| 77 void set_partial_peel_loop() { _loop_flags |= PartialPeelLoop; } | |
| 78 int partial_peel_has_failed() const { return _loop_flags & PartialPeelFailed; } | |
| 79 void mark_partial_peel_failed() { _loop_flags |= PartialPeelFailed; } | |
| 0 | 80 |
| 81 int unswitch_max() { return _unswitch_max; } | |
| 82 int unswitch_count() { return _unswitch_count; } | |
| 83 void set_unswitch_count(int val) { | |
| 84 assert (val <= unswitch_max(), "too many unswitches"); | |
| 85 _unswitch_count = val; | |
| 86 } | |
| 87 | |
| 88 LoopNode( Node *entry, Node *backedge ) : RegionNode(3), _loop_flags(0), _unswitch_count(0) { | |
| 89 init_class_id(Class_Loop); | |
| 90 init_req(EntryControl, entry); | |
| 91 init_req(LoopBackControl, backedge); | |
| 92 } | |
| 93 | |
| 94 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 95 virtual int Opcode() const; | |
| 96 bool can_be_counted_loop(PhaseTransform* phase) const { | |
| 97 return req() == 3 && in(0) != NULL && | |
| 98 in(1) != NULL && phase->type(in(1)) != Type::TOP && | |
| 99 in(2) != NULL && phase->type(in(2)) != Type::TOP; | |
| 100 } | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
101 bool is_valid_counted_loop() const; |
| 0 | 102 #ifndef PRODUCT |
| 103 virtual void dump_spec(outputStream *st) const; | |
| 104 #endif | |
| 105 }; | |
| 106 | |
| 107 //------------------------------Counted Loops---------------------------------- | |
| 108 // Counted loops are all trip-counted loops, with exactly 1 trip-counter exit | |
| 109 // path (and maybe some other exit paths). The trip-counter exit is always | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
110 // last in the loop. The trip-counter have to stride by a constant; |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
111 // the exit value is also loop invariant. |
| 0 | 112 |
| 113 // CountedLoopNodes and CountedLoopEndNodes come in matched pairs. The | |
| 114 // CountedLoopNode has the incoming loop control and the loop-back-control | |
| 115 // which is always the IfTrue before the matching CountedLoopEndNode. The | |
| 116 // CountedLoopEndNode has an incoming control (possibly not the | |
| 117 // CountedLoopNode if there is control flow in the loop), the post-increment | |
| 118 // trip-counter value, and the limit. The trip-counter value is always of | |
| 119 // the form (Op old-trip-counter stride). The old-trip-counter is produced | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
120 // by a Phi connected to the CountedLoopNode. The stride is constant. |
| 0 | 121 // The Op is any commutable opcode, including Add, Mul, Xor. The |
| 122 // CountedLoopEndNode also takes in the loop-invariant limit value. | |
| 123 | |
| 124 // From a CountedLoopNode I can reach the matching CountedLoopEndNode via the | |
| 125 // loop-back control. From CountedLoopEndNodes I can reach CountedLoopNodes | |
| 126 // via the old-trip-counter from the Op node. | |
| 127 | |
| 128 //------------------------------CountedLoopNode-------------------------------- | |
| 129 // CountedLoopNodes head simple counted loops. CountedLoopNodes have as | |
| 130 // inputs the incoming loop-start control and the loop-back control, so they | |
| 131 // act like RegionNodes. They also take in the initial trip counter, the | |
| 132 // loop-invariant stride and the loop-invariant limit value. CountedLoopNodes | |
| 133 // produce a loop-body control and the trip counter value. Since | |
| 134 // CountedLoopNodes behave like RegionNodes I still have a standard CFG model. | |
| 135 | |
| 136 class CountedLoopNode : public LoopNode { | |
| 137 // Size is bigger to hold _main_idx. However, _main_idx does not change | |
| 138 // the semantics so it does not appear in the hash & cmp functions. | |
| 139 virtual uint size_of() const { return sizeof(*this); } | |
| 140 | |
| 141 // For Pre- and Post-loops during debugging ONLY, this holds the index of | |
| 142 // the Main CountedLoop. Used to assert that we understand the graph shape. | |
| 143 node_idx_t _main_idx; | |
| 144 | |
| 2465 | 145 // Known trip count calculated by compute_exact_trip_count() |
| 146 uint _trip_count; | |
| 0 | 147 |
| 148 // Expected trip count from profile data | |
| 149 float _profile_trip_cnt; | |
| 150 | |
| 151 // Log2 of original loop bodies in unrolled loop | |
| 152 int _unrolled_count_log2; | |
| 153 | |
| 154 // Node count prior to last unrolling - used to decide if | |
| 155 // unroll,optimize,unroll,optimize,... is making progress | |
| 156 int _node_count_before_unroll; | |
| 157 | |
| 158 public: | |
| 159 CountedLoopNode( Node *entry, Node *backedge ) | |
| 2465 | 160 : LoopNode(entry, backedge), _main_idx(0), _trip_count(max_juint), |
| 0 | 161 _profile_trip_cnt(COUNT_UNKNOWN), _unrolled_count_log2(0), |
| 162 _node_count_before_unroll(0) { | |
| 163 init_class_id(Class_CountedLoop); | |
| 164 // Initialize _trip_count to the largest possible value. | |
| 165 // Will be reset (lower) if the loop's trip count is known. | |
| 166 } | |
| 167 | |
| 168 virtual int Opcode() const; | |
| 169 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 170 | |
| 171 Node *init_control() const { return in(EntryControl); } | |
| 172 Node *back_control() const { return in(LoopBackControl); } | |
| 173 CountedLoopEndNode *loopexit() const; | |
| 174 Node *init_trip() const; | |
| 175 Node *stride() const; | |
| 176 int stride_con() const; | |
| 177 bool stride_is_con() const; | |
| 178 Node *limit() const; | |
| 179 Node *incr() const; | |
| 180 Node *phi() const; | |
| 181 | |
| 182 // Match increment with optional truncation | |
| 183 static Node* match_incr_with_optional_truncation(Node* expr, Node** trunc1, Node** trunc2, const TypeInt** trunc_type); | |
| 184 | |
| 185 // A 'main' loop has a pre-loop and a post-loop. The 'main' loop | |
| 186 // can run short a few iterations and may start a few iterations in. | |
| 187 // It will be RCE'd and unrolled and aligned. | |
| 188 | |
| 189 // A following 'post' loop will run any remaining iterations. Used | |
| 190 // during Range Check Elimination, the 'post' loop will do any final | |
| 191 // iterations with full checks. Also used by Loop Unrolling, where | |
| 192 // the 'post' loop will do any epilog iterations needed. Basically, | |
| 193 // a 'post' loop can not profitably be further unrolled or RCE'd. | |
| 194 | |
| 195 // A preceding 'pre' loop will run at least 1 iteration (to do peeling), | |
| 196 // it may do under-flow checks for RCE and may do alignment iterations | |
| 197 // so the following main loop 'knows' that it is striding down cache | |
| 198 // lines. | |
| 199 | |
| 200 // A 'main' loop that is ONLY unrolled or peeled, never RCE'd or | |
| 201 // Aligned, may be missing it's pre-loop. | |
| 2465 | 202 int is_normal_loop() const { return (_loop_flags&PreMainPostFlagsMask) == Normal; } |
| 203 int is_pre_loop () const { return (_loop_flags&PreMainPostFlagsMask) == Pre; } | |
| 204 int is_main_loop () const { return (_loop_flags&PreMainPostFlagsMask) == Main; } | |
| 205 int is_post_loop () const { return (_loop_flags&PreMainPostFlagsMask) == Post; } | |
| 206 int is_main_no_pre_loop() const { return _loop_flags & MainHasNoPreLoop; } | |
| 207 void set_main_no_pre_loop() { _loop_flags |= MainHasNoPreLoop; } | |
| 0 | 208 |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
209 int main_idx() const { return _main_idx; } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
210 |
| 0 | 211 |
| 212 void set_pre_loop (CountedLoopNode *main) { assert(is_normal_loop(),""); _loop_flags |= Pre ; _main_idx = main->_idx; } | |
| 213 void set_main_loop ( ) { assert(is_normal_loop(),""); _loop_flags |= Main; } | |
| 214 void set_post_loop (CountedLoopNode *main) { assert(is_normal_loop(),""); _loop_flags |= Post; _main_idx = main->_idx; } | |
| 2465 | 215 void set_normal_loop( ) { _loop_flags &= ~PreMainPostFlagsMask; } |
| 216 | |
| 217 void set_trip_count(uint tc) { _trip_count = tc; } | |
| 218 uint trip_count() { return _trip_count; } | |
| 0 | 219 |
| 2465 | 220 bool has_exact_trip_count() const { return (_loop_flags & HasExactTripCount) != 0; } |
| 221 void set_exact_trip_count(uint tc) { | |
| 222 _trip_count = tc; | |
| 223 _loop_flags |= HasExactTripCount; | |
| 224 } | |
| 225 void set_nonexact_trip_count() { | |
| 226 _loop_flags &= ~HasExactTripCount; | |
| 227 } | |
| 0 | 228 |
| 229 void set_profile_trip_cnt(float ptc) { _profile_trip_cnt = ptc; } | |
| 230 float profile_trip_cnt() { return _profile_trip_cnt; } | |
| 231 | |
| 232 void double_unrolled_count() { _unrolled_count_log2++; } | |
| 233 int unrolled_count() { return 1 << MIN2(_unrolled_count_log2, BitsPerInt-3); } | |
| 234 | |
| 235 void set_node_count_before_unroll(int ct) { _node_count_before_unroll = ct; } | |
| 236 int node_count_before_unroll() { return _node_count_before_unroll; } | |
| 237 | |
| 238 #ifndef PRODUCT | |
| 239 virtual void dump_spec(outputStream *st) const; | |
| 240 #endif | |
| 241 }; | |
| 242 | |
| 243 //------------------------------CountedLoopEndNode----------------------------- | |
| 244 // CountedLoopEndNodes end simple trip counted loops. They act much like | |
| 245 // IfNodes. | |
| 246 class CountedLoopEndNode : public IfNode { | |
| 247 public: | |
| 248 enum { TestControl, TestValue }; | |
| 249 | |
| 250 CountedLoopEndNode( Node *control, Node *test, float prob, float cnt ) | |
| 251 : IfNode( control, test, prob, cnt) { | |
| 252 init_class_id(Class_CountedLoopEnd); | |
| 253 } | |
| 254 virtual int Opcode() const; | |
| 255 | |
| 256 Node *cmp_node() const { return (in(TestValue)->req() >=2) ? in(TestValue)->in(1) : NULL; } | |
| 257 Node *incr() const { Node *tmp = cmp_node(); return (tmp && tmp->req()==3) ? tmp->in(1) : NULL; } | |
| 258 Node *limit() const { Node *tmp = cmp_node(); return (tmp && tmp->req()==3) ? tmp->in(2) : NULL; } | |
| 259 Node *stride() const { Node *tmp = incr (); return (tmp && tmp->req()==3) ? tmp->in(2) : NULL; } | |
| 260 Node *phi() const { Node *tmp = incr (); return (tmp && tmp->req()==3) ? tmp->in(1) : NULL; } | |
| 261 Node *init_trip() const { Node *tmp = phi (); return (tmp && tmp->req()==3) ? tmp->in(1) : NULL; } | |
| 262 int stride_con() const; | |
| 263 bool stride_is_con() const { Node *tmp = stride (); return (tmp != NULL && tmp->is_Con()); } | |
| 264 BoolTest::mask test_trip() const { return in(TestValue)->as_Bool()->_test._test; } | |
| 265 CountedLoopNode *loopnode() const { | |
|
8048
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
266 // The CountedLoopNode that goes with this CountedLoopEndNode may |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
267 // have been optimized out by the IGVN so be cautious with the |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
268 // pattern matching on the graph |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
269 if (phi() == NULL) { |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
270 return NULL; |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
271 } |
| 0 | 272 Node *ln = phi()->in(0); |
|
8048
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
273 if (ln->is_CountedLoop() && ln->as_CountedLoop()->loopexit() == this) { |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
274 return (CountedLoopNode*)ln; |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
275 } |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
276 return NULL; |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
277 } |
| 0 | 278 |
| 279 #ifndef PRODUCT | |
| 280 virtual void dump_spec(outputStream *st) const; | |
| 281 #endif | |
| 282 }; | |
| 283 | |
| 284 | |
| 285 inline CountedLoopEndNode *CountedLoopNode::loopexit() const { | |
| 286 Node *bc = back_control(); | |
| 287 if( bc == NULL ) return NULL; | |
| 288 Node *le = bc->in(0); | |
| 289 if( le->Opcode() != Op_CountedLoopEnd ) | |
| 290 return NULL; | |
| 291 return (CountedLoopEndNode*)le; | |
| 292 } | |
| 293 inline Node *CountedLoopNode::init_trip() const { return loopexit() ? loopexit()->init_trip() : NULL; } | |
| 294 inline Node *CountedLoopNode::stride() const { return loopexit() ? loopexit()->stride() : NULL; } | |
| 295 inline int CountedLoopNode::stride_con() const { return loopexit() ? loopexit()->stride_con() : 0; } | |
| 296 inline bool CountedLoopNode::stride_is_con() const { return loopexit() && loopexit()->stride_is_con(); } | |
| 297 inline Node *CountedLoopNode::limit() const { return loopexit() ? loopexit()->limit() : NULL; } | |
| 298 inline Node *CountedLoopNode::incr() const { return loopexit() ? loopexit()->incr() : NULL; } | |
| 299 inline Node *CountedLoopNode::phi() const { return loopexit() ? loopexit()->phi() : NULL; } | |
| 300 | |
| 3345 | 301 //------------------------------LoopLimitNode----------------------------- |
| 302 // Counted Loop limit node which represents exact final iterator value: | |
| 303 // trip_count = (limit - init_trip + stride - 1)/stride | |
| 304 // final_value= trip_count * stride + init_trip. | |
| 305 // Use HW instructions to calculate it when it can overflow in integer. | |
| 306 // Note, final_value should fit into integer since counted loop has | |
| 307 // limit check: limit <= max_int-stride. | |
| 308 class LoopLimitNode : public Node { | |
| 309 enum { Init=1, Limit=2, Stride=3 }; | |
| 310 public: | |
| 311 LoopLimitNode( Compile* C, Node *init, Node *limit, Node *stride ) : Node(0,init,limit,stride) { | |
| 312 // Put it on the Macro nodes list to optimize during macro nodes expansion. | |
| 313 init_flags(Flag_is_macro); | |
| 314 C->add_macro_node(this); | |
| 315 } | |
| 316 virtual int Opcode() const; | |
| 317 virtual const Type *bottom_type() const { return TypeInt::INT; } | |
| 318 virtual uint ideal_reg() const { return Op_RegI; } | |
| 319 virtual const Type *Value( PhaseTransform *phase ) const; | |
| 320 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
| 321 virtual Node *Identity( PhaseTransform *phase ); | |
| 322 }; | |
| 0 | 323 |
| 324 // -----------------------------IdealLoopTree---------------------------------- | |
| 325 class IdealLoopTree : public ResourceObj { | |
| 326 public: | |
| 327 IdealLoopTree *_parent; // Parent in loop tree | |
| 328 IdealLoopTree *_next; // Next sibling in loop tree | |
| 329 IdealLoopTree *_child; // First child in loop tree | |
| 330 | |
| 331 // The head-tail backedge defines the loop. | |
| 332 // If tail is NULL then this loop has multiple backedges as part of the | |
| 333 // same loop. During cleanup I'll peel off the multiple backedges; merge | |
| 334 // them at the loop bottom and flow 1 real backedge into the loop. | |
| 335 Node *_head; // Head of loop | |
| 336 Node *_tail; // Tail of loop | |
| 337 inline Node *tail(); // Handle lazy update of _tail field | |
| 338 PhaseIdealLoop* _phase; | |
| 339 | |
| 340 Node_List _body; // Loop body for inner loops | |
| 341 | |
| 342 uint8 _nest; // Nesting depth | |
| 343 uint8 _irreducible:1, // True if irreducible | |
| 344 _has_call:1, // True if has call safepoint | |
| 345 _has_sfpt:1, // True if has non-call safepoint | |
| 346 _rce_candidate:1; // True if candidate for range check elimination | |
| 347 | |
| 6636 | 348 Node_List* _safepts; // List of safepoints in this loop |
|
39
76256d272075
6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation
kvn
parents:
17
diff
changeset
|
349 Node_List* _required_safept; // A inner loop cannot delete these safepts; |
|
76256d272075
6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation
kvn
parents:
17
diff
changeset
|
350 bool _allow_optimizations; // Allow loop optimizations |
| 0 | 351 |
| 352 IdealLoopTree( PhaseIdealLoop* phase, Node *head, Node *tail ) | |
| 353 : _parent(0), _next(0), _child(0), | |
| 354 _head(head), _tail(tail), | |
| 355 _phase(phase), | |
| 6636 | 356 _safepts(NULL), |
| 0 | 357 _required_safept(NULL), |
|
39
76256d272075
6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation
kvn
parents:
17
diff
changeset
|
358 _allow_optimizations(true), |
| 0 | 359 _nest(0), _irreducible(0), _has_call(0), _has_sfpt(0), _rce_candidate(0) |
| 360 { } | |
| 361 | |
| 362 // Is 'l' a member of 'this'? | |
| 363 int is_member( const IdealLoopTree *l ) const; // Test for nested membership | |
| 364 | |
| 365 // Set loop nesting depth. Accumulate has_call bits. | |
| 366 int set_nest( uint depth ); | |
| 367 | |
| 368 // Split out multiple fall-in edges from the loop header. Move them to a | |
| 369 // private RegionNode before the loop. This becomes the loop landing pad. | |
| 370 void split_fall_in( PhaseIdealLoop *phase, int fall_in_cnt ); | |
| 371 | |
| 372 // Split out the outermost loop from this shared header. | |
| 373 void split_outer_loop( PhaseIdealLoop *phase ); | |
| 374 | |
| 375 // Merge all the backedges from the shared header into a private Region. | |
| 376 // Feed that region as the one backedge to this loop. | |
| 377 void merge_many_backedges( PhaseIdealLoop *phase ); | |
| 378 | |
| 379 // Split shared headers and insert loop landing pads. | |
| 380 // Insert a LoopNode to replace the RegionNode. | |
| 381 // Returns TRUE if loop tree is structurally changed. | |
| 382 bool beautify_loops( PhaseIdealLoop *phase ); | |
| 383 | |
| 1172 | 384 // Perform optimization to use the loop predicates for null checks and range checks. |
| 385 // Applies to any loop level (not just the innermost one) | |
| 386 bool loop_predication( PhaseIdealLoop *phase); | |
| 387 | |
|
401
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
388 // Perform iteration-splitting on inner loops. Split iterations to |
|
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
389 // avoid range checks or one-shot null checks. Returns false if the |
|
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
390 // current round of loop opts should stop. |
|
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
391 bool iteration_split( PhaseIdealLoop *phase, Node_List &old_new ); |
| 0 | 392 |
|
401
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
393 // Driver for various flavors of iteration splitting. Returns false |
|
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
394 // if the current round of loop opts should stop. |
|
ee8f06bfb27c
6743188: incomplete fix for 6700047 C2 failed in idom_no_update
never
parents:
367
diff
changeset
|
395 bool iteration_split_impl( PhaseIdealLoop *phase, Node_List &old_new ); |
| 0 | 396 |
| 397 // Given dominators, try to find loops with calls that must always be | |
| 398 // executed (call dominates loop tail). These loops do not need non-call | |
| 399 // safepoints (ncsfpt). | |
| 400 void check_safepts(VectorSet &visited, Node_List &stack); | |
| 401 | |
| 402 // Allpaths backwards scan from loop tail, terminating each path at first safepoint | |
| 403 // encountered. | |
| 404 void allpaths_check_safepts(VectorSet &visited, Node_List &stack); | |
| 405 | |
| 406 // Convert to counted loops where possible | |
| 407 void counted_loop( PhaseIdealLoop *phase ); | |
| 408 | |
| 409 // Check for Node being a loop-breaking test | |
| 410 Node *is_loop_exit(Node *iff) const; | |
| 411 | |
| 412 // Returns true if ctrl is executed on every complete iteration | |
| 413 bool dominates_backedge(Node* ctrl); | |
| 414 | |
| 415 // Remove simplistic dead code from loop body | |
| 416 void DCE_loop_body(); | |
| 417 | |
| 418 // Look for loop-exit tests with my 50/50 guesses from the Parsing stage. | |
| 419 // Replace with a 1-in-10 exit guess. | |
| 420 void adjust_loop_exit_prob( PhaseIdealLoop *phase ); | |
| 421 | |
| 422 // Return TRUE or FALSE if the loop should never be RCE'd or aligned. | |
| 423 // Useful for unrolling loops with NO array accesses. | |
| 424 bool policy_peel_only( PhaseIdealLoop *phase ) const; | |
| 425 | |
| 426 // Return TRUE or FALSE if the loop should be unswitched -- clone | |
| 427 // loop with an invariant test | |
| 428 bool policy_unswitching( PhaseIdealLoop *phase ) const; | |
| 429 | |
| 430 // Micro-benchmark spamming. Remove empty loops. | |
| 431 bool policy_do_remove_empty_loop( PhaseIdealLoop *phase ); | |
| 432 | |
| 2465 | 433 // Convert one iteration loop into normal code. |
| 434 bool policy_do_one_iteration_loop( PhaseIdealLoop *phase ); | |
| 435 | |
| 0 | 436 // Return TRUE or FALSE if the loop should be peeled or not. Peel if we can |
| 437 // make some loop-invariant test (usually a null-check) happen before the | |
| 438 // loop. | |
| 439 bool policy_peeling( PhaseIdealLoop *phase ) const; | |
| 440 | |
| 441 // Return TRUE or FALSE if the loop should be maximally unrolled. Stash any | |
| 442 // known trip count in the counted loop node. | |
| 443 bool policy_maximally_unroll( PhaseIdealLoop *phase ) const; | |
| 444 | |
| 445 // Return TRUE or FALSE if the loop should be unrolled or not. Unroll if | |
| 446 // the loop is a CountedLoop and the body is small enough. | |
| 447 bool policy_unroll( PhaseIdealLoop *phase ) const; | |
| 448 | |
| 449 // Return TRUE or FALSE if the loop should be range-check-eliminated. | |
| 450 // Gather a list of IF tests that are dominated by iteration splitting; | |
| 451 // also gather the end of the first split and the start of the 2nd split. | |
| 452 bool policy_range_check( PhaseIdealLoop *phase ) const; | |
| 453 | |
| 454 // Return TRUE or FALSE if the loop should be cache-line aligned. | |
| 455 // Gather the expression that does the alignment. Note that only | |
| 605 | 456 // one array base can be aligned in a loop (unless the VM guarantees |
| 0 | 457 // mutual alignment). Note that if we vectorize short memory ops |
| 458 // into longer memory ops, we may want to increase alignment. | |
| 459 bool policy_align( PhaseIdealLoop *phase ) const; | |
| 460 | |
| 1172 | 461 // Return TRUE if "iff" is a range check. |
| 462 bool is_range_check_if(IfNode *iff, PhaseIdealLoop *phase, Invariance& invar) const; | |
| 463 | |
| 2465 | 464 // Compute loop exact trip count if possible |
| 465 void compute_exact_trip_count( PhaseIdealLoop *phase ); | |
| 466 | |
| 0 | 467 // Compute loop trip count from profile data |
| 468 void compute_profile_trip_cnt( PhaseIdealLoop *phase ); | |
| 469 | |
| 470 // Reassociate invariant expressions. | |
| 471 void reassociate_invariants(PhaseIdealLoop *phase); | |
| 472 // Reassociate invariant add and subtract expressions. | |
| 473 Node* reassociate_add_sub(Node* n1, PhaseIdealLoop *phase); | |
| 474 // Return nonzero index of invariant operand if invariant and variant | |
| 605 | 475 // are combined with an Add or Sub. Helper for reassociate_invariants. |
| 0 | 476 int is_invariant_addition(Node* n, PhaseIdealLoop *phase); |
| 477 | |
| 478 // Return true if n is invariant | |
| 479 bool is_invariant(Node* n) const; | |
| 480 | |
| 481 // Put loop body on igvn work list | |
| 482 void record_for_igvn(); | |
| 483 | |
| 484 bool is_loop() { return !_irreducible && _tail && !_tail->is_top(); } | |
| 485 bool is_inner() { return is_loop() && _child == NULL; } | |
| 486 bool is_counted() { return is_loop() && _head != NULL && _head->is_CountedLoop(); } | |
| 487 | |
| 488 #ifndef PRODUCT | |
| 489 void dump_head( ) const; // Dump loop head only | |
| 490 void dump() const; // Dump this loop recursively | |
| 491 void verify_tree(IdealLoopTree *loop, const IdealLoopTree *parent) const; | |
| 492 #endif | |
| 493 | |
| 494 }; | |
| 495 | |
| 496 // -----------------------------PhaseIdealLoop--------------------------------- | |
| 497 // Computes the mapping from Nodes to IdealLoopTrees. Organizes IdealLoopTrees into a | |
| 498 // loop tree. Drives the loop-based transformations on the ideal graph. | |
| 499 class PhaseIdealLoop : public PhaseTransform { | |
| 500 friend class IdealLoopTree; | |
| 501 friend class SuperWord; | |
| 502 // Pre-computed def-use info | |
| 503 PhaseIterGVN &_igvn; | |
| 504 | |
| 505 // Head of loop tree | |
| 506 IdealLoopTree *_ltree_root; | |
| 507 | |
| 508 // Array of pre-order numbers, plus post-visited bit. | |
| 509 // ZERO for not pre-visited. EVEN for pre-visited but not post-visited. | |
| 510 // ODD for post-visited. Other bits are the pre-order number. | |
| 511 uint *_preorders; | |
| 512 uint _max_preorder; | |
| 513 | |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
514 const PhaseIdealLoop* _verify_me; |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
515 bool _verify_only; |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
516 |
| 0 | 517 // Allocate _preorders[] array |
| 518 void allocate_preorders() { | |
| 519 _max_preorder = C->unique()+8; | |
| 520 _preorders = NEW_RESOURCE_ARRAY(uint, _max_preorder); | |
| 521 memset(_preorders, 0, sizeof(uint) * _max_preorder); | |
| 522 } | |
| 523 | |
| 524 // Allocate _preorders[] array | |
| 525 void reallocate_preorders() { | |
| 526 if ( _max_preorder < C->unique() ) { | |
| 527 _preorders = REALLOC_RESOURCE_ARRAY(uint, _preorders, _max_preorder, C->unique()); | |
| 528 _max_preorder = C->unique(); | |
| 529 } | |
| 530 memset(_preorders, 0, sizeof(uint) * _max_preorder); | |
| 531 } | |
| 532 | |
| 533 // Check to grow _preorders[] array for the case when build_loop_tree_impl() | |
| 534 // adds new nodes. | |
| 535 void check_grow_preorders( ) { | |
| 536 if ( _max_preorder < C->unique() ) { | |
| 537 uint newsize = _max_preorder<<1; // double size of array | |
| 538 _preorders = REALLOC_RESOURCE_ARRAY(uint, _preorders, _max_preorder, newsize); | |
| 539 memset(&_preorders[_max_preorder],0,sizeof(uint)*(newsize-_max_preorder)); | |
| 540 _max_preorder = newsize; | |
| 541 } | |
| 542 } | |
| 543 // Check for pre-visited. Zero for NOT visited; non-zero for visited. | |
| 544 int is_visited( Node *n ) const { return _preorders[n->_idx]; } | |
| 545 // Pre-order numbers are written to the Nodes array as low-bit-set values. | |
| 546 void set_preorder_visited( Node *n, int pre_order ) { | |
| 547 assert( !is_visited( n ), "already set" ); | |
| 548 _preorders[n->_idx] = (pre_order<<1); | |
| 549 }; | |
| 550 // Return pre-order number. | |
| 551 int get_preorder( Node *n ) const { assert( is_visited(n), "" ); return _preorders[n->_idx]>>1; } | |
| 552 | |
| 553 // Check for being post-visited. | |
| 554 // Should be previsited already (checked with assert(is_visited(n))). | |
| 555 int is_postvisited( Node *n ) const { assert( is_visited(n), "" ); return _preorders[n->_idx]&1; } | |
| 556 | |
| 557 // Mark as post visited | |
| 558 void set_postvisited( Node *n ) { assert( !is_postvisited( n ), "" ); _preorders[n->_idx] |= 1; } | |
| 559 | |
| 560 // Set/get control node out. Set lower bit to distinguish from IdealLoopTree | |
| 561 // Returns true if "n" is a data node, false if it's a control node. | |
| 562 bool has_ctrl( Node *n ) const { return ((intptr_t)_nodes[n->_idx]) & 1; } | |
| 563 | |
| 564 // clear out dead code after build_loop_late | |
| 565 Node_List _deadlist; | |
| 566 | |
| 567 // Support for faster execution of get_late_ctrl()/dom_lca() | |
| 568 // when a node has many uses and dominator depth is deep. | |
| 569 Node_Array _dom_lca_tags; | |
| 570 void init_dom_lca_tags(); | |
| 571 void clear_dom_lca_tags(); | |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
572 |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
573 // Helper for debugging bad dominance relationships |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
574 bool verify_dominance(Node* n, Node* use, Node* LCA, Node* early); |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
575 |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
576 Node* compute_lca_of_uses(Node* n, Node* early, bool verify = false); |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
577 |
| 0 | 578 // Inline wrapper for frequent cases: |
| 579 // 1) only one use | |
| 580 // 2) a use is the same as the current LCA passed as 'n1' | |
| 581 Node *dom_lca_for_get_late_ctrl( Node *lca, Node *n, Node *tag ) { | |
| 582 assert( n->is_CFG(), "" ); | |
| 583 // Fast-path NULL lca | |
| 584 if( lca != NULL && lca != n ) { | |
| 585 assert( lca->is_CFG(), "" ); | |
| 586 // find LCA of all uses | |
| 587 n = dom_lca_for_get_late_ctrl_internal( lca, n, tag ); | |
| 588 } | |
| 589 return find_non_split_ctrl(n); | |
| 590 } | |
| 591 Node *dom_lca_for_get_late_ctrl_internal( Node *lca, Node *n, Node *tag ); | |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
592 |
| 0 | 593 // Helper function for directing control inputs away from CFG split |
| 594 // points. | |
| 595 Node *find_non_split_ctrl( Node *ctrl ) const { | |
| 596 if (ctrl != NULL) { | |
| 597 if (ctrl->is_MultiBranch()) { | |
| 598 ctrl = ctrl->in(0); | |
| 599 } | |
| 600 assert(ctrl->is_CFG(), "CFG"); | |
| 601 } | |
| 602 return ctrl; | |
| 603 } | |
| 604 | |
| 605 public: | |
|
8774
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
606 bool has_node( Node* n ) const { |
|
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
607 guarantee(n != NULL, "No Node."); |
|
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
608 return _nodes[n->_idx] != NULL; |
|
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
609 } |
| 0 | 610 // check if transform created new nodes that need _ctrl recorded |
| 611 Node *get_late_ctrl( Node *n, Node *early ); | |
| 612 Node *get_early_ctrl( Node *n ); | |
|
8048
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
613 Node *get_early_ctrl_for_expensive(Node *n, Node* earliest); |
| 0 | 614 void set_early_ctrl( Node *n ); |
| 615 void set_subtree_ctrl( Node *root ); | |
| 616 void set_ctrl( Node *n, Node *ctrl ) { | |
| 617 assert( !has_node(n) || has_ctrl(n), "" ); | |
| 618 assert( ctrl->in(0), "cannot set dead control node" ); | |
| 619 assert( ctrl == find_non_split_ctrl(ctrl), "must set legal crtl" ); | |
| 620 _nodes.map( n->_idx, (Node*)((intptr_t)ctrl + 1) ); | |
| 621 } | |
| 622 // Set control and update loop membership | |
| 623 void set_ctrl_and_loop(Node* n, Node* ctrl) { | |
| 624 IdealLoopTree* old_loop = get_loop(get_ctrl(n)); | |
| 625 IdealLoopTree* new_loop = get_loop(ctrl); | |
| 626 if (old_loop != new_loop) { | |
| 627 if (old_loop->_child == NULL) old_loop->_body.yank(n); | |
| 628 if (new_loop->_child == NULL) new_loop->_body.push(n); | |
| 629 } | |
| 630 set_ctrl(n, ctrl); | |
| 631 } | |
| 632 // Control nodes can be replaced or subsumed. During this pass they | |
| 633 // get their replacement Node in slot 1. Instead of updating the block | |
| 634 // location of all Nodes in the subsumed block, we lazily do it. As we | |
| 635 // pull such a subsumed block out of the array, we write back the final | |
| 636 // correct block. | |
| 637 Node *get_ctrl( Node *i ) { | |
| 638 assert(has_node(i), ""); | |
| 639 Node *n = get_ctrl_no_update(i); | |
| 640 _nodes.map( i->_idx, (Node*)((intptr_t)n + 1) ); | |
| 641 assert(has_node(i) && has_ctrl(i), ""); | |
| 642 assert(n == find_non_split_ctrl(n), "must return legal ctrl" ); | |
| 643 return n; | |
| 644 } | |
| 1172 | 645 // true if CFG node d dominates CFG node n |
| 646 bool is_dominator(Node *d, Node *n); | |
| 647 // return get_ctrl for a data node and self(n) for a CFG node | |
| 648 Node* ctrl_or_self(Node* n) { | |
| 649 if (has_ctrl(n)) | |
| 650 return get_ctrl(n); | |
| 651 else { | |
| 652 assert (n->is_CFG(), "must be a CFG node"); | |
| 653 return n; | |
| 654 } | |
| 655 } | |
| 0 | 656 |
| 657 private: | |
| 658 Node *get_ctrl_no_update( Node *i ) const { | |
| 659 assert( has_ctrl(i), "" ); | |
| 660 Node *n = (Node*)(((intptr_t)_nodes[i->_idx]) & ~1); | |
| 661 if (!n->in(0)) { | |
| 662 // Skip dead CFG nodes | |
| 663 do { | |
| 664 n = (Node*)(((intptr_t)_nodes[n->_idx]) & ~1); | |
| 665 } while (!n->in(0)); | |
| 666 n = find_non_split_ctrl(n); | |
| 667 } | |
| 668 return n; | |
| 669 } | |
| 670 | |
| 671 // Check for loop being set | |
| 672 // "n" must be a control node. Returns true if "n" is known to be in a loop. | |
| 673 bool has_loop( Node *n ) const { | |
| 674 assert(!has_node(n) || !has_ctrl(n), ""); | |
| 675 return has_node(n); | |
| 676 } | |
| 677 // Set loop | |
| 678 void set_loop( Node *n, IdealLoopTree *loop ) { | |
| 679 _nodes.map(n->_idx, (Node*)loop); | |
| 680 } | |
| 681 // Lazy-dazy update of 'get_ctrl' and 'idom_at' mechanisms. Replace | |
| 682 // the 'old_node' with 'new_node'. Kill old-node. Add a reference | |
| 683 // from old_node to new_node to support the lazy update. Reference | |
| 1172 | 684 // replaces loop reference, since that is not needed for dead node. |
| 0 | 685 public: |
| 686 void lazy_update( Node *old_node, Node *new_node ) { | |
| 687 assert( old_node != new_node, "no cycles please" ); | |
| 688 //old_node->set_req( 1, new_node /*NO DU INFO*/ ); | |
| 689 // Nodes always have DU info now, so re-use the side array slot | |
| 690 // for this node to provide the forwarding pointer. | |
| 691 _nodes.map( old_node->_idx, (Node*)((intptr_t)new_node + 1) ); | |
| 692 } | |
| 693 void lazy_replace( Node *old_node, Node *new_node ) { | |
|
1621
6027dddc26c6
6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents:
1552
diff
changeset
|
694 _igvn.replace_node( old_node, new_node ); |
| 0 | 695 lazy_update( old_node, new_node ); |
| 696 } | |
| 697 void lazy_replace_proj( Node *old_node, Node *new_node ) { | |
| 698 assert( old_node->req() == 1, "use this for Projs" ); | |
| 699 _igvn.hash_delete(old_node); // Must hash-delete before hacking edges | |
| 700 old_node->add_req( NULL ); | |
| 701 lazy_replace( old_node, new_node ); | |
| 702 } | |
| 703 | |
| 704 private: | |
| 705 | |
| 706 // Place 'n' in some loop nest, where 'n' is a CFG node | |
| 707 void build_loop_tree(); | |
| 708 int build_loop_tree_impl( Node *n, int pre_order ); | |
| 709 // Insert loop into the existing loop tree. 'innermost' is a leaf of the | |
| 710 // loop tree, not the root. | |
| 711 IdealLoopTree *sort( IdealLoopTree *loop, IdealLoopTree *innermost ); | |
| 712 | |
| 713 // Place Data nodes in some loop nest | |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
714 void build_loop_early( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ); |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
715 void build_loop_late ( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ); |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
716 void build_loop_late_post ( Node* n ); |
| 0 | 717 |
| 718 // Array of immediate dominance info for each CFG node indexed by node idx | |
| 719 private: | |
| 720 uint _idom_size; | |
| 721 Node **_idom; // Array of immediate dominators | |
| 722 uint *_dom_depth; // Used for fast LCA test | |
| 723 GrowableArray<uint>* _dom_stk; // For recomputation of dom depth | |
| 724 | |
| 725 Node* idom_no_update(Node* d) const { | |
| 726 assert(d->_idx < _idom_size, "oob"); | |
| 727 Node* n = _idom[d->_idx]; | |
| 728 assert(n != NULL,"Bad immediate dominator info."); | |
| 729 while (n->in(0) == NULL) { // Skip dead CFG nodes | |
| 730 //n = n->in(1); | |
| 731 n = (Node*)(((intptr_t)_nodes[n->_idx]) & ~1); | |
| 732 assert(n != NULL,"Bad immediate dominator info."); | |
| 733 } | |
| 734 return n; | |
| 735 } | |
| 736 Node *idom(Node* d) const { | |
| 737 uint didx = d->_idx; | |
| 738 Node *n = idom_no_update(d); | |
| 739 _idom[didx] = n; // Lazily remove dead CFG nodes from table. | |
| 740 return n; | |
| 741 } | |
| 742 uint dom_depth(Node* d) const { | |
|
8774
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
743 guarantee(d != NULL, "Null dominator info."); |
|
3b9368710f08
8008811: [parfait] Null pointer deference in hotspot/src/share/vm/opto/loopopts.cpp
morris
parents:
8048
diff
changeset
|
744 guarantee(d->_idx < _idom_size, ""); |
| 0 | 745 return _dom_depth[d->_idx]; |
| 746 } | |
| 747 void set_idom(Node* d, Node* n, uint dom_depth); | |
| 748 // Locally compute IDOM using dom_lca call | |
| 749 Node *compute_idom( Node *region ) const; | |
| 750 // Recompute dom_depth | |
| 751 void recompute_dom_depth(); | |
| 752 | |
| 753 // Is safept not required by an outer loop? | |
| 754 bool is_deleteable_safept(Node* sfpt); | |
| 755 | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
756 // Replace parallel induction variable (parallel to trip counter) |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
757 void replace_parallel_iv(IdealLoopTree *loop); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
758 |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
759 // Perform verification that the graph is valid. |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
760 PhaseIdealLoop( PhaseIterGVN &igvn) : |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
761 PhaseTransform(Ideal_Loop), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
762 _igvn(igvn), |
|
2248
194c9fdee631
7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1
kvn
parents:
1972
diff
changeset
|
763 _dom_lca_tags(arena()), // Thread::resource_area |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
764 _verify_me(NULL), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
765 _verify_only(true) { |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
3845
diff
changeset
|
766 build_and_optimize(false, false); |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
767 } |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
768 |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
769 // build the loop tree and perform any requested optimizations |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
3845
diff
changeset
|
770 void build_and_optimize(bool do_split_if, bool skip_loop_opts); |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
771 |
| 0 | 772 public: |
| 773 // Dominators for the sea of nodes | |
| 774 void Dominators(); | |
| 775 Node *dom_lca( Node *n1, Node *n2 ) const { | |
| 776 return find_non_split_ctrl(dom_lca_internal(n1, n2)); | |
| 777 } | |
| 778 Node *dom_lca_internal( Node *n1, Node *n2 ) const; | |
| 779 | |
| 780 // Compute the Ideal Node to Loop mapping | |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
3845
diff
changeset
|
781 PhaseIdealLoop( PhaseIterGVN &igvn, bool do_split_ifs, bool skip_loop_opts = false) : |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
782 PhaseTransform(Ideal_Loop), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
783 _igvn(igvn), |
|
2248
194c9fdee631
7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1
kvn
parents:
1972
diff
changeset
|
784 _dom_lca_tags(arena()), // Thread::resource_area |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
785 _verify_me(NULL), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
786 _verify_only(false) { |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
3845
diff
changeset
|
787 build_and_optimize(do_split_ifs, skip_loop_opts); |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
788 } |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
789 |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
790 // Verify that verify_me made the same decisions as a fresh run. |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
791 PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify_me) : |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
792 PhaseTransform(Ideal_Loop), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
793 _igvn(igvn), |
|
2248
194c9fdee631
7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1
kvn
parents:
1972
diff
changeset
|
794 _dom_lca_tags(arena()), // Thread::resource_area |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
795 _verify_me(verify_me), |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
796 _verify_only(false) { |
|
4064
670a74b863fc
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
3845
diff
changeset
|
797 build_and_optimize(false, false); |
|
921
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
798 } |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
799 |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
800 // Build and verify the loop tree without modifying the graph. This |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
801 // is useful to verify that all inputs properly dominate their uses. |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
802 static void verify(PhaseIterGVN& igvn) { |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
803 #ifdef ASSERT |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
804 PhaseIdealLoop v(igvn); |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
805 #endif |
|
046932b72aa2
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
605
diff
changeset
|
806 } |
| 0 | 807 |
| 808 // True if the method has at least 1 irreducible loop | |
| 809 bool _has_irreducible_loops; | |
| 810 | |
| 811 // Per-Node transform | |
| 812 virtual Node *transform( Node *a_node ) { return 0; } | |
| 813 | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
814 bool is_counted_loop( Node *x, IdealLoopTree *loop ); |
| 0 | 815 |
| 3345 | 816 Node* exact_limit( IdealLoopTree *loop ); |
| 817 | |
| 0 | 818 // Return a post-walked LoopNode |
| 819 IdealLoopTree *get_loop( Node *n ) const { | |
| 820 // Dead nodes have no loop, so return the top level loop instead | |
| 821 if (!has_node(n)) return _ltree_root; | |
| 822 assert(!has_ctrl(n), ""); | |
| 823 return (IdealLoopTree*)_nodes[n->_idx]; | |
| 824 } | |
| 825 | |
| 826 // Is 'n' a (nested) member of 'loop'? | |
| 827 int is_member( const IdealLoopTree *loop, Node *n ) const { | |
| 828 return loop->is_member(get_loop(n)); } | |
| 829 | |
| 830 // This is the basic building block of the loop optimizations. It clones an | |
| 831 // entire loop body. It makes an old_new loop body mapping; with this | |
| 832 // mapping you can find the new-loop equivalent to an old-loop node. All | |
| 833 // new-loop nodes are exactly equal to their old-loop counterparts, all | |
| 834 // edges are the same. All exits from the old-loop now have a RegionNode | |
| 835 // that merges the equivalent new-loop path. This is true even for the | |
| 836 // normal "loop-exit" condition. All uses of loop-invariant old-loop values | |
| 837 // now come from (one or more) Phis that merge their new-loop equivalents. | |
| 838 // Parameter side_by_side_idom: | |
| 839 // When side_by_size_idom is NULL, the dominator tree is constructed for | |
| 840 // the clone loop to dominate the original. Used in construction of | |
| 841 // pre-main-post loop sequence. | |
| 842 // When nonnull, the clone and original are side-by-side, both are | |
| 843 // dominated by the passed in side_by_side_idom node. Used in | |
| 844 // construction of unswitched loops. | |
| 845 void clone_loop( IdealLoopTree *loop, Node_List &old_new, int dom_depth, | |
| 846 Node* side_by_side_idom = NULL); | |
| 847 | |
| 848 // If we got the effect of peeling, either by actually peeling or by | |
| 849 // making a pre-loop which must execute at least once, we can remove | |
| 850 // all loop-invariant dominated tests in the main body. | |
| 851 void peeled_dom_test_elim( IdealLoopTree *loop, Node_List &old_new ); | |
| 852 | |
| 853 // Generate code to do a loop peel for the given loop (and body). | |
| 854 // old_new is a temp array. | |
| 855 void do_peeling( IdealLoopTree *loop, Node_List &old_new ); | |
| 856 | |
| 857 // Add pre and post loops around the given loop. These loops are used | |
| 858 // during RCE, unrolling and aligning loops. | |
| 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. | |
|
3788
e3cbc9ddd434
7044738: Loop unroll optimization causes incorrect result
kvn
parents:
3383
diff
changeset
|
862 Node *clone_up_backedge_goo( Node *back_ctrl, Node *preheader_ctrl, Node *n, VectorSet &visited, Node_Stack &clones ); |
| 0 | 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 | |
| 1172 | 879 // Create a new if above the uncommon_trap_if_pattern for the predicate to be promoted |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
880 ProjNode* create_new_if_for_predicate(ProjNode* cont_proj, Node* new_entry, |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
881 Deoptimization::DeoptReason reason); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
882 void register_control(Node* n, IdealLoopTree *loop, Node* pred); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
883 |
| 2445 | 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); | |
|
3845
c96c3eb1efae
7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post
kvn
parents:
3840
diff
changeset
|
889 |
| 2445 | 890 static Node* clone_loop_predicates(Node* old_entry, Node* new_entry, |
| 3345 | 891 bool clone_limit_check, |
| 2445 | 892 PhaseIdealLoop* loop_phase, |
| 893 PhaseIterGVN* igvn); | |
| 3345 | 894 Node* clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check); |
| 2445 | 895 |
| 896 static Node* skip_loop_predicates(Node* entry); | |
| 897 | |
| 898 // Find a good location to insert a predicate | |
|
2383
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
899 static ProjNode* find_predicate_insertion_point(Node* start_c, Deoptimization::DeoptReason reason); |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
900 // Find a predicate |
|
9dc311b8473e
7008866: Missing loop predicate for loop with multiple entries
kvn
parents:
2248
diff
changeset
|
901 static Node* find_predicate(Node* entry); |
| 1172 | 902 // Construct a range check for a predicate if |
| 3345 | 903 BoolNode* rc_predicate(IdealLoopTree *loop, Node* ctrl, |
| 1172 | 904 int scale, Node* offset, |
| 905 Node* init, Node* limit, Node* stride, | |
|
1303
c047da02984c
6930043: C2: SIGSEGV in javasoft.sqe.tests.lang.arr017.arr01702.arr01702.loop_forw(II)I
never
parents:
1172
diff
changeset
|
906 Node* range, bool upper); |
| 1172 | 907 |
| 908 // Implementation of the loop predication to promote checks outside the loop | |
| 909 bool loop_predication_impl(IdealLoopTree *loop); | |
| 910 | |
| 911 // Helper function to collect predicate for eliminating the useless ones | |
| 912 void collect_potentially_useful_predicates(IdealLoopTree *loop, Unique_Node_List &predicate_opaque1); | |
| 913 void eliminate_useless_predicates(); | |
| 914 | |
|
8048
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
915 // Change the control input of expensive nodes to allow commoning by |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
916 // IGVN when it is guaranteed to not result in a more frequent |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
917 // execution of the expensive node. Return true if progress. |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
918 bool process_expensive_nodes(); |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
919 |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
920 // Check whether node has become unreachable |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
921 bool is_node_unreachable(Node *n) const { |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
922 return !has_node(n) || n->is_unreachable(_igvn); |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
923 } |
|
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
924 |
| 0 | 925 // Eliminate range-checks and other trip-counter vs loop-invariant tests. |
| 926 void do_range_check( IdealLoopTree *loop, Node_List &old_new ); | |
| 927 | |
| 928 // Create a slow version of the loop by cloning the loop | |
| 929 // and inserting an if to select fast-slow versions. | |
| 930 ProjNode* create_slow_version_of_loop(IdealLoopTree *loop, | |
| 931 Node_List &old_new); | |
| 932 | |
| 933 // Clone loop with an invariant test (that does not exit) and | |
| 934 // insert a clone of the test that selects which version to | |
| 935 // execute. | |
| 936 void do_unswitching (IdealLoopTree *loop, Node_List &old_new); | |
| 937 | |
| 938 // Find candidate "if" for unswitching | |
| 939 IfNode* find_unswitching_candidate(const IdealLoopTree *loop) const; | |
| 940 | |
| 941 // Range Check Elimination uses this function! | |
| 942 // Constrain the main loop iterations so the affine function: | |
| 3345 | 943 // low_limit <= scale_con * I + offset < upper_limit |
| 0 | 944 // always holds true. That is, either increase the number of iterations in |
| 945 // the pre-loop or the post-loop until the condition holds true in the main | |
| 946 // loop. Scale_con, offset and limit are all loop invariant. | |
| 3345 | 947 void add_constraint( int stride_con, int scale_con, Node *offset, Node *low_limit, Node *upper_limit, Node *pre_ctrl, Node **pre_limit, Node **main_limit ); |
|
3383
38569792a45a
7044725: -XX:-UnrollLimitCheck -Xcomp : Exception: String index out of range: 29488
kvn
parents:
3345
diff
changeset
|
948 // Helper function for add_constraint(). |
|
38569792a45a
7044725: -XX:-UnrollLimitCheck -Xcomp : Exception: String index out of range: 29488
kvn
parents:
3345
diff
changeset
|
949 Node* adjust_limit( int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl ); |
| 0 | 950 |
| 951 // Partially peel loop up through last_peel node. | |
| 952 bool partial_peel( IdealLoopTree *loop, Node_List &old_new ); | |
| 953 | |
| 954 // Create a scheduled list of nodes control dependent on ctrl set. | |
| 955 void scheduled_nodelist( IdealLoopTree *loop, VectorSet& ctrl, Node_List &sched ); | |
| 956 // Has a use in the vector set | |
| 957 bool has_use_in_set( Node* n, VectorSet& vset ); | |
| 958 // Has use internal to the vector set (ie. not in a phi at the loop head) | |
| 959 bool has_use_internal_to_set( Node* n, VectorSet& vset, IdealLoopTree *loop ); | |
| 960 // clone "n" for uses that are outside of loop | |
|
10322
1682bec79205
8014811: loopTransform.cpp assert(cmp_end->in(2) == limit) failed
kvn
parents:
8774
diff
changeset
|
961 int clone_for_use_outside_loop( IdealLoopTree *loop, Node* n, Node_List& worklist ); |
| 0 | 962 // clone "n" for special uses that are in the not_peeled region |
| 963 void clone_for_special_use_inside_loop( IdealLoopTree *loop, Node* n, | |
| 964 VectorSet& not_peel, Node_List& sink_list, Node_List& worklist ); | |
| 965 // Insert phi(lp_entry_val, back_edge_val) at use->in(idx) for loop lp if phi does not already exist | |
| 966 void insert_phi_for_loop( Node* use, uint idx, Node* lp_entry_val, Node* back_edge_val, LoopNode* lp ); | |
| 967 #ifdef ASSERT | |
| 968 // Validate the loop partition sets: peel and not_peel | |
| 969 bool is_valid_loop_partition( IdealLoopTree *loop, VectorSet& peel, Node_List& peel_list, VectorSet& not_peel ); | |
| 970 // Ensure that uses outside of loop are of the right form | |
| 971 bool is_valid_clone_loop_form( IdealLoopTree *loop, Node_List& peel_list, | |
| 972 uint orig_exit_idx, uint clone_exit_idx); | |
| 973 bool is_valid_clone_loop_exit_use( IdealLoopTree *loop, Node* use, uint exit_idx); | |
| 974 #endif | |
| 975 | |
| 976 // Returns nonzero constant stride if-node is a possible iv test (otherwise returns zero.) | |
| 977 int stride_of_possible_iv( Node* iff ); | |
| 978 bool is_possible_iv_test( Node* iff ) { return stride_of_possible_iv(iff) != 0; } | |
| 979 // Return the (unique) control output node that's in the loop (if it exists.) | |
| 980 Node* stay_in_loop( Node* n, IdealLoopTree *loop); | |
| 981 // Insert a signed compare loop exit cloned from an unsigned compare. | |
| 982 IfNode* insert_cmpi_loop_exit(IfNode* if_cmpu, IdealLoopTree *loop); | |
| 983 void remove_cmpi_loop_exit(IfNode* if_cmp, IdealLoopTree *loop); | |
| 984 // Utility to register node "n" with PhaseIdealLoop | |
| 985 void register_node(Node* n, IdealLoopTree *loop, Node* pred, int ddepth); | |
| 986 // Utility to create an if-projection | |
| 987 ProjNode* proj_clone(ProjNode* p, IfNode* iff); | |
| 988 // Force the iff control output to be the live_proj | |
| 989 Node* short_circuit_if(IfNode* iff, ProjNode* live_proj); | |
| 990 // Insert a region before an if projection | |
| 991 RegionNode* insert_region_before_proj(ProjNode* proj); | |
| 992 // Insert a new if before an if projection | |
| 993 ProjNode* insert_if_before_proj(Node* left, bool Signed, BoolTest::mask relop, Node* right, ProjNode* proj); | |
| 994 | |
| 995 // Passed in a Phi merging (recursively) some nearly equivalent Bool/Cmps. | |
| 996 // "Nearly" because all Nodes have been cloned from the original in the loop, | |
| 997 // but the fall-in edges to the Cmp are different. Clone bool/Cmp pairs | |
| 998 // through the Phi recursively, and return a Bool. | |
| 999 BoolNode *clone_iff( PhiNode *phi, IdealLoopTree *loop ); | |
| 1000 CmpNode *clone_bool( PhiNode *phi, IdealLoopTree *loop ); | |
| 1001 | |
| 1002 | |
| 1003 // Rework addressing expressions to get the most loop-invariant stuff | |
| 1004 // moved out. We'd like to do all associative operators, but it's especially | |
| 1005 // important (common) to do address expressions. | |
| 1006 Node *remix_address_expressions( Node *n ); | |
| 1007 | |
| 1008 // Attempt to use a conditional move instead of a phi/branch | |
| 1009 Node *conditional_move( Node *n ); | |
| 1010 | |
| 1011 // Reorganize offset computations to lower register pressure. | |
| 1012 // Mostly prevent loop-fallout uses of the pre-incremented trip counter | |
| 1013 // (which are then alive with the post-incremented trip counter | |
| 1014 // forcing an extra register move) | |
| 1015 void reorg_offsets( IdealLoopTree *loop ); | |
| 1016 | |
| 1017 // Check for aggressive application of 'split-if' optimization, | |
| 1018 // using basic block level info. | |
| 1019 void split_if_with_blocks ( VectorSet &visited, Node_Stack &nstack ); | |
| 1020 Node *split_if_with_blocks_pre ( Node *n ); | |
| 1021 void split_if_with_blocks_post( Node *n ); | |
| 1022 Node *has_local_phi_input( Node *n ); | |
| 1023 // Mark an IfNode as being dominated by a prior test, | |
| 1024 // without actually altering the CFG (and hence IDOM info). | |
|
3840
4e761e7e6e12
7070134: Hotspot crashes with sigsegv from PorterStemmer
kvn
parents:
3788
diff
changeset
|
1025 void dominated_by( Node *prevdom, Node *iff, bool flip = false, bool exclude_loop_predicate = false ); |
| 0 | 1026 |
| 1027 // Split Node 'n' through merge point | |
| 1028 Node *split_thru_region( Node *n, Node *region ); | |
| 1029 // Split Node 'n' through merge point if there is enough win. | |
| 1030 Node *split_thru_phi( Node *n, Node *region, int policy ); | |
| 1031 // Found an If getting its condition-code input from a Phi in the | |
| 1032 // same block. Split thru the Region. | |
| 1033 void do_split_if( Node *iff ); | |
| 1034 | |
| 1763 | 1035 // Conversion of fill/copy patterns into intrisic versions |
| 1036 bool do_intrinsify_fill(); | |
| 1037 bool intrinsify_fill(IdealLoopTree* lpt); | |
| 1038 bool match_fill_loop(IdealLoopTree* lpt, Node*& store, Node*& store_value, | |
| 1039 Node*& shift, Node*& offset); | |
| 1040 | |
| 0 | 1041 private: |
| 1042 // Return a type based on condition control flow | |
| 1043 const TypeInt* filtered_type( Node *n, Node* n_ctrl); | |
| 1044 const TypeInt* filtered_type( Node *n ) { return filtered_type(n, NULL); } | |
| 1045 // Helpers for filtered type | |
| 1046 const TypeInt* filtered_type_from_dominators( Node* val, Node *val_ctrl); | |
| 1047 | |
| 1048 // Helper functions | |
| 1049 Node *spinup( Node *iff, Node *new_false, Node *new_true, Node *region, Node *phi, small_cache *cache ); | |
| 1050 Node *find_use_block( Node *use, Node *def, Node *old_false, Node *new_false, Node *old_true, Node *new_true ); | |
| 1051 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 ); | |
| 1052 bool split_up( Node *n, Node *blk1, Node *blk2 ); | |
| 1053 void sink_use( Node *use, Node *post_loop ); | |
| 1054 Node *place_near_use( Node *useblock ) const; | |
| 1055 | |
| 1056 bool _created_loop_node; | |
| 1057 public: | |
| 1058 void set_created_loop_node() { _created_loop_node = true; } | |
| 1059 bool created_loop_node() { return _created_loop_node; } | |
| 1172 | 1060 void register_new_node( Node *n, Node *blk ); |
| 0 | 1061 |
|
4779
c8d8e124380c
7064302: JDK7 build 147 crashed after testing my java 6-compiled web app
kvn
parents:
4064
diff
changeset
|
1062 #ifdef ASSERT |
|
8048
8b3da8d14c93
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
6842
diff
changeset
|
1063 void dump_bad_graph(const char* msg, Node* n, Node* early, Node* LCA); |
|
4779
c8d8e124380c
7064302: JDK7 build 147 crashed after testing my java 6-compiled web app
kvn
parents:
4064
diff
changeset
|
1064 #endif |
|
c8d8e124380c
7064302: JDK7 build 147 crashed after testing my java 6-compiled web app
kvn
parents:
4064
diff
changeset
|
1065 |
| 0 | 1066 #ifndef PRODUCT |
| 1067 void dump( ) const; | |
| 1068 void dump( IdealLoopTree *loop, uint rpo_idx, Node_List &rpo_list ) const; | |
| 1069 void rpo( Node *start, Node_Stack &stk, VectorSet &visited, Node_List &rpo_list ) const; | |
| 1070 void verify() const; // Major slow :-) | |
| 1071 void verify_compare( Node *n, const PhaseIdealLoop *loop_verify, VectorSet &visited ) const; | |
| 1072 IdealLoopTree *get_loop_idx(Node* n) const { | |
| 1073 // Dead nodes have no loop, so return the top level loop instead | |
| 1074 return _nodes[n->_idx] ? (IdealLoopTree*)_nodes[n->_idx] : _ltree_root; | |
| 1075 } | |
| 1076 // Print some stats | |
| 1077 static void print_statistics(); | |
| 1078 static int _loop_invokes; // Count of PhaseIdealLoop invokes | |
| 1079 static int _loop_work; // Sum of PhaseIdealLoop x _unique | |
| 1080 #endif | |
| 1081 }; | |
| 1082 | |
| 1083 inline Node* IdealLoopTree::tail() { | |
| 1084 // Handle lazy update of _tail field | |
| 1085 Node *n = _tail; | |
| 1086 //while( !n->in(0) ) // Skip dead CFG nodes | |
| 1087 //n = n->in(1); | |
| 1088 if (n->in(0) == NULL) | |
| 1089 n = _phase->get_ctrl(n); | |
| 1090 _tail = n; | |
| 1091 return n; | |
| 1092 } | |
| 1093 | |
| 1094 | |
| 1095 // Iterate over the loop tree using a preorder, left-to-right traversal. | |
| 1096 // | |
| 1097 // Example that visits all counted loops from within PhaseIdealLoop | |
| 1098 // | |
| 1099 // for (LoopTreeIterator iter(_ltree_root); !iter.done(); iter.next()) { | |
| 1100 // IdealLoopTree* lpt = iter.current(); | |
| 1101 // if (!lpt->is_counted()) continue; | |
| 1102 // ... | |
| 1103 class LoopTreeIterator : public StackObj { | |
| 1104 private: | |
| 1105 IdealLoopTree* _root; | |
| 1106 IdealLoopTree* _curnt; | |
| 1107 | |
| 1108 public: | |
| 1109 LoopTreeIterator(IdealLoopTree* root) : _root(root), _curnt(root) {} | |
| 1110 | |
| 1111 bool done() { return _curnt == NULL; } // Finished iterating? | |
| 1112 | |
| 1113 void next(); // Advance to next loop tree | |
| 1114 | |
| 1115 IdealLoopTree* current() { return _curnt; } // Return current value of iterator. | |
| 1116 }; | |
| 1972 | 1117 |
| 1118 #endif // SHARE_VM_OPTO_LOOPNODE_HPP |