truffle: src/share/vm/opto/loopnode.cpp annotate

annotate src/share/vm/opto/loopnode.cpp @ 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	3213ba4d3dff
children	cd3c534f8f4a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8868 diff changeset	2 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1172 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1172 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: 1172 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	26 #include "ci/ciMethodData.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	27 #include "compiler/compileLog.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	28 #include "libadt/vectset.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	29 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	30 #include "opto/addnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	31 #include "opto/callnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	32 #include "opto/connode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	33 #include "opto/divnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	34 #include "opto/idealGraphPrinter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	35 #include "opto/loopnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	36 #include "opto/mulnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	37 #include "opto/rootnode.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1763 diff changeset	38 #include "opto/superword.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	41 //------------------------------is_loop_iv-------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	42 // Determine if a node is Counted loop induction variable.
a61af66fc99e Initial load duke parents: diff changeset	43 // The method is declared in node.hpp.
a61af66fc99e Initial load duke parents: diff changeset	44 const Node* Node::is_loop_iv() const {
a61af66fc99e Initial load duke parents: diff changeset	45 if (this->is_Phi() && !this->as_Phi()->is_copy() &&
a61af66fc99e Initial load duke parents: diff changeset	46 this->as_Phi()->region()->is_CountedLoop() &&
a61af66fc99e Initial load duke parents: diff changeset	47 this->as_Phi()->region()->as_CountedLoop()->phi() == this) {
a61af66fc99e Initial load duke parents: diff changeset	48 return this;
a61af66fc99e Initial load duke parents: diff changeset	49 } else {
a61af66fc99e Initial load duke parents: diff changeset	50 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	51 }
a61af66fc99e Initial load duke parents: diff changeset	52 }
a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	55 //------------------------------dump_spec--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	56 // Dump special per-node info
a61af66fc99e Initial load duke parents: diff changeset	57 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	58 void LoopNode::dump_spec(outputStream *st) const {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	59 if (is_inner_loop()) st->print( "inner " );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	60 if (is_partial_peel_loop()) st->print( "partial_peel " );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	61 if (partial_peel_has_failed()) st->print( "partial_peel_failed " );
0 a61af66fc99e Initial load duke parents: diff changeset	62 }
a61af66fc99e Initial load duke parents: diff changeset	63 #endif
a61af66fc99e Initial load duke parents: diff changeset	64
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	65 //------------------------------is_valid_counted_loop-------------------------
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	66 bool LoopNode::is_valid_counted_loop() const {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	67 if (is_CountedLoop()) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	68 CountedLoopNode* l = as_CountedLoop();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	69 CountedLoopEndNode* le = l->loopexit();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	70 if (le != NULL &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	71 le->proj_out(1 /* true */) == l->in(LoopNode::LoopBackControl)) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	72 Node* phi = l->phi();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	73 Node* exit = le->proj_out(0 /* false */);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	74 if (exit != NULL && exit->Opcode() == Op_IfFalse &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	75 phi != NULL && phi->is_Phi() &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	76 phi->in(LoopNode::LoopBackControl) == l->incr() &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	77 le->loopnode() == l && le->stride_is_con()) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	78 return true;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	79 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	80 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	81 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	82 return false;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	83 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	84
0 a61af66fc99e Initial load duke parents: diff changeset	85 //------------------------------get_early_ctrl---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	86 // Compute earliest legal control
a61af66fc99e Initial load duke parents: diff changeset	87 Node PhaseIdealLoop::get_early_ctrl( Node n ) {
a61af66fc99e Initial load duke parents: diff changeset	88 assert( !n->is_Phi() && !n->is_CFG(), "this code only handles data nodes" );
a61af66fc99e Initial load duke parents: diff changeset	89 uint i;
a61af66fc99e Initial load duke parents: diff changeset	90 Node *early;
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	91 if (n->in(0) && !n->is_expensive()) {
0 a61af66fc99e Initial load duke parents: diff changeset	92 early = n->in(0);
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	93 if (!early->is_CFG()) // Might be a non-CFG multi-def
0 a61af66fc99e Initial load duke parents: diff changeset	94 early = get_ctrl(early); // So treat input as a straight data input
a61af66fc99e Initial load duke parents: diff changeset	95 i = 1;
a61af66fc99e Initial load duke parents: diff changeset	96 } else {
a61af66fc99e Initial load duke parents: diff changeset	97 early = get_ctrl(n->in(1));
a61af66fc99e Initial load duke parents: diff changeset	98 i = 2;
a61af66fc99e Initial load duke parents: diff changeset	99 }
a61af66fc99e Initial load duke parents: diff changeset	100 uint e_d = dom_depth(early);
a61af66fc99e Initial load duke parents: diff changeset	101 assert( early, "" );
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	102 for (; i < n->req(); i++) {
0 a61af66fc99e Initial load duke parents: diff changeset	103 Node *cin = get_ctrl(n->in(i));
a61af66fc99e Initial load duke parents: diff changeset	104 assert( cin, "" );
a61af66fc99e Initial load duke parents: diff changeset	105 // Keep deepest dominator depth
a61af66fc99e Initial load duke parents: diff changeset	106 uint c_d = dom_depth(cin);
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	107 if (c_d > e_d) { // Deeper guy?
0 a61af66fc99e Initial load duke parents: diff changeset	108 early = cin; // Keep deepest found so far
a61af66fc99e Initial load duke parents: diff changeset	109 e_d = c_d;
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	110 } else if (c_d == e_d && // Same depth?
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	111 early != cin) { // If not equal, must use slower algorithm
0 a61af66fc99e Initial load duke parents: diff changeset	112 // If same depth but not equal, one _must_ dominate the other
a61af66fc99e Initial load duke parents: diff changeset	113 // and we want the deeper (i.e., dominated) guy.
a61af66fc99e Initial load duke parents: diff changeset	114 Node *n1 = early;
a61af66fc99e Initial load duke parents: diff changeset	115 Node *n2 = cin;
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	116 while (1) {
0 a61af66fc99e Initial load duke parents: diff changeset	117 n1 = idom(n1); // Walk up until break cycle
a61af66fc99e Initial load duke parents: diff changeset	118 n2 = idom(n2);
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	119 if (n1 == cin \|\| // Walked early up to cin
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	120 dom_depth(n2) < c_d)
0 a61af66fc99e Initial load duke parents: diff changeset	121 break; // early is deeper; keep him
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	122 if (n2 == early \|\| // Walked cin up to early
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	123 dom_depth(n1) < c_d) {
0 a61af66fc99e Initial load duke parents: diff changeset	124 early = cin; // cin is deeper; keep him
a61af66fc99e Initial load duke parents: diff changeset	125 break;
a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127 }
a61af66fc99e Initial load duke parents: diff changeset	128 e_d = dom_depth(early); // Reset depth register cache
a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 // Return earliest legal location
a61af66fc99e Initial load duke parents: diff changeset	133 assert(early == find_non_split_ctrl(early), "unexpected early control");
a61af66fc99e Initial load duke parents: diff changeset	134
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	135 if (n->is_expensive()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	136 assert(n->in(0), "should have control input");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	137 early = get_early_ctrl_for_expensive(n, early);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	138 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	139
0 a61af66fc99e Initial load duke parents: diff changeset	140 return early;
a61af66fc99e Initial load duke parents: diff changeset	141 }
a61af66fc99e Initial load duke parents: diff changeset	142
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	143 //------------------------------get_early_ctrl_for_expensive---------------------------------
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	144 // Move node up the dominator tree as high as legal while still beneficial
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	145 Node PhaseIdealLoop::get_early_ctrl_for_expensive(Node n, Node* earliest) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	146 assert(n->in(0) && n->is_expensive(), "expensive node with control input here");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	147 assert(OptimizeExpensiveOps, "optimization off?");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	148
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	149 Node* ctl = n->in(0);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	150 assert(ctl->is_CFG(), "expensive input 0 must be cfg");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	151 uint min_dom_depth = dom_depth(earliest);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	152 #ifdef ASSERT
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	153 if (!is_dominator(ctl, earliest) && !is_dominator(earliest, ctl)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	154 dump_bad_graph("Bad graph detected in get_early_ctrl_for_expensive", n, earliest, ctl);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	155 assert(false, "Bad graph detected in get_early_ctrl_for_expensive");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	156 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	157 #endif
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	158 if (dom_depth(ctl) < min_dom_depth) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	159 return earliest;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	160 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	161
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	162 while (1) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	163 Node *next = ctl;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	164 // Moving the node out of a loop on the projection of a If
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	165 // confuses loop predication. So once we hit a Loop in a If branch
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	166 // that doesn't branch to an UNC, we stop. The code that process
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	167 // expensive nodes will notice the loop and skip over it to try to
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	168 // move the node further up.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	169 if (ctl->is_CountedLoop() && ctl->in(1) != NULL && ctl->in(1)->in(0) != NULL && ctl->in(1)->in(0)->is_If()) {
12956 3213ba4d3dff 8024069: replace_in_map() should operate on parent maps roland parents: 10405 diff changeset	170 if (!ctl->in(1)->as_Proj()->is_uncommon_trap_if_pattern(Deoptimization::Reason_none)) {
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	171 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	172 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	173 next = idom(ctl->in(1)->in(0));
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	174 } else if (ctl->is_Proj()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	175 // We only move it up along a projection if the projection is
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	176 // the single control projection for its parent: same code path,
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	177 // if it's a If with UNC or fallthrough of a call.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	178 Node* parent_ctl = ctl->in(0);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	179 if (parent_ctl == NULL) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	180 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	181 } else if (parent_ctl->is_CountedLoopEnd() && parent_ctl->as_CountedLoopEnd()->loopnode() != NULL) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	182 next = parent_ctl->as_CountedLoopEnd()->loopnode()->init_control();
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	183 } else if (parent_ctl->is_If()) {
12956 3213ba4d3dff 8024069: replace_in_map() should operate on parent maps roland parents: 10405 diff changeset	184 if (!ctl->as_Proj()->is_uncommon_trap_if_pattern(Deoptimization::Reason_none)) {
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	185 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	186 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	187 assert(idom(ctl) == parent_ctl, "strange");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	188 next = idom(parent_ctl);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	189 } else if (ctl->is_CatchProj()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	190 if (ctl->as_Proj()->_con != CatchProjNode::fall_through_index) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	191 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	192 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	193 assert(parent_ctl->in(0)->in(0)->is_Call(), "strange graph");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	194 next = parent_ctl->in(0)->in(0)->in(0);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	195 } else {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	196 // Check if parent control has a single projection (this
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	197 // control is the only possible successor of the parent
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	198 // control). If so, we can try to move the node above the
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	199 // parent control.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	200 int nb_ctl_proj = 0;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	201 for (DUIterator_Fast imax, i = parent_ctl->fast_outs(imax); i < imax; i++) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	202 Node *p = parent_ctl->fast_out(i);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	203 if (p->is_Proj() && p->is_CFG()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	204 nb_ctl_proj++;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	205 if (nb_ctl_proj > 1) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	206 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	207 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	208 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	209 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	210
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	211 if (nb_ctl_proj > 1) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	212 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	213 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	214 assert(parent_ctl->is_Start() \|\| parent_ctl->is_MemBar() \|\| parent_ctl->is_Call(), "unexpected node");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	215 assert(idom(ctl) == parent_ctl, "strange");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	216 next = idom(parent_ctl);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	217 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	218 } else {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	219 next = idom(ctl);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	220 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	221 if (next->is_Root() \|\| next->is_Start() \|\| dom_depth(next) < min_dom_depth) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	222 break;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	223 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	224 ctl = next;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	225 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	226
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	227 if (ctl != n->in(0)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	228 _igvn.hash_delete(n);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	229 n->set_req(0, ctl);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	230 _igvn.hash_insert(n);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	231 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	232
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	233 return ctl;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	234 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	235
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	236
0 a61af66fc99e Initial load duke parents: diff changeset	237 //------------------------------set_early_ctrl---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	238 // Set earliest legal control
a61af66fc99e Initial load duke parents: diff changeset	239 void PhaseIdealLoop::set_early_ctrl( Node *n ) {
a61af66fc99e Initial load duke parents: diff changeset	240 Node *early = get_early_ctrl(n);
a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 // Record earliest legal location
a61af66fc99e Initial load duke parents: diff changeset	243 set_ctrl(n, early);
a61af66fc99e Initial load duke parents: diff changeset	244 }
a61af66fc99e Initial load duke parents: diff changeset	245
a61af66fc99e Initial load duke parents: diff changeset	246 //------------------------------set_subtree_ctrl-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	247 // set missing _ctrl entries on new nodes
a61af66fc99e Initial load duke parents: diff changeset	248 void PhaseIdealLoop::set_subtree_ctrl( Node *n ) {
a61af66fc99e Initial load duke parents: diff changeset	249 // Already set? Get out.
a61af66fc99e Initial load duke parents: diff changeset	250 if( _nodes[n->_idx] ) return;
a61af66fc99e Initial load duke parents: diff changeset	251 // Recursively set _nodes array to indicate where the Node goes
a61af66fc99e Initial load duke parents: diff changeset	252 uint i;
a61af66fc99e Initial load duke parents: diff changeset	253 for( i = 0; i < n->req(); ++i ) {
a61af66fc99e Initial load duke parents: diff changeset	254 Node *m = n->in(i);
a61af66fc99e Initial load duke parents: diff changeset	255 if( m && m != C->root() )
a61af66fc99e Initial load duke parents: diff changeset	256 set_subtree_ctrl( m );
a61af66fc99e Initial load duke parents: diff changeset	257 }
a61af66fc99e Initial load duke parents: diff changeset	258
a61af66fc99e Initial load duke parents: diff changeset	259 // Fixup self
a61af66fc99e Initial load duke parents: diff changeset	260 set_early_ctrl( n );
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262
a61af66fc99e Initial load duke parents: diff changeset	263 //------------------------------is_counted_loop--------------------------------
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	264 bool PhaseIdealLoop::is_counted_loop( Node x, IdealLoopTree loop ) {
0 a61af66fc99e Initial load duke parents: diff changeset	265 PhaseGVN *gvn = &_igvn;
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 // Counted loop head must be a good RegionNode with only 3 not NULL
a61af66fc99e Initial load duke parents: diff changeset	268 // control input edges: Self, Entry, LoopBack.
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	269 if (x->in(LoopNode::Self) == NULL \|\| x->req() != 3)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	270 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 Node *init_control = x->in(LoopNode::EntryControl);
a61af66fc99e Initial load duke parents: diff changeset	273 Node *back_control = x->in(LoopNode::LoopBackControl);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	274 if (init_control == NULL \|\| back_control == NULL) // Partially dead
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	275 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	276 // Must also check for TOP when looking for a dead loop
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	277 if (init_control->is_top() \|\| back_control->is_top())
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	278 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // Allow funny placement of Safepoint
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	281 if (back_control->Opcode() == Op_SafePoint)
0 a61af66fc99e Initial load duke parents: diff changeset	282 back_control = back_control->in(TypeFunc::Control);
a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 // Controlling test for loop
a61af66fc99e Initial load duke parents: diff changeset	285 Node *iftrue = back_control;
a61af66fc99e Initial load duke parents: diff changeset	286 uint iftrue_op = iftrue->Opcode();
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	287 if (iftrue_op != Op_IfTrue &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	288 iftrue_op != Op_IfFalse)
0 a61af66fc99e Initial load duke parents: diff changeset	289 // I have a weird back-control. Probably the loop-exit test is in
a61af66fc99e Initial load duke parents: diff changeset	290 // the middle of the loop and I am looking at some trailing control-flow
a61af66fc99e Initial load duke parents: diff changeset	291 // merge point. To fix this I would have to partially peel the loop.
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	292 return false; // Obscure back-control
0 a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 // Get boolean guarding loop-back test
a61af66fc99e Initial load duke parents: diff changeset	295 Node *iff = iftrue->in(0);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	296 if (get_loop(iff) != loop \|\| !iff->in(1)->is_Bool())
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	297 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	298 BoolNode *test = iff->in(1)->as_Bool();
a61af66fc99e Initial load duke parents: diff changeset	299 BoolTest::mask bt = test->_test._test;
a61af66fc99e Initial load duke parents: diff changeset	300 float cl_prob = iff->as_If()->_prob;
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	301 if (iftrue_op == Op_IfFalse) {
0 a61af66fc99e Initial load duke parents: diff changeset	302 bt = BoolTest(bt).negate();
a61af66fc99e Initial load duke parents: diff changeset	303 cl_prob = 1.0 - cl_prob;
a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305 // Get backedge compare
a61af66fc99e Initial load duke parents: diff changeset	306 Node *cmp = test->in(1);
a61af66fc99e Initial load duke parents: diff changeset	307 int cmp_op = cmp->Opcode();
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	308 if (cmp_op != Op_CmpI)
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	309 return false; // Avoid pointer & float compares
0 a61af66fc99e Initial load duke parents: diff changeset	310
a61af66fc99e Initial load duke parents: diff changeset	311 // Find the trip-counter increment & limit. Limit must be loop invariant.
a61af66fc99e Initial load duke parents: diff changeset	312 Node *incr = cmp->in(1);
a61af66fc99e Initial load duke parents: diff changeset	313 Node *limit = cmp->in(2);
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 // ---------
a61af66fc99e Initial load duke parents: diff changeset	316 // need 'loop()' test to tell if limit is loop invariant
a61af66fc99e Initial load duke parents: diff changeset	317 // ---------
a61af66fc99e Initial load duke parents: diff changeset	318
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	319 if (!is_member(loop, get_ctrl(incr))) { // Swapped trip counter and limit?
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	320 Node *tmp = incr; // Then reverse order into the CmpI
0 a61af66fc99e Initial load duke parents: diff changeset	321 incr = limit;
a61af66fc99e Initial load duke parents: diff changeset	322 limit = tmp;
a61af66fc99e Initial load duke parents: diff changeset	323 bt = BoolTest(bt).commute(); // And commute the exit test
a61af66fc99e Initial load duke parents: diff changeset	324 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	325 if (is_member(loop, get_ctrl(limit))) // Limit must be loop-invariant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	326 return false;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	327 if (!is_member(loop, get_ctrl(incr))) // Trip counter must be loop-variant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	328 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	329
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	330 Node* phi_incr = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	331 // Trip-counter increment must be commutative & associative.
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	332 if (incr->is_Phi()) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	333 if (incr->as_Phi()->region() != x \|\| incr->req() != 3)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	334 return false; // Not simple trip counter expression
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	335 phi_incr = incr;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	336 incr = phi_incr->in(LoopNode::LoopBackControl); // Assume incr is on backedge of Phi
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	337 if (!is_member(loop, get_ctrl(incr))) // Trip counter must be loop-variant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	338 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	339 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	340
0 a61af66fc99e Initial load duke parents: diff changeset	341 Node* trunc1 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	342 Node* trunc2 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	343 const TypeInt* iv_trunc_t = NULL;
a61af66fc99e Initial load duke parents: diff changeset	344 if (!(incr = CountedLoopNode::match_incr_with_optional_truncation(incr, &trunc1, &trunc2, &iv_trunc_t))) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	345 return false; // Funny increment opcode
0 a61af66fc99e Initial load duke parents: diff changeset	346 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	347 assert(incr->Opcode() == Op_AddI, "wrong increment code");
0 a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 // Get merge point
a61af66fc99e Initial load duke parents: diff changeset	350 Node *xphi = incr->in(1);
a61af66fc99e Initial load duke parents: diff changeset	351 Node *stride = incr->in(2);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	352 if (!stride->is_Con()) { // Oops, swap these
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	353 if (!xphi->is_Con()) // Is the other guy a constant?
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	354 return false; // Nope, unknown stride, bail out
0 a61af66fc99e Initial load duke parents: diff changeset	355 Node *tmp = xphi; // 'incr' is commutative, so ok to swap
a61af66fc99e Initial load duke parents: diff changeset	356 xphi = stride;
a61af66fc99e Initial load duke parents: diff changeset	357 stride = tmp;
a61af66fc99e Initial load duke parents: diff changeset	358 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	359 // Stride must be constant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	360 int stride_con = stride->get_int();
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	361 if (stride_con == 0)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	362 return false; // missed some peephole opt
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	363
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	364 if (!xphi->is_Phi())
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	365 return false; // Too much math on the trip counter
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	366 if (phi_incr != NULL && phi_incr != xphi)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	367 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	368 PhiNode *phi = xphi->as_Phi();
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 // Phi must be of loop header; backedge must wrap to increment
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	371 if (phi->region() != x)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	372 return false;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	373 if (trunc1 == NULL && phi->in(LoopNode::LoopBackControl) != incr \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	374 trunc1 != NULL && phi->in(LoopNode::LoopBackControl) != trunc1) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	375 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377 Node *init_trip = phi->in(LoopNode::EntryControl);
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 // If iv trunc type is smaller than int, check for possible wrap.
a61af66fc99e Initial load duke parents: diff changeset	380 if (!TypeInt::INT->higher_equal(iv_trunc_t)) {
a61af66fc99e Initial load duke parents: diff changeset	381 assert(trunc1 != NULL, "must have found some truncation");
a61af66fc99e Initial load duke parents: diff changeset	382
a61af66fc99e Initial load duke parents: diff changeset	383 // Get a better type for the phi (filtered thru if's)
a61af66fc99e Initial load duke parents: diff changeset	384 const TypeInt* phi_ft = filtered_type(phi);
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 // Can iv take on a value that will wrap?
a61af66fc99e Initial load duke parents: diff changeset	387 //
a61af66fc99e Initial load duke parents: diff changeset	388 // Ensure iv's limit is not within "stride" of the wrap value.
a61af66fc99e Initial load duke parents: diff changeset	389 //
a61af66fc99e Initial load duke parents: diff changeset	390 // Example for "short" type
a61af66fc99e Initial load duke parents: diff changeset	391 // Truncation ensures value is in the range -32768..32767 (iv_trunc_t)
a61af66fc99e Initial load duke parents: diff changeset	392 // If the stride is +10, then the last value of the induction
a61af66fc99e Initial load duke parents: diff changeset	393 // variable before the increment (phi_ft->_hi) must be
a61af66fc99e Initial load duke parents: diff changeset	394 // <= 32767 - 10 and (phi_ft->_lo) must be >= -32768 to
a61af66fc99e Initial load duke parents: diff changeset	395 // ensure no truncation occurs after the increment.
a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 if (stride_con > 0) {
a61af66fc99e Initial load duke parents: diff changeset	398 if (iv_trunc_t->_hi - phi_ft->_hi < stride_con \|\|
a61af66fc99e Initial load duke parents: diff changeset	399 iv_trunc_t->_lo > phi_ft->_lo) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	400 return false; // truncation may occur
0 a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 } else if (stride_con < 0) {
a61af66fc99e Initial load duke parents: diff changeset	403 if (iv_trunc_t->_lo - phi_ft->_lo > stride_con \|\|
a61af66fc99e Initial load duke parents: diff changeset	404 iv_trunc_t->_hi < phi_ft->_hi) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	405 return false; // truncation may occur
0 a61af66fc99e Initial load duke parents: diff changeset	406 }
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408 // No possibility of wrap so truncation can be discarded
a61af66fc99e Initial load duke parents: diff changeset	409 // Promote iv type to Int
a61af66fc99e Initial load duke parents: diff changeset	410 } else {
a61af66fc99e Initial load duke parents: diff changeset	411 assert(trunc1 == NULL && trunc2 == NULL, "no truncation for int");
a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	414 // If the condition is inverted and we will be rolling
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	415 // through MININT to MAXINT, then bail out.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	416 if (bt == BoolTest::eq \|\| // Bail out, but this loop trips at most twice!
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	417 // Odd stride
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	418 bt == BoolTest::ne && stride_con != 1 && stride_con != -1 \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	419 // Count down loop rolls through MAXINT
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	420 (bt == BoolTest::le \|\| bt == BoolTest::lt) && stride_con < 0 \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	421 // Count up loop rolls through MININT
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	422 (bt == BoolTest::ge \|\| bt == BoolTest::gt) && stride_con > 0) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	423 return false; // Bail out
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	424 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	425
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	426 const TypeInt* init_t = gvn->type(init_trip)->is_int();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	427 const TypeInt* limit_t = gvn->type(limit)->is_int();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	428
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	429 if (stride_con > 0) {
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	430 jlong init_p = (jlong)init_t->_lo + stride_con;
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	431 if (init_p > (jlong)max_jint \|\| init_p > (jlong)limit_t->_hi)
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	432 return false; // cyclic loop or this loop trips only once
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	433 } else {
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	434 jlong init_p = (jlong)init_t->_hi + stride_con;
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	435 if (init_p < (jlong)min_jint \|\| init_p < (jlong)limit_t->_lo)
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	436 return false; // cyclic loop or this loop trips only once
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	437 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	438
0 a61af66fc99e Initial load duke parents: diff changeset	439 // =================================================
a61af66fc99e Initial load duke parents: diff changeset	440 // ---- SUCCESS! Found A Trip-Counted Loop! -----
a61af66fc99e Initial load duke parents: diff changeset	441 //
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	442 assert(x->Opcode() == Op_Loop, "regular loops only");
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8868 diff changeset	443 C->print_method(PHASE_BEFORE_CLOOPS, 3);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	444
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	445 Node *hook = new (C) Node(6);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	446
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	447 if (LoopLimitCheck) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	448
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	449 // ===================================================
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	450 // Generate loop limit check to avoid integer overflow
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	451 // in cases like next (cyclic loops):
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	452 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	453 // for (i=0; i <= max_jint; i++) {}
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	454 // for (i=0; i < max_jint; i+=2) {}
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	455 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	456 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	457 // Limit check predicate depends on the loop test:
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	458 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	459 // for(;i != limit; i++) --> limit <= (max_jint)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	460 // for(;i < limit; i+=stride) --> limit <= (max_jint - stride + 1)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	461 // for(;i <= limit; i+=stride) --> limit <= (max_jint - stride )
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	462 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	463
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	464 // Check if limit is excluded to do more precise int overflow check.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	465 bool incl_limit = (bt == BoolTest::le \|\| bt == BoolTest::ge);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	466 int stride_m = stride_con - (incl_limit ? 0 : (stride_con > 0 ? 1 : -1));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	467
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	468 // If compare points directly to the phi we need to adjust
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	469 // the compare so that it points to the incr. Limit have
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	470 // to be adjusted to keep trip count the same and the
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	471 // adjusted limit should be checked for int overflow.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	472 if (phi_incr != NULL) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	473 stride_m += stride_con;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	474 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	475
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	476 if (limit->is_Con()) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	477 int limit_con = limit->get_int();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	478 if ((stride_con > 0 && limit_con > (max_jint - stride_m)) \|\|
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	479 (stride_con < 0 && limit_con < (min_jint - stride_m))) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	480 // Bailout: it could be integer overflow.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	481 return false;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	482 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	483 } else if ((stride_con > 0 && limit_t->_hi <= (max_jint - stride_m)) \|\|
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	484 (stride_con < 0 && limit_t->_lo >= (min_jint - stride_m))) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	485 // Limit's type may satisfy the condition, for example,
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	486 // when it is an array length.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	487 } else {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	488 // Generate loop's limit check.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	489 // Loop limit check predicate should be near the loop.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	490 ProjNode *limit_check_proj = find_predicate_insertion_point(init_control, Deoptimization::Reason_loop_limit_check);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	491 if (!limit_check_proj) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	492 // The limit check predicate is not generated if this method trapped here before.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	493 #ifdef ASSERT
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	494 if (TraceLoopLimitCheck) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	495 tty->print("missing loop limit check:");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	496 loop->dump_head();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	497 x->dump(1);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	498 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	499 #endif
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	500 return false;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	501 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	502
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	503 IfNode* check_iff = limit_check_proj->in(0)->as_If();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	504 Node* cmp_limit;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	505 Node* bol;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	506
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	507 if (stride_con > 0) {
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	508 cmp_limit = new (C) CmpINode(limit, _igvn.intcon(max_jint - stride_m));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	509 bol = new (C) BoolNode(cmp_limit, BoolTest::le);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	510 } else {
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	511 cmp_limit = new (C) CmpINode(limit, _igvn.intcon(min_jint - stride_m));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	512 bol = new (C) BoolNode(cmp_limit, BoolTest::ge);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	513 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	514 cmp_limit = _igvn.register_new_node_with_optimizer(cmp_limit);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	515 bol = _igvn.register_new_node_with_optimizer(bol);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	516 set_subtree_ctrl(bol);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	517
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	518 // Replace condition in original predicate but preserve Opaque node
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	519 // so that previous predicates could be found.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	520 assert(check_iff->in(1)->Opcode() == Op_Conv2B &&
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	521 check_iff->in(1)->in(1)->Opcode() == Op_Opaque1, "");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	522 Node* opq = check_iff->in(1)->in(1);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	523 _igvn.hash_delete(opq);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	524 opq->set_req(1, bol);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	525 // Update ctrl.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	526 set_ctrl(opq, check_iff->in(0));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	527 set_ctrl(check_iff->in(1), check_iff->in(0));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	528
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	529 #ifndef PRODUCT
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	530 // report that the loop predication has been actually performed
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	531 // for this loop
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	532 if (TraceLoopLimitCheck) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	533 tty->print_cr("Counted Loop Limit Check generated:");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	534 debug_only( bol->dump(2); )
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	535 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	536 #endif
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	537 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	538
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	539 if (phi_incr != NULL) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	540 // If compare points directly to the phi we need to adjust
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	541 // the compare so that it points to the incr. Limit have
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	542 // to be adjusted to keep trip count the same and we
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	543 // should avoid int overflow.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	544 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	545 // i = init; do {} while(i++ < limit);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	546 // is converted to
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	547 // i = init; do {} while(++i < limit+1);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	548 //
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	549 limit = gvn->transform(new (C) AddINode(limit, stride));
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	550 }
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	551
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	552 // Now we need to canonicalize loop condition.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	553 if (bt == BoolTest::ne) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	554 assert(stride_con == 1 \|\| stride_con == -1, "simple increment only");
3782 aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	555 // 'ne' can be replaced with 'lt' only when init < limit.
aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	556 if (stride_con > 0 && init_t->_hi < limit_t->_lo)
aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	557 bt = BoolTest::lt;
aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	558 // 'ne' can be replaced with 'gt' only when init > limit.
aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	559 if (stride_con < 0 && init_t->_lo > limit_t->_hi)
aacaff365100 7052494: Eclipse test fails on JDK 7 b142 kvn parents: 3345 diff changeset	560 bt = BoolTest::gt;
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	561 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	562
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	563 if (incl_limit) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	564 // The limit check guaranties that 'limit <= (max_jint - stride)' so
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	565 // we can convert 'i <= limit' to 'i < limit+1' since stride != 0.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	566 //
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	567 Node* one = (stride_con > 0) ? gvn->intcon( 1) : gvn->intcon(-1);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	568 limit = gvn->transform(new (C) AddINode(limit, one));
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	569 if (bt == BoolTest::le)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	570 bt = BoolTest::lt;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	571 else if (bt == BoolTest::ge)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	572 bt = BoolTest::gt;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	573 else
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	574 ShouldNotReachHere();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	575 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	576 set_subtree_ctrl( limit );
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	577
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	578 } else { // LoopLimitCheck
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	579
0 a61af66fc99e Initial load duke parents: diff changeset	580 // If compare points to incr, we are ok. Otherwise the compare
a61af66fc99e Initial load duke parents: diff changeset	581 // can directly point to the phi; in this case adjust the compare so that
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	582 // it points to the incr by adjusting the limit.
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	583 if (cmp->in(1) == phi \|\| cmp->in(2) == phi)
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	584 limit = gvn->transform(new (C) AddINode(limit,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	585
a61af66fc99e Initial load duke parents: diff changeset	586 // trip-count for +-tive stride should be: (limit - init_trip + stride - 1)/stride.
a61af66fc99e Initial load duke parents: diff changeset	587 // Final value for iterator should be: trip_count * stride + init_trip.
a61af66fc99e Initial load duke parents: diff changeset	588 Node *one_p = gvn->intcon( 1);
a61af66fc99e Initial load duke parents: diff changeset	589 Node *one_m = gvn->intcon(-1);
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 Node *trip_count = NULL;
a61af66fc99e Initial load duke parents: diff changeset	592 switch( bt ) {
a61af66fc99e Initial load duke parents: diff changeset	593 case BoolTest::eq:
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	594 ShouldNotReachHere();
0 a61af66fc99e Initial load duke parents: diff changeset	595 case BoolTest::ne: // Ahh, the case we desire
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	596 if (stride_con == 1)
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	597 trip_count = gvn->transform(new (C) SubINode(limit,init_trip));
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	598 else if (stride_con == -1)
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	599 trip_count = gvn->transform(new (C) SubINode(init_trip,limit));
0 a61af66fc99e Initial load duke parents: diff changeset	600 else
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	601 ShouldNotReachHere();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	602 set_subtree_ctrl(trip_count);
0 a61af66fc99e Initial load duke parents: diff changeset	603 //_loop.map(trip_count->_idx,loop(limit));
a61af66fc99e Initial load duke parents: diff changeset	604 break;
a61af66fc99e Initial load duke parents: diff changeset	605 case BoolTest::le: // Maybe convert to '<' case
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	606 limit = gvn->transform(new (C) AddINode(limit,one_p));
0 a61af66fc99e Initial load duke parents: diff changeset	607 set_subtree_ctrl( limit );
a61af66fc99e Initial load duke parents: diff changeset	608 hook->init_req(4, limit);
a61af66fc99e Initial load duke parents: diff changeset	609
a61af66fc99e Initial load duke parents: diff changeset	610 bt = BoolTest::lt;
a61af66fc99e Initial load duke parents: diff changeset	611 // Make the new limit be in the same loop nest as the old limit
a61af66fc99e Initial load duke parents: diff changeset	612 //_loop.map(limit->_idx,limit_loop);
a61af66fc99e Initial load duke parents: diff changeset	613 // Fall into next case
a61af66fc99e Initial load duke parents: diff changeset	614 case BoolTest::lt: { // Maybe convert to '!=' case
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	615 if (stride_con < 0) // Count down loop rolls through MAXINT
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	616 ShouldNotReachHere();
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	617 Node *range = gvn->transform(new (C) SubINode(limit,init_trip));
0 a61af66fc99e Initial load duke parents: diff changeset	618 set_subtree_ctrl( range );
a61af66fc99e Initial load duke parents: diff changeset	619 hook->init_req(0, range);
a61af66fc99e Initial load duke parents: diff changeset	620
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	621 Node *bias = gvn->transform(new (C) AddINode(range,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	622 set_subtree_ctrl( bias );
a61af66fc99e Initial load duke parents: diff changeset	623 hook->init_req(1, bias);
a61af66fc99e Initial load duke parents: diff changeset	624
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	625 Node *bias1 = gvn->transform(new (C) AddINode(bias,one_m));
0 a61af66fc99e Initial load duke parents: diff changeset	626 set_subtree_ctrl( bias1 );
a61af66fc99e Initial load duke parents: diff changeset	627 hook->init_req(2, bias1);
a61af66fc99e Initial load duke parents: diff changeset	628
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	629 trip_count = gvn->transform(new (C) DivINode(0,bias1,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	630 set_subtree_ctrl( trip_count );
a61af66fc99e Initial load duke parents: diff changeset	631 hook->init_req(3, trip_count);
a61af66fc99e Initial load duke parents: diff changeset	632 break;
a61af66fc99e Initial load duke parents: diff changeset	633 }
a61af66fc99e Initial load duke parents: diff changeset	634
a61af66fc99e Initial load duke parents: diff changeset	635 case BoolTest::ge: // Maybe convert to '>' case
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	636 limit = gvn->transform(new (C) AddINode(limit,one_m));
0 a61af66fc99e Initial load duke parents: diff changeset	637 set_subtree_ctrl( limit );
a61af66fc99e Initial load duke parents: diff changeset	638 hook->init_req(4 ,limit);
a61af66fc99e Initial load duke parents: diff changeset	639
a61af66fc99e Initial load duke parents: diff changeset	640 bt = BoolTest::gt;
a61af66fc99e Initial load duke parents: diff changeset	641 // Make the new limit be in the same loop nest as the old limit
a61af66fc99e Initial load duke parents: diff changeset	642 //_loop.map(limit->_idx,limit_loop);
a61af66fc99e Initial load duke parents: diff changeset	643 // Fall into next case
a61af66fc99e Initial load duke parents: diff changeset	644 case BoolTest::gt: { // Maybe convert to '!=' case
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	645 if (stride_con > 0) // count up loop rolls through MININT
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	646 ShouldNotReachHere();
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	647 Node *range = gvn->transform(new (C) SubINode(limit,init_trip));
0 a61af66fc99e Initial load duke parents: diff changeset	648 set_subtree_ctrl( range );
a61af66fc99e Initial load duke parents: diff changeset	649 hook->init_req(0, range);
a61af66fc99e Initial load duke parents: diff changeset	650
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	651 Node *bias = gvn->transform(new (C) AddINode(range,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	652 set_subtree_ctrl( bias );
a61af66fc99e Initial load duke parents: diff changeset	653 hook->init_req(1, bias);
a61af66fc99e Initial load duke parents: diff changeset	654
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	655 Node *bias1 = gvn->transform(new (C) AddINode(bias,one_p));
0 a61af66fc99e Initial load duke parents: diff changeset	656 set_subtree_ctrl( bias1 );
a61af66fc99e Initial load duke parents: diff changeset	657 hook->init_req(2, bias1);
a61af66fc99e Initial load duke parents: diff changeset	658
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	659 trip_count = gvn->transform(new (C) DivINode(0,bias1,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	660 set_subtree_ctrl( trip_count );
a61af66fc99e Initial load duke parents: diff changeset	661 hook->init_req(3, trip_count);
a61af66fc99e Initial load duke parents: diff changeset	662 break;
a61af66fc99e Initial load duke parents: diff changeset	663 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	664 } // switch( bt )
0 a61af66fc99e Initial load duke parents: diff changeset	665
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	666 Node *span = gvn->transform(new (C) MulINode(trip_count,stride));
0 a61af66fc99e Initial load duke parents: diff changeset	667 set_subtree_ctrl( span );
a61af66fc99e Initial load duke parents: diff changeset	668 hook->init_req(5, span);
a61af66fc99e Initial load duke parents: diff changeset	669
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	670 limit = gvn->transform(new (C) AddINode(span,init_trip));
0 a61af66fc99e Initial load duke parents: diff changeset	671 set_subtree_ctrl( limit );
a61af66fc99e Initial load duke parents: diff changeset	672
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	673 } // LoopLimitCheck
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	674
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	675 // Check for SafePoint on backedge and remove
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	676 Node *sfpt = x->in(LoopNode::LoopBackControl);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	677 if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	678 lazy_replace( sfpt, iftrue );
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	679 if (loop->_safepts != NULL) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	680 loop->_safepts->yank(sfpt);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	681 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	682 loop->_tail = iftrue;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	683 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	684
0 a61af66fc99e Initial load duke parents: diff changeset	685 // Build a canonical trip test.
a61af66fc99e Initial load duke parents: diff changeset	686 // Clone code, as old values may be in use.
a61af66fc99e Initial load duke parents: diff changeset	687 incr = incr->clone();
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	688 incr->set_req(1,phi);
0 a61af66fc99e Initial load duke parents: diff changeset	689 incr->set_req(2,stride);
a61af66fc99e Initial load duke parents: diff changeset	690 incr = _igvn.register_new_node_with_optimizer(incr);
a61af66fc99e Initial load duke parents: diff changeset	691 set_early_ctrl( incr );
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	692 _igvn.hash_delete(phi);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	693 phi->set_req_X( LoopNode::LoopBackControl, incr, &_igvn );
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	694
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	695 // If phi type is more restrictive than Int, raise to
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	696 // Int to prevent (almost) infinite recursion in igvn
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	697 // which can only handle integer types for constants or minint..maxint.
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	698 if (!TypeInt::INT->higher_equal(phi->bottom_type())) {
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	699 Node* nphi = PhiNode::make(phi->in(0), phi->in(LoopNode::EntryControl), TypeInt::INT);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	700 nphi->set_req(LoopNode::LoopBackControl, phi->in(LoopNode::LoopBackControl));
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	701 nphi = _igvn.register_new_node_with_optimizer(nphi);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	702 set_ctrl(nphi, get_ctrl(phi));
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	703 _igvn.replace_node(phi, nphi);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	704 phi = nphi->as_Phi();
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	705 }
0 a61af66fc99e Initial load duke parents: diff changeset	706 cmp = cmp->clone();
a61af66fc99e Initial load duke parents: diff changeset	707 cmp->set_req(1,incr);
a61af66fc99e Initial load duke parents: diff changeset	708 cmp->set_req(2,limit);
a61af66fc99e Initial load duke parents: diff changeset	709 cmp = _igvn.register_new_node_with_optimizer(cmp);
a61af66fc99e Initial load duke parents: diff changeset	710 set_ctrl(cmp, iff->in(0));
a61af66fc99e Initial load duke parents: diff changeset	711
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	712 test = test->clone()->as_Bool();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	713 ((BoolTest)&test->_test)._test = bt;
0 a61af66fc99e Initial load duke parents: diff changeset	714 test->set_req(1,cmp);
a61af66fc99e Initial load duke parents: diff changeset	715 _igvn.register_new_node_with_optimizer(test);
a61af66fc99e Initial load duke parents: diff changeset	716 set_ctrl(test, iff->in(0));
a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // Replace the old IfNode with a new LoopEndNode
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	719 Node *lex = _igvn.register_new_node_with_optimizer(new (C) CountedLoopEndNode( iff->in(0), test, cl_prob, iff->as_If()->_fcnt ));
0 a61af66fc99e Initial load duke parents: diff changeset	720 IfNode *le = lex->as_If();
a61af66fc99e Initial load duke parents: diff changeset	721 uint dd = dom_depth(iff);
a61af66fc99e Initial load duke parents: diff changeset	722 set_idom(le, le->in(0), dd); // Update dominance for loop exit
a61af66fc99e Initial load duke parents: diff changeset	723 set_loop(le, loop);
a61af66fc99e Initial load duke parents: diff changeset	724
a61af66fc99e Initial load duke parents: diff changeset	725 // Get the loop-exit control
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	726 Node *iffalse = iff->as_If()->proj_out(!(iftrue_op == Op_IfTrue));
0 a61af66fc99e Initial load duke parents: diff changeset	727
a61af66fc99e Initial load duke parents: diff changeset	728 // Need to swap loop-exit and loop-back control?
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	729 if (iftrue_op == Op_IfFalse) {
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	730 Node *ift2=_igvn.register_new_node_with_optimizer(new (C) IfTrueNode (le));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	731 Node *iff2=_igvn.register_new_node_with_optimizer(new (C) IfFalseNode(le));
0 a61af66fc99e Initial load duke parents: diff changeset	732
a61af66fc99e Initial load duke parents: diff changeset	733 loop->_tail = back_control = ift2;
a61af66fc99e Initial load duke parents: diff changeset	734 set_loop(ift2, loop);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	735 set_loop(iff2, get_loop(iffalse));
0 a61af66fc99e Initial load duke parents: diff changeset	736
a61af66fc99e Initial load duke parents: diff changeset	737 // Lazy update of 'get_ctrl' mechanism.
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	738 lazy_replace_proj( iffalse, iff2 );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	739 lazy_replace_proj( iftrue, ift2 );
0 a61af66fc99e Initial load duke parents: diff changeset	740
a61af66fc99e Initial load duke parents: diff changeset	741 // Swap names
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	742 iffalse = iff2;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	743 iftrue = ift2;
0 a61af66fc99e Initial load duke parents: diff changeset	744 } else {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	745 _igvn.hash_delete(iffalse);
0 a61af66fc99e Initial load duke parents: diff changeset	746 _igvn.hash_delete(iftrue);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	747 iffalse->set_req_X( 0, le, &_igvn );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	748 iftrue ->set_req_X( 0, le, &_igvn );
0 a61af66fc99e Initial load duke parents: diff changeset	749 }
a61af66fc99e Initial load duke parents: diff changeset	750
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	751 set_idom(iftrue, le, dd+1);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	752 set_idom(iffalse, le, dd+1);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	753 assert(iff->outcnt() == 0, "should be dead now");
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	754 lazy_replace( iff, le ); // fix 'get_ctrl'
0 a61af66fc99e Initial load duke parents: diff changeset	755
a61af66fc99e Initial load duke parents: diff changeset	756 // Now setup a new CountedLoopNode to replace the existing LoopNode
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	757 CountedLoopNode *l = new (C) CountedLoopNode(init_control, back_control);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	758 l->set_unswitch_count(x->as_Loop()->unswitch_count()); // Preserve
0 a61af66fc99e Initial load duke parents: diff changeset	759 // The following assert is approximately true, and defines the intention
a61af66fc99e Initial load duke parents: diff changeset	760 // of can_be_counted_loop. It fails, however, because phase->type
a61af66fc99e Initial load duke parents: diff changeset	761 // is not yet initialized for this loop and its parts.
a61af66fc99e Initial load duke parents: diff changeset	762 //assert(l->can_be_counted_loop(this), "sanity");
a61af66fc99e Initial load duke parents: diff changeset	763 _igvn.register_new_node_with_optimizer(l);
a61af66fc99e Initial load duke parents: diff changeset	764 set_loop(l, loop);
a61af66fc99e Initial load duke parents: diff changeset	765 loop->_head = l;
a61af66fc99e Initial load duke parents: diff changeset	766 // Fix all data nodes placed at the old loop head.
a61af66fc99e Initial load duke parents: diff changeset	767 // Uses the lazy-update mechanism of 'get_ctrl'.
a61af66fc99e Initial load duke parents: diff changeset	768 lazy_replace( x, l );
a61af66fc99e Initial load duke parents: diff changeset	769 set_idom(l, init_control, dom_depth(x));
a61af66fc99e Initial load duke parents: diff changeset	770
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	771 // Check for immediately preceding SafePoint and remove
0 a61af66fc99e Initial load duke parents: diff changeset	772 Node *sfpt2 = le->in(0);
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	773 if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
0 a61af66fc99e Initial load duke parents: diff changeset	774 lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	775 if (loop->_safepts != NULL) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	776 loop->_safepts->yank(sfpt2);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	777 }
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	778 }
0 a61af66fc99e Initial load duke parents: diff changeset	779
a61af66fc99e Initial load duke parents: diff changeset	780 // Free up intermediate goo
a61af66fc99e Initial load duke parents: diff changeset	781 _igvn.remove_dead_node(hook);
a61af66fc99e Initial load duke parents: diff changeset	782
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	783 #ifdef ASSERT
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	784 assert(l->is_valid_counted_loop(), "counted loop shape is messed up");
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	785 assert(l == loop->_head && l->phi() == phi && l->loopexit() == lex, "" );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	786 #endif
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	787 #ifndef PRODUCT
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	788 if (TraceLoopOpts) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	789 tty->print("Counted ");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	790 loop->dump_head();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	791 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	792 #endif
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	793
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8868 diff changeset	794 C->print_method(PHASE_AFTER_CLOOPS, 3);
0 a61af66fc99e Initial load duke parents: diff changeset	795
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	796 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	797 }
a61af66fc99e Initial load duke parents: diff changeset	798
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	799 //----------------------exact_limit-------------------------------------------
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	800 Node* PhaseIdealLoop::exact_limit( IdealLoopTree *loop ) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	801 assert(loop->_head->is_CountedLoop(), "");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	802 CountedLoopNode *cl = loop->_head->as_CountedLoop();
3850 6987871cfb9b 7077439: Possible reference through NULL in loopPredicate.cpp:726 kvn parents: 3845 diff changeset	803 assert(cl->is_valid_counted_loop(), "");
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	804
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	805 if (!LoopLimitCheck \|\| ABS(cl->stride_con()) == 1 \|\|
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	806 cl->limit()->Opcode() == Op_LoopLimit) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	807 // Old code has exact limit (it could be incorrect in case of int overflow).
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	808 // Loop limit is exact with stride == 1. And loop may already have exact limit.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	809 return cl->limit();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	810 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	811 Node *limit = NULL;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	812 #ifdef ASSERT
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	813 BoolTest::mask bt = cl->loopexit()->test_trip();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	814 assert(bt == BoolTest::lt \|\| bt == BoolTest::gt, "canonical test is expected");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	815 #endif
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	816 if (cl->has_exact_trip_count()) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	817 // Simple case: loop has constant boundaries.
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	818 // Use jlongs to avoid integer overflow.
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	819 int stride_con = cl->stride_con();
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	820 jlong init_con = cl->init_trip()->get_int();
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	821 jlong limit_con = cl->limit()->get_int();
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	822 julong trip_cnt = cl->trip_count();
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	823 jlong final_con = init_con + trip_cnt*stride_con;
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	824 int final_int = (int)final_con;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	825 // The final value should be in integer range since the loop
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	826 // is counted and the limit was checked for overflow.
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	827 assert(final_con == (jlong)final_int, "final value should be integer");
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	828 limit = _igvn.intcon(final_int);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	829 } else {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	830 // Create new LoopLimit node to get exact limit (final iv value).
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	831 limit = new (C) LoopLimitNode(C, cl->init_trip(), cl->limit(), cl->stride());
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	832 register_new_node(limit, cl->in(LoopNode::EntryControl));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	833 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	834 assert(limit != NULL, "sanity");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	835 return limit;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	836 }
0 a61af66fc99e Initial load duke parents: diff changeset	837
a61af66fc99e Initial load duke parents: diff changeset	838 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	839 // Return a node which is more "ideal" than the current node.
a61af66fc99e Initial load duke parents: diff changeset	840 // Attempt to convert into a counted-loop.
a61af66fc99e Initial load duke parents: diff changeset	841 Node LoopNode::Ideal(PhaseGVN phase, bool can_reshape) {
a61af66fc99e Initial load duke parents: diff changeset	842 if (!can_be_counted_loop(phase)) {
a61af66fc99e Initial load duke parents: diff changeset	843 phase->C->set_major_progress();
a61af66fc99e Initial load duke parents: diff changeset	844 }
a61af66fc99e Initial load duke parents: diff changeset	845 return RegionNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load duke parents: diff changeset	846 }
a61af66fc99e Initial load duke parents: diff changeset	847
a61af66fc99e Initial load duke parents: diff changeset	848
a61af66fc99e Initial load duke parents: diff changeset	849 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	850 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	851 // Return a node which is more "ideal" than the current node.
a61af66fc99e Initial load duke parents: diff changeset	852 // Attempt to convert into a counted-loop.
a61af66fc99e Initial load duke parents: diff changeset	853 Node CountedLoopNode::Ideal(PhaseGVN phase, bool can_reshape) {
a61af66fc99e Initial load duke parents: diff changeset	854 return RegionNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load duke parents: diff changeset	855 }
a61af66fc99e Initial load duke parents: diff changeset	856
a61af66fc99e Initial load duke parents: diff changeset	857 //------------------------------dump_spec--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	858 // Dump special per-node info
a61af66fc99e Initial load duke parents: diff changeset	859 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	860 void CountedLoopNode::dump_spec(outputStream *st) const {
a61af66fc99e Initial load duke parents: diff changeset	861 LoopNode::dump_spec(st);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	862 if (stride_is_con()) {
0 a61af66fc99e Initial load duke parents: diff changeset	863 st->print("stride: %d ",stride_con());
a61af66fc99e Initial load duke parents: diff changeset	864 }
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	865 if (is_pre_loop ()) st->print("pre of N%d" , _main_idx);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	866 if (is_main_loop()) st->print("main of N%d", _idx);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	867 if (is_post_loop()) st->print("post of N%d", _main_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	868 }
a61af66fc99e Initial load duke parents: diff changeset	869 #endif
a61af66fc99e Initial load duke parents: diff changeset	870
a61af66fc99e Initial load duke parents: diff changeset	871 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	872 int CountedLoopEndNode::stride_con() const {
a61af66fc99e Initial load duke parents: diff changeset	873 return stride()->bottom_type()->is_int()->get_con();
a61af66fc99e Initial load duke parents: diff changeset	874 }
a61af66fc99e Initial load duke parents: diff changeset	875
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	876 //=============================================================================
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	877 //------------------------------Value-----------------------------------------
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	878 const Type LoopLimitNode::Value( PhaseTransform phase ) const {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	879 const Type* init_t = phase->type(in(Init));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	880 const Type* limit_t = phase->type(in(Limit));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	881 const Type* stride_t = phase->type(in(Stride));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	882 // Either input is TOP ==> the result is TOP
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	883 if (init_t == Type::TOP) return Type::TOP;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	884 if (limit_t == Type::TOP) return Type::TOP;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	885 if (stride_t == Type::TOP) return Type::TOP;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	886
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	887 int stride_con = stride_t->is_int()->get_con();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	888 if (stride_con == 1)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	889 return NULL; // Identity
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	890
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	891 if (init_t->is_int()->is_con() && limit_t->is_int()->is_con()) {
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	892 // Use jlongs to avoid integer overflow.
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	893 jlong init_con = init_t->is_int()->get_con();
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	894 jlong limit_con = limit_t->is_int()->get_con();
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	895 int stride_m = stride_con - (stride_con > 0 ? 1 : -1);
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	896 jlong trip_count = (limit_con - init_con + stride_m)/stride_con;
377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	897 jlong final_con = init_con + stride_con*trip_count;
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	898 int final_int = (int)final_con;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	899 // The final value should be in integer range since the loop
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	900 // is counted and the limit was checked for overflow.
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	901 assert(final_con == (jlong)final_int, "final value should be integer");
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	902 return TypeInt::make(final_int);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	903 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	904
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	905 return bottom_type(); // TypeInt::INT
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	906 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	907
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	908 //------------------------------Ideal------------------------------------------
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	909 // Return a node which is more "ideal" than the current node.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	910 Node LoopLimitNode::Ideal(PhaseGVN phase, bool can_reshape) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	911 if (phase->type(in(Init)) == Type::TOP \|\|
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	912 phase->type(in(Limit)) == Type::TOP \|\|
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	913 phase->type(in(Stride)) == Type::TOP)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	914 return NULL; // Dead
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	915
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	916 int stride_con = phase->type(in(Stride))->is_int()->get_con();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	917 if (stride_con == 1)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	918 return NULL; // Identity
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	919
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	920 if (in(Init)->is_Con() && in(Limit)->is_Con())
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	921 return NULL; // Value
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	922
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	923 // Delay following optimizations until all loop optimizations
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	924 // done to keep Ideal graph simple.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	925 if (!can_reshape \|\| phase->C->major_progress())
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	926 return NULL;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	927
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	928 const TypeInt* init_t = phase->type(in(Init) )->is_int();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	929 const TypeInt* limit_t = phase->type(in(Limit))->is_int();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	930 int stride_p;
6846 377508648226 8000313: C2 should use jlong for 64bit values vlivanov parents: 6804 diff changeset	931 jlong lim, ini;
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	932 julong max;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	933 if (stride_con > 0) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	934 stride_p = stride_con;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	935 lim = limit_t->_hi;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	936 ini = init_t->_lo;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	937 max = (julong)max_jint;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	938 } else {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	939 stride_p = -stride_con;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	940 lim = init_t->_hi;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	941 ini = limit_t->_lo;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	942 max = (julong)min_jint;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	943 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	944 julong range = lim - ini + stride_p;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	945 if (range <= max) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	946 // Convert to integer expression if it is not overflow.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	947 Node* stride_m = phase->intcon(stride_con - (stride_con > 0 ? 1 : -1));
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	948 Node *range = phase->transform(new (phase->C) SubINode(in(Limit), in(Init)));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	949 Node *bias = phase->transform(new (phase->C) AddINode(range, stride_m));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	950 Node *trip = phase->transform(new (phase->C) DivINode(0, bias, in(Stride)));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	951 Node *span = phase->transform(new (phase->C) MulINode(trip, in(Stride)));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	952 return new (phase->C) AddINode(span, in(Init)); // exact limit
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	953 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	954
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	955 if (is_power_of_2(stride_p) \|\| // divisor is 2^n
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	956 !Matcher::has_match_rule(Op_LoopLimit)) { // or no specialized Mach node?
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	957 // Convert to long expression to avoid integer overflow
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	958 // and let igvn optimizer convert this division.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	959 //
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	960 Node* init = phase->transform( new (phase->C) ConvI2LNode(in(Init)));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	961 Node* limit = phase->transform( new (phase->C) ConvI2LNode(in(Limit)));
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	962 Node* stride = phase->longcon(stride_con);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	963 Node* stride_m = phase->longcon(stride_con - (stride_con > 0 ? 1 : -1));
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	964
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	965 Node *range = phase->transform(new (phase->C) SubLNode(limit, init));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	966 Node *bias = phase->transform(new (phase->C) AddLNode(range, stride_m));
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	967 Node *span;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	968 if (stride_con > 0 && is_power_of_2(stride_p)) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	969 // bias >= 0 if stride >0, so if stride is 2^n we can use &(-stride)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	970 // and avoid generating rounding for division. Zero trip guard should
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	971 // guarantee that init < limit but sometimes the guard is missing and
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	972 // we can get situation when init > limit. Note, for the empty loop
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	973 // optimization zero trip guard is generated explicitly which leaves
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	974 // only RCE predicate where exact limit is used and the predicate
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	975 // will simply fail forcing recompilation.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	976 Node* neg_stride = phase->longcon(-stride_con);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	977 span = phase->transform(new (phase->C) AndLNode(bias, neg_stride));
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	978 } else {
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	979 Node *trip = phase->transform(new (phase->C) DivLNode(0, bias, stride));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	980 span = phase->transform(new (phase->C) MulLNode(trip, stride));
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	981 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	982 // Convert back to int
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	983 Node *span_int = phase->transform(new (phase->C) ConvL2INode(span));
e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	984 return new (phase->C) AddINode(span_int, in(Init)); // exact limit
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	985 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	986
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	987 return NULL; // No progress
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	988 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	989
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	990 //------------------------------Identity---------------------------------------
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	991 // If stride == 1 return limit node.
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	992 Node LoopLimitNode::Identity( PhaseTransform phase ) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	993 int stride_con = phase->type(in(Stride))->is_int()->get_con();
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	994 if (stride_con == 1 \|\| stride_con == -1)
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	995 return in(Limit);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	996 return this;
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	997 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	998
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	999 //=============================================================================
0 a61af66fc99e Initial load duke parents: diff changeset	1000 //----------------------match_incr_with_optional_truncation--------------------
a61af66fc99e Initial load duke parents: diff changeset	1001 // Match increment with optional truncation:
a61af66fc99e Initial load duke parents: diff changeset	1002 // CHAR: (i+1)&0x7fff, BYTE: ((i+1)<<8)>>8, or SHORT: ((i+1)<<16)>>16
a61af66fc99e Initial load duke parents: diff changeset	1003 // Return NULL for failure. Success returns the increment node.
a61af66fc99e Initial load duke parents: diff changeset	1004 Node* CountedLoopNode::match_incr_with_optional_truncation(
a61af66fc99e Initial load duke parents: diff changeset	1005 Node* expr, Node trunc1, Node trunc2, const TypeInt** trunc_type) {
a61af66fc99e Initial load duke parents: diff changeset	1006 // Quick cutouts:
4862 f457154eee8b 7140882: Don't return booleans from methods returning pointers brutisso parents: 4779 diff changeset	1007 if (expr == NULL \|\| expr->req() != 3) return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1008
a61af66fc99e Initial load duke parents: diff changeset	1009 Node *t1 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1010 Node *t2 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1011 const TypeInt* trunc_t = TypeInt::INT;
a61af66fc99e Initial load duke parents: diff changeset	1012 Node* n1 = expr;
a61af66fc99e Initial load duke parents: diff changeset	1013 int n1op = n1->Opcode();
a61af66fc99e Initial load duke parents: diff changeset	1014
a61af66fc99e Initial load duke parents: diff changeset	1015 // Try to strip (n1 & M) or (n1 << N >> N) from n1.
a61af66fc99e Initial load duke parents: diff changeset	1016 if (n1op == Op_AndI &&
a61af66fc99e Initial load duke parents: diff changeset	1017 n1->in(2)->is_Con() &&
a61af66fc99e Initial load duke parents: diff changeset	1018 n1->in(2)->bottom_type()->is_int()->get_con() == 0x7fff) {
a61af66fc99e Initial load duke parents: diff changeset	1019 // %%% This check should match any mask of 2**K-1.
a61af66fc99e Initial load duke parents: diff changeset	1020 t1 = n1;
a61af66fc99e Initial load duke parents: diff changeset	1021 n1 = t1->in(1);
a61af66fc99e Initial load duke parents: diff changeset	1022 n1op = n1->Opcode();
a61af66fc99e Initial load duke parents: diff changeset	1023 trunc_t = TypeInt::CHAR;
a61af66fc99e Initial load duke parents: diff changeset	1024 } else if (n1op == Op_RShiftI &&
a61af66fc99e Initial load duke parents: diff changeset	1025 n1->in(1) != NULL &&
a61af66fc99e Initial load duke parents: diff changeset	1026 n1->in(1)->Opcode() == Op_LShiftI &&
a61af66fc99e Initial load duke parents: diff changeset	1027 n1->in(2) == n1->in(1)->in(2) &&
a61af66fc99e Initial load duke parents: diff changeset	1028 n1->in(2)->is_Con()) {
a61af66fc99e Initial load duke parents: diff changeset	1029 jint shift = n1->in(2)->bottom_type()->is_int()->get_con();
a61af66fc99e Initial load duke parents: diff changeset	1030 // %%% This check should match any shift in [1..31].
a61af66fc99e Initial load duke parents: diff changeset	1031 if (shift == 16 \|\| shift == 8) {
a61af66fc99e Initial load duke parents: diff changeset	1032 t1 = n1;
a61af66fc99e Initial load duke parents: diff changeset	1033 t2 = t1->in(1);
a61af66fc99e Initial load duke parents: diff changeset	1034 n1 = t2->in(1);
a61af66fc99e Initial load duke parents: diff changeset	1035 n1op = n1->Opcode();
a61af66fc99e Initial load duke parents: diff changeset	1036 if (shift == 16) {
a61af66fc99e Initial load duke parents: diff changeset	1037 trunc_t = TypeInt::SHORT;
a61af66fc99e Initial load duke parents: diff changeset	1038 } else if (shift == 8) {
a61af66fc99e Initial load duke parents: diff changeset	1039 trunc_t = TypeInt::BYTE;
a61af66fc99e Initial load duke parents: diff changeset	1040 }
a61af66fc99e Initial load duke parents: diff changeset	1041 }
a61af66fc99e Initial load duke parents: diff changeset	1042 }
a61af66fc99e Initial load duke parents: diff changeset	1043
a61af66fc99e Initial load duke parents: diff changeset	1044 // If (maybe after stripping) it is an AddI, we won:
a61af66fc99e Initial load duke parents: diff changeset	1045 if (n1op == Op_AddI) {
a61af66fc99e Initial load duke parents: diff changeset	1046 *trunc1 = t1;
a61af66fc99e Initial load duke parents: diff changeset	1047 *trunc2 = t2;
a61af66fc99e Initial load duke parents: diff changeset	1048 *trunc_type = trunc_t;
a61af66fc99e Initial load duke parents: diff changeset	1049 return n1;
a61af66fc99e Initial load duke parents: diff changeset	1050 }
a61af66fc99e Initial load duke parents: diff changeset	1051
a61af66fc99e Initial load duke parents: diff changeset	1052 // failed
a61af66fc99e Initial load duke parents: diff changeset	1053 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1054 }
a61af66fc99e Initial load duke parents: diff changeset	1055
a61af66fc99e Initial load duke parents: diff changeset	1056
a61af66fc99e Initial load duke parents: diff changeset	1057 //------------------------------filtered_type--------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1058 // Return a type based on condition control flow
a61af66fc99e Initial load duke parents: diff changeset	1059 // A successful return will be a type that is restricted due
a61af66fc99e Initial load duke parents: diff changeset	1060 // to a series of dominating if-tests, such as:
a61af66fc99e Initial load duke parents: diff changeset	1061 // if (i < 10) {
a61af66fc99e Initial load duke parents: diff changeset	1062 // if (i > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1063 // here: "i" type is [1..10)
a61af66fc99e Initial load duke parents: diff changeset	1064 // }
a61af66fc99e Initial load duke parents: diff changeset	1065 // }
a61af66fc99e Initial load duke parents: diff changeset	1066 // or a control flow merge
a61af66fc99e Initial load duke parents: diff changeset	1067 // if (i < 10) {
a61af66fc99e Initial load duke parents: diff changeset	1068 // do {
a61af66fc99e Initial load duke parents: diff changeset	1069 // phi( , ) -- at top of loop type is [min_int..10)
a61af66fc99e Initial load duke parents: diff changeset	1070 // i = ?
a61af66fc99e Initial load duke parents: diff changeset	1071 // } while ( i < 10)
a61af66fc99e Initial load duke parents: diff changeset	1072 //
a61af66fc99e Initial load duke parents: diff changeset	1073 const TypeInt* PhaseIdealLoop::filtered_type( Node n, Node n_ctrl) {
a61af66fc99e Initial load duke parents: diff changeset	1074 assert(n && n->bottom_type()->is_int(), "must be int");
a61af66fc99e Initial load duke parents: diff changeset	1075 const TypeInt* filtered_t = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1076 if (!n->is_Phi()) {
a61af66fc99e Initial load duke parents: diff changeset	1077 assert(n_ctrl != NULL \|\| n_ctrl == C->top(), "valid control");
a61af66fc99e Initial load duke parents: diff changeset	1078 filtered_t = filtered_type_from_dominators(n, n_ctrl);
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080 } else {
a61af66fc99e Initial load duke parents: diff changeset	1081 Node* phi = n->as_Phi();
a61af66fc99e Initial load duke parents: diff changeset	1082 Node* region = phi->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1083 assert(n_ctrl == NULL \|\| n_ctrl == region, "ctrl parameter must be region");
a61af66fc99e Initial load duke parents: diff changeset	1084 if (region && region != C->top()) {
a61af66fc99e Initial load duke parents: diff changeset	1085 for (uint i = 1; i < phi->req(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1086 Node* val = phi->in(i);
a61af66fc99e Initial load duke parents: diff changeset	1087 Node* use_c = region->in(i);
a61af66fc99e Initial load duke parents: diff changeset	1088 const TypeInt* val_t = filtered_type_from_dominators(val, use_c);
a61af66fc99e Initial load duke parents: diff changeset	1089 if (val_t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1090 if (filtered_t == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1091 filtered_t = val_t;
a61af66fc99e Initial load duke parents: diff changeset	1092 } else {
a61af66fc99e Initial load duke parents: diff changeset	1093 filtered_t = filtered_t->meet(val_t)->is_int();
a61af66fc99e Initial load duke parents: diff changeset	1094 }
a61af66fc99e Initial load duke parents: diff changeset	1095 }
a61af66fc99e Initial load duke parents: diff changeset	1096 }
a61af66fc99e Initial load duke parents: diff changeset	1097 }
a61af66fc99e Initial load duke parents: diff changeset	1098 }
a61af66fc99e Initial load duke parents: diff changeset	1099 const TypeInt* n_t = _igvn.type(n)->is_int();
a61af66fc99e Initial load duke parents: diff changeset	1100 if (filtered_t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1101 n_t = n_t->join(filtered_t)->is_int();
a61af66fc99e Initial load duke parents: diff changeset	1102 }
a61af66fc99e Initial load duke parents: diff changeset	1103 return n_t;
a61af66fc99e Initial load duke parents: diff changeset	1104 }
a61af66fc99e Initial load duke parents: diff changeset	1105
a61af66fc99e Initial load duke parents: diff changeset	1106
a61af66fc99e Initial load duke parents: diff changeset	1107 //------------------------------filtered_type_from_dominators--------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1108 // Return a possibly more restrictive type for val based on condition control flow of dominators
a61af66fc99e Initial load duke parents: diff changeset	1109 const TypeInt* PhaseIdealLoop::filtered_type_from_dominators( Node* val, Node *use_ctrl) {
a61af66fc99e Initial load duke parents: diff changeset	1110 if (val->is_Con()) {
a61af66fc99e Initial load duke parents: diff changeset	1111 return val->bottom_type()->is_int();
a61af66fc99e Initial load duke parents: diff changeset	1112 }
a61af66fc99e Initial load duke parents: diff changeset	1113 uint if_limit = 10; // Max number of dominating if's visited
a61af66fc99e Initial load duke parents: diff changeset	1114 const TypeInt* rtn_t = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1115
a61af66fc99e Initial load duke parents: diff changeset	1116 if (use_ctrl && use_ctrl != C->top()) {
a61af66fc99e Initial load duke parents: diff changeset	1117 Node* val_ctrl = get_ctrl(val);
a61af66fc99e Initial load duke parents: diff changeset	1118 uint val_dom_depth = dom_depth(val_ctrl);
a61af66fc99e Initial load duke parents: diff changeset	1119 Node* pred = use_ctrl;
a61af66fc99e Initial load duke parents: diff changeset	1120 uint if_cnt = 0;
a61af66fc99e Initial load duke parents: diff changeset	1121 while (if_cnt < if_limit) {
a61af66fc99e Initial load duke parents: diff changeset	1122 if ((pred->Opcode() == Op_IfTrue \|\| pred->Opcode() == Op_IfFalse)) {
a61af66fc99e Initial load duke parents: diff changeset	1123 if_cnt++;
17 ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long) never parents: 0 diff changeset	1124 const TypeInt* if_t = IfNode::filtered_int_type(&_igvn, val, pred);
0 a61af66fc99e Initial load duke parents: diff changeset	1125 if (if_t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1126 if (rtn_t == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1127 rtn_t = if_t;
a61af66fc99e Initial load duke parents: diff changeset	1128 } else {
a61af66fc99e Initial load duke parents: diff changeset	1129 rtn_t = rtn_t->join(if_t)->is_int();
a61af66fc99e Initial load duke parents: diff changeset	1130 }
a61af66fc99e Initial load duke parents: diff changeset	1131 }
a61af66fc99e Initial load duke parents: diff changeset	1132 }
a61af66fc99e Initial load duke parents: diff changeset	1133 pred = idom(pred);
a61af66fc99e Initial load duke parents: diff changeset	1134 if (pred == NULL \|\| pred == C->top()) {
a61af66fc99e Initial load duke parents: diff changeset	1135 break;
a61af66fc99e Initial load duke parents: diff changeset	1136 }
a61af66fc99e Initial load duke parents: diff changeset	1137 // Stop if going beyond definition block of val
a61af66fc99e Initial load duke parents: diff changeset	1138 if (dom_depth(pred) < val_dom_depth) {
a61af66fc99e Initial load duke parents: diff changeset	1139 break;
a61af66fc99e Initial load duke parents: diff changeset	1140 }
a61af66fc99e Initial load duke parents: diff changeset	1141 }
a61af66fc99e Initial load duke parents: diff changeset	1142 }
a61af66fc99e Initial load duke parents: diff changeset	1143 return rtn_t;
a61af66fc99e Initial load duke parents: diff changeset	1144 }
a61af66fc99e Initial load duke parents: diff changeset	1145
a61af66fc99e Initial load duke parents: diff changeset	1146
a61af66fc99e Initial load duke parents: diff changeset	1147 //------------------------------dump_spec--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1148 // Dump special per-node info
a61af66fc99e Initial load duke parents: diff changeset	1149 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1150 void CountedLoopEndNode::dump_spec(outputStream *st) const {
a61af66fc99e Initial load duke parents: diff changeset	1151 if( in(TestValue)->is_Bool() ) {
a61af66fc99e Initial load duke parents: diff changeset	1152 BoolTest bt( test_trip()); // Added this for g++.
a61af66fc99e Initial load duke parents: diff changeset	1153
a61af66fc99e Initial load duke parents: diff changeset	1154 st->print("[");
a61af66fc99e Initial load duke parents: diff changeset	1155 bt.dump_on(st);
a61af66fc99e Initial load duke parents: diff changeset	1156 st->print("]");
a61af66fc99e Initial load duke parents: diff changeset	1157 }
a61af66fc99e Initial load duke parents: diff changeset	1158 st->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	1159 IfNode::dump_spec(st);
a61af66fc99e Initial load duke parents: diff changeset	1160 }
a61af66fc99e Initial load duke parents: diff changeset	1161 #endif
a61af66fc99e Initial load duke parents: diff changeset	1162
a61af66fc99e Initial load duke parents: diff changeset	1163 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	1164 //------------------------------is_member--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1165 // Is 'l' a member of 'this'?
a61af66fc99e Initial load duke parents: diff changeset	1166 int IdealLoopTree::is_member( const IdealLoopTree *l ) const {
a61af66fc99e Initial load duke parents: diff changeset	1167 while( l->_nest > _nest ) l = l->_parent;
a61af66fc99e Initial load duke parents: diff changeset	1168 return l == this;
a61af66fc99e Initial load duke parents: diff changeset	1169 }
a61af66fc99e Initial load duke parents: diff changeset	1170
a61af66fc99e Initial load duke parents: diff changeset	1171 //------------------------------set_nest---------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1172 // Set loop tree nesting depth. Accumulate _has_call bits.
a61af66fc99e Initial load duke parents: diff changeset	1173 int IdealLoopTree::set_nest( uint depth ) {
a61af66fc99e Initial load duke parents: diff changeset	1174 _nest = depth;
a61af66fc99e Initial load duke parents: diff changeset	1175 int bits = _has_call;
a61af66fc99e Initial load duke parents: diff changeset	1176 if( _child ) bits \|= _child->set_nest(depth+1);
a61af66fc99e Initial load duke parents: diff changeset	1177 if( bits ) _has_call = 1;
a61af66fc99e Initial load duke parents: diff changeset	1178 if( _next ) bits \|= _next ->set_nest(depth );
a61af66fc99e Initial load duke parents: diff changeset	1179 return bits;
a61af66fc99e Initial load duke parents: diff changeset	1180 }
a61af66fc99e Initial load duke parents: diff changeset	1181
a61af66fc99e Initial load duke parents: diff changeset	1182 //------------------------------split_fall_in----------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1183 // Split out multiple fall-in edges from the loop header. Move them to a
a61af66fc99e Initial load duke parents: diff changeset	1184 // private RegionNode before the loop. This becomes the loop landing pad.
a61af66fc99e Initial load duke parents: diff changeset	1185 void IdealLoopTree::split_fall_in( PhaseIdealLoop *phase, int fall_in_cnt ) {
a61af66fc99e Initial load duke parents: diff changeset	1186 PhaseIterGVN &igvn = phase->_igvn;
a61af66fc99e Initial load duke parents: diff changeset	1187 uint i;
a61af66fc99e Initial load duke parents: diff changeset	1188
a61af66fc99e Initial load duke parents: diff changeset	1189 // Make a new RegionNode to be the landing pad.
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1190 Node *landing_pad = new (phase->C) RegionNode( fall_in_cnt+1 );
0 a61af66fc99e Initial load duke parents: diff changeset	1191 phase->set_loop(landing_pad,_parent);
a61af66fc99e Initial load duke parents: diff changeset	1192 // Gather all the fall-in control paths into the landing pad
a61af66fc99e Initial load duke parents: diff changeset	1193 uint icnt = fall_in_cnt;
a61af66fc99e Initial load duke parents: diff changeset	1194 uint oreq = _head->req();
a61af66fc99e Initial load duke parents: diff changeset	1195 for( i = oreq-1; i>0; i-- )
a61af66fc99e Initial load duke parents: diff changeset	1196 if( !phase->is_member( this, _head->in(i) ) )
a61af66fc99e Initial load duke parents: diff changeset	1197 landing_pad->set_req(icnt--,_head->in(i));
a61af66fc99e Initial load duke parents: diff changeset	1198
a61af66fc99e Initial load duke parents: diff changeset	1199 // Peel off PhiNode edges as well
a61af66fc99e Initial load duke parents: diff changeset	1200 for (DUIterator_Fast jmax, j = _head->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load duke parents: diff changeset	1201 Node *oj = _head->fast_out(j);
a61af66fc99e Initial load duke parents: diff changeset	1202 if( oj->is_Phi() ) {
a61af66fc99e Initial load duke parents: diff changeset	1203 PhiNode* old_phi = oj->as_Phi();
a61af66fc99e Initial load duke parents: diff changeset	1204 assert( old_phi->region() == _head, "" );
a61af66fc99e Initial load duke parents: diff changeset	1205 igvn.hash_delete(old_phi); // Yank from hash before hacking edges
a61af66fc99e Initial load duke parents: diff changeset	1206 Node *p = PhiNode::make_blank(landing_pad, old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1207 uint icnt = fall_in_cnt;
a61af66fc99e Initial load duke parents: diff changeset	1208 for( i = oreq-1; i>0; i-- ) {
a61af66fc99e Initial load duke parents: diff changeset	1209 if( !phase->is_member( this, _head->in(i) ) ) {
a61af66fc99e Initial load duke parents: diff changeset	1210 p->init_req(icnt--, old_phi->in(i));
a61af66fc99e Initial load duke parents: diff changeset	1211 // Go ahead and clean out old edges from old phi
a61af66fc99e Initial load duke parents: diff changeset	1212 old_phi->del_req(i);
a61af66fc99e Initial load duke parents: diff changeset	1213 }
a61af66fc99e Initial load duke parents: diff changeset	1214 }
a61af66fc99e Initial load duke parents: diff changeset	1215 // Search for CSE's here, because ZKM.jar does a lot of
a61af66fc99e Initial load duke parents: diff changeset	1216 // loop hackery and we need to be a little incremental
a61af66fc99e Initial load duke parents: diff changeset	1217 // with the CSE to avoid O(N^2) node blow-up.
a61af66fc99e Initial load duke parents: diff changeset	1218 Node *p2 = igvn.hash_find_insert(p); // Look for a CSE
a61af66fc99e Initial load duke parents: diff changeset	1219 if( p2 ) { // Found CSE
a61af66fc99e Initial load duke parents: diff changeset	1220 p->destruct(); // Recover useless new node
a61af66fc99e Initial load duke parents: diff changeset	1221 p = p2; // Use old node
a61af66fc99e Initial load duke parents: diff changeset	1222 } else {
a61af66fc99e Initial load duke parents: diff changeset	1223 igvn.register_new_node_with_optimizer(p, old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1224 }
a61af66fc99e Initial load duke parents: diff changeset	1225 // Make old Phi refer to new Phi.
a61af66fc99e Initial load duke parents: diff changeset	1226 old_phi->add_req(p);
a61af66fc99e Initial load duke parents: diff changeset	1227 // Check for the special case of making the old phi useless and
a61af66fc99e Initial load duke parents: diff changeset	1228 // disappear it. In JavaGrande I have a case where this useless
a61af66fc99e Initial load duke parents: diff changeset	1229 // Phi is the loop limit and prevents recognizing a CountedLoop
a61af66fc99e Initial load duke parents: diff changeset	1230 // which in turn prevents removing an empty loop.
a61af66fc99e Initial load duke parents: diff changeset	1231 Node *id_old_phi = old_phi->Identity( &igvn );
a61af66fc99e Initial load duke parents: diff changeset	1232 if( id_old_phi != old_phi ) { // Found a simple identity?
1621 6027dddc26c6 6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist() kvn parents: 1552 diff changeset	1233 // Note that I cannot call 'replace_node' here, because
0 a61af66fc99e Initial load duke parents: diff changeset	1234 // that will yank the edge from old_phi to the Region and
a61af66fc99e Initial load duke parents: diff changeset	1235 // I'm mid-iteration over the Region's uses.
a61af66fc99e Initial load duke parents: diff changeset	1236 for (DUIterator_Last imin, i = old_phi->last_outs(imin); i >= imin; ) {
a61af66fc99e Initial load duke parents: diff changeset	1237 Node* use = old_phi->last_out(i);
6144 5e990493719e 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node, int, Node) where applicable kvn parents: 4862 diff changeset	1238 igvn.rehash_node_delayed(use);
0 a61af66fc99e Initial load duke parents: diff changeset	1239 uint uses_found = 0;
a61af66fc99e Initial load duke parents: diff changeset	1240 for (uint j = 0; j < use->len(); j++) {
a61af66fc99e Initial load duke parents: diff changeset	1241 if (use->in(j) == old_phi) {
a61af66fc99e Initial load duke parents: diff changeset	1242 if (j < use->req()) use->set_req (j, id_old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1243 else use->set_prec(j, id_old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1244 uses_found++;
a61af66fc99e Initial load duke parents: diff changeset	1245 }
a61af66fc99e Initial load duke parents: diff changeset	1246 }
a61af66fc99e Initial load duke parents: diff changeset	1247 i -= uses_found; // we deleted 1 or more copies of this edge
a61af66fc99e Initial load duke parents: diff changeset	1248 }
a61af66fc99e Initial load duke parents: diff changeset	1249 }
a61af66fc99e Initial load duke parents: diff changeset	1250 igvn._worklist.push(old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1251 }
a61af66fc99e Initial load duke parents: diff changeset	1252 }
a61af66fc99e Initial load duke parents: diff changeset	1253 // Finally clean out the fall-in edges from the RegionNode
a61af66fc99e Initial load duke parents: diff changeset	1254 for( i = oreq-1; i>0; i-- ) {
a61af66fc99e Initial load duke parents: diff changeset	1255 if( !phase->is_member( this, _head->in(i) ) ) {
a61af66fc99e Initial load duke parents: diff changeset	1256 _head->del_req(i);
a61af66fc99e Initial load duke parents: diff changeset	1257 }
a61af66fc99e Initial load duke parents: diff changeset	1258 }
a61af66fc99e Initial load duke parents: diff changeset	1259 // Transform landing pad
a61af66fc99e Initial load duke parents: diff changeset	1260 igvn.register_new_node_with_optimizer(landing_pad, _head);
a61af66fc99e Initial load duke parents: diff changeset	1261 // Insert landing pad into the header
a61af66fc99e Initial load duke parents: diff changeset	1262 _head->add_req(landing_pad);
a61af66fc99e Initial load duke parents: diff changeset	1263 }
a61af66fc99e Initial load duke parents: diff changeset	1264
a61af66fc99e Initial load duke parents: diff changeset	1265 //------------------------------split_outer_loop-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1266 // Split out the outermost loop from this shared header.
a61af66fc99e Initial load duke parents: diff changeset	1267 void IdealLoopTree::split_outer_loop( PhaseIdealLoop *phase ) {
a61af66fc99e Initial load duke parents: diff changeset	1268 PhaseIterGVN &igvn = phase->_igvn;
a61af66fc99e Initial load duke parents: diff changeset	1269
a61af66fc99e Initial load duke parents: diff changeset	1270 // Find index of outermost loop; it should also be my tail.
a61af66fc99e Initial load duke parents: diff changeset	1271 uint outer_idx = 1;
a61af66fc99e Initial load duke parents: diff changeset	1272 while( _head->in(outer_idx) != _tail ) outer_idx++;
a61af66fc99e Initial load duke parents: diff changeset	1273
a61af66fc99e Initial load duke parents: diff changeset	1274 // Make a LoopNode for the outermost loop.
a61af66fc99e Initial load duke parents: diff changeset	1275 Node *ctl = _head->in(LoopNode::EntryControl);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1276 Node *outer = new (phase->C) LoopNode( ctl, _head->in(outer_idx) );
0 a61af66fc99e Initial load duke parents: diff changeset	1277 outer = igvn.register_new_node_with_optimizer(outer, _head);
a61af66fc99e Initial load duke parents: diff changeset	1278 phase->set_created_loop_node();
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	1279
0 a61af66fc99e Initial load duke parents: diff changeset	1280 // Outermost loop falls into '_head' loop
3845 c96c3eb1efae 7068051: SIGSEGV in PhaseIdealLoop::build_loop_late_post kvn parents: 3782 diff changeset	1281 _head->set_req(LoopNode::EntryControl, outer);
0 a61af66fc99e Initial load duke parents: diff changeset	1282 _head->del_req(outer_idx);
a61af66fc99e Initial load duke parents: diff changeset	1283 // Split all the Phis up between '_head' loop and 'outer' loop.
a61af66fc99e Initial load duke parents: diff changeset	1284 for (DUIterator_Fast jmax, j = _head->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load duke parents: diff changeset	1285 Node *out = _head->fast_out(j);
a61af66fc99e Initial load duke parents: diff changeset	1286 if( out->is_Phi() ) {
a61af66fc99e Initial load duke parents: diff changeset	1287 PhiNode *old_phi = out->as_Phi();
a61af66fc99e Initial load duke parents: diff changeset	1288 assert( old_phi->region() == _head, "" );
a61af66fc99e Initial load duke parents: diff changeset	1289 Node *phi = PhiNode::make_blank(outer, old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1290 phi->init_req(LoopNode::EntryControl, old_phi->in(LoopNode::EntryControl));
a61af66fc99e Initial load duke parents: diff changeset	1291 phi->init_req(LoopNode::LoopBackControl, old_phi->in(outer_idx));
a61af66fc99e Initial load duke parents: diff changeset	1292 phi = igvn.register_new_node_with_optimizer(phi, old_phi);
a61af66fc99e Initial load duke parents: diff changeset	1293 // Make old Phi point to new Phi on the fall-in path
6144 5e990493719e 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node, int, Node) where applicable kvn parents: 4862 diff changeset	1294 igvn.replace_input_of(old_phi, LoopNode::EntryControl, phi);
0 a61af66fc99e Initial load duke parents: diff changeset	1295 old_phi->del_req(outer_idx);
a61af66fc99e Initial load duke parents: diff changeset	1296 }
a61af66fc99e Initial load duke parents: diff changeset	1297 }
a61af66fc99e Initial load duke parents: diff changeset	1298
a61af66fc99e Initial load duke parents: diff changeset	1299 // Use the new loop head instead of the old shared one
a61af66fc99e Initial load duke parents: diff changeset	1300 _head = outer;
a61af66fc99e Initial load duke parents: diff changeset	1301 phase->set_loop(_head, this);
a61af66fc99e Initial load duke parents: diff changeset	1302 }
a61af66fc99e Initial load duke parents: diff changeset	1303
a61af66fc99e Initial load duke parents: diff changeset	1304 //------------------------------fix_parent-------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1305 static void fix_parent( IdealLoopTree loop, IdealLoopTree parent ) {
a61af66fc99e Initial load duke parents: diff changeset	1306 loop->_parent = parent;
a61af66fc99e Initial load duke parents: diff changeset	1307 if( loop->_child ) fix_parent( loop->_child, loop );
a61af66fc99e Initial load duke parents: diff changeset	1308 if( loop->_next ) fix_parent( loop->_next , parent );
a61af66fc99e Initial load duke parents: diff changeset	1309 }
a61af66fc99e Initial load duke parents: diff changeset	1310
a61af66fc99e Initial load duke parents: diff changeset	1311 //------------------------------estimate_path_freq-----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1312 static float estimate_path_freq( Node *n ) {
a61af66fc99e Initial load duke parents: diff changeset	1313 // Try to extract some path frequency info
a61af66fc99e Initial load duke parents: diff changeset	1314 IfNode *iff;
a61af66fc99e Initial load duke parents: diff changeset	1315 for( int i = 0; i < 50; i++ ) { // Skip through a bunch of uncommon tests
a61af66fc99e Initial load duke parents: diff changeset	1316 uint nop = n->Opcode();
a61af66fc99e Initial load duke parents: diff changeset	1317 if( nop == Op_SafePoint ) { // Skip any safepoint
a61af66fc99e Initial load duke parents: diff changeset	1318 n = n->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1319 continue;
a61af66fc99e Initial load duke parents: diff changeset	1320 }
a61af66fc99e Initial load duke parents: diff changeset	1321 if( nop == Op_CatchProj ) { // Get count from a prior call
a61af66fc99e Initial load duke parents: diff changeset	1322 // Assume call does not always throw exceptions: means the call-site
a61af66fc99e Initial load duke parents: diff changeset	1323 // count is also the frequency of the fall-through path.
a61af66fc99e Initial load duke parents: diff changeset	1324 assert( n->is_CatchProj(), "" );
a61af66fc99e Initial load duke parents: diff changeset	1325 if( ((CatchProjNode*)n)->_con != CatchProjNode::fall_through_index )
a61af66fc99e Initial load duke parents: diff changeset	1326 return 0.0f; // Assume call exception path is rare
a61af66fc99e Initial load duke parents: diff changeset	1327 Node *call = n->in(0)->in(0)->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1328 assert( call->is_Call(), "expect a call here" );
a61af66fc99e Initial load duke parents: diff changeset	1329 const JVMState jvms = ((CallNode)call)->jvms();
a61af66fc99e Initial load duke parents: diff changeset	1330 ciMethodData* methodData = jvms->method()->method_data();
a61af66fc99e Initial load duke parents: diff changeset	1331 if (!methodData->is_mature()) return 0.0f; // No call-site data
a61af66fc99e Initial load duke parents: diff changeset	1332 ciProfileData* data = methodData->bci_to_data(jvms->bci());
a61af66fc99e Initial load duke parents: diff changeset	1333 if ((data == NULL) \|\| !data->is_CounterData()) {
a61af66fc99e Initial load duke parents: diff changeset	1334 // no call profile available, try call's control input
a61af66fc99e Initial load duke parents: diff changeset	1335 n = n->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1336 continue;
a61af66fc99e Initial load duke parents: diff changeset	1337 }
a61af66fc99e Initial load duke parents: diff changeset	1338 return data->as_CounterData()->count()/FreqCountInvocations;
a61af66fc99e Initial load duke parents: diff changeset	1339 }
a61af66fc99e Initial load duke parents: diff changeset	1340 // See if there's a gating IF test
a61af66fc99e Initial load duke parents: diff changeset	1341 Node *n_c = n->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1342 if( !n_c->is_If() ) break; // No estimate available
a61af66fc99e Initial load duke parents: diff changeset	1343 iff = n_c->as_If();
a61af66fc99e Initial load duke parents: diff changeset	1344 if( iff->_fcnt != COUNT_UNKNOWN ) // Have a valid count?
a61af66fc99e Initial load duke parents: diff changeset	1345 // Compute how much count comes on this path
a61af66fc99e Initial load duke parents: diff changeset	1346 return ((nop == Op_IfTrue) ? iff->_prob : 1.0f - iff->_prob) * iff->_fcnt;
a61af66fc99e Initial load duke parents: diff changeset	1347 // Have no count info. Skip dull uncommon-trap like branches.
a61af66fc99e Initial load duke parents: diff changeset	1348 if( (nop == Op_IfTrue && iff->_prob < PROB_LIKELY_MAG(5)) \|\|
a61af66fc99e Initial load duke parents: diff changeset	1349 (nop == Op_IfFalse && iff->_prob > PROB_UNLIKELY_MAG(5)) )
a61af66fc99e Initial load duke parents: diff changeset	1350 break;
a61af66fc99e Initial load duke parents: diff changeset	1351 // Skip through never-taken branch; look for a real loop exit.
a61af66fc99e Initial load duke parents: diff changeset	1352 n = iff->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1353 }
a61af66fc99e Initial load duke parents: diff changeset	1354 return 0.0f; // No estimate available
a61af66fc99e Initial load duke parents: diff changeset	1355 }
a61af66fc99e Initial load duke parents: diff changeset	1356
a61af66fc99e Initial load duke parents: diff changeset	1357 //------------------------------merge_many_backedges---------------------------
a61af66fc99e Initial load duke parents: diff changeset	1358 // Merge all the backedges from the shared header into a private Region.
a61af66fc99e Initial load duke parents: diff changeset	1359 // Feed that region as the one backedge to this loop.
a61af66fc99e Initial load duke parents: diff changeset	1360 void IdealLoopTree::merge_many_backedges( PhaseIdealLoop *phase ) {
a61af66fc99e Initial load duke parents: diff changeset	1361 uint i;
a61af66fc99e Initial load duke parents: diff changeset	1362
a61af66fc99e Initial load duke parents: diff changeset	1363 // Scan for the top 2 hottest backedges
a61af66fc99e Initial load duke parents: diff changeset	1364 float hotcnt = 0.0f;
a61af66fc99e Initial load duke parents: diff changeset	1365 float warmcnt = 0.0f;
a61af66fc99e Initial load duke parents: diff changeset	1366 uint hot_idx = 0;
a61af66fc99e Initial load duke parents: diff changeset	1367 // Loop starts at 2 because slot 1 is the fall-in path
a61af66fc99e Initial load duke parents: diff changeset	1368 for( i = 2; i < _head->req(); i++ ) {
a61af66fc99e Initial load duke parents: diff changeset	1369 float cnt = estimate_path_freq(_head->in(i));
a61af66fc99e Initial load duke parents: diff changeset	1370 if( cnt > hotcnt ) { // Grab hottest path
a61af66fc99e Initial load duke parents: diff changeset	1371 warmcnt = hotcnt;
a61af66fc99e Initial load duke parents: diff changeset	1372 hotcnt = cnt;
a61af66fc99e Initial load duke parents: diff changeset	1373 hot_idx = i;
a61af66fc99e Initial load duke parents: diff changeset	1374 } else if( cnt > warmcnt ) { // And 2nd hottest path
a61af66fc99e Initial load duke parents: diff changeset	1375 warmcnt = cnt;
a61af66fc99e Initial load duke parents: diff changeset	1376 }
a61af66fc99e Initial load duke parents: diff changeset	1377 }
a61af66fc99e Initial load duke parents: diff changeset	1378
a61af66fc99e Initial load duke parents: diff changeset	1379 // See if the hottest backedge is worthy of being an inner loop
a61af66fc99e Initial load duke parents: diff changeset	1380 // by being much hotter than the next hottest backedge.
a61af66fc99e Initial load duke parents: diff changeset	1381 if( hotcnt <= 0.0001 \|\|
a61af66fc99e Initial load duke parents: diff changeset	1382 hotcnt < 2.0*warmcnt ) hot_idx = 0;// No hot backedge
a61af66fc99e Initial load duke parents: diff changeset	1383
a61af66fc99e Initial load duke parents: diff changeset	1384 // Peel out the backedges into a private merge point; peel
a61af66fc99e Initial load duke parents: diff changeset	1385 // them all except optionally hot_idx.
a61af66fc99e Initial load duke parents: diff changeset	1386 PhaseIterGVN &igvn = phase->_igvn;
a61af66fc99e Initial load duke parents: diff changeset	1387
a61af66fc99e Initial load duke parents: diff changeset	1388 Node *hot_tail = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1389 // Make a Region for the merge point
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1390 Node *r = new (phase->C) RegionNode(1);
0 a61af66fc99e Initial load duke parents: diff changeset	1391 for( i = 2; i < _head->req(); i++ ) {
a61af66fc99e Initial load duke parents: diff changeset	1392 if( i != hot_idx )
a61af66fc99e Initial load duke parents: diff changeset	1393 r->add_req( _head->in(i) );
a61af66fc99e Initial load duke parents: diff changeset	1394 else hot_tail = _head->in(i);
a61af66fc99e Initial load duke parents: diff changeset	1395 }
a61af66fc99e Initial load duke parents: diff changeset	1396 igvn.register_new_node_with_optimizer(r, _head);
a61af66fc99e Initial load duke parents: diff changeset	1397 // Plug region into end of loop _head, followed by hot_tail
a61af66fc99e Initial load duke parents: diff changeset	1398 while( _head->req() > 3 ) _head->del_req( _head->req()-1 );
a61af66fc99e Initial load duke parents: diff changeset	1399 _head->set_req(2, r);
a61af66fc99e Initial load duke parents: diff changeset	1400 if( hot_idx ) _head->add_req(hot_tail);
a61af66fc99e Initial load duke parents: diff changeset	1401
a61af66fc99e Initial load duke parents: diff changeset	1402 // Split all the Phis up between '_head' loop and the Region 'r'
a61af66fc99e Initial load duke parents: diff changeset	1403 for (DUIterator_Fast jmax, j = _head->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load duke parents: diff changeset	1404 Node *out = _head->fast_out(j);
a61af66fc99e Initial load duke parents: diff changeset	1405 if( out->is_Phi() ) {
a61af66fc99e Initial load duke parents: diff changeset	1406 PhiNode* n = out->as_Phi();
a61af66fc99e Initial load duke parents: diff changeset	1407 igvn.hash_delete(n); // Delete from hash before hacking edges
a61af66fc99e Initial load duke parents: diff changeset	1408 Node *hot_phi = NULL;
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1409 Node *phi = new (phase->C) PhiNode(r, n->type(), n->adr_type());
0 a61af66fc99e Initial load duke parents: diff changeset	1410 // Check all inputs for the ones to peel out
a61af66fc99e Initial load duke parents: diff changeset	1411 uint j = 1;
a61af66fc99e Initial load duke parents: diff changeset	1412 for( uint i = 2; i < n->req(); i++ ) {
a61af66fc99e Initial load duke parents: diff changeset	1413 if( i != hot_idx )
a61af66fc99e Initial load duke parents: diff changeset	1414 phi->set_req( j++, n->in(i) );
a61af66fc99e Initial load duke parents: diff changeset	1415 else hot_phi = n->in(i);
a61af66fc99e Initial load duke parents: diff changeset	1416 }
a61af66fc99e Initial load duke parents: diff changeset	1417 // Register the phi but do not transform until whole place transforms
a61af66fc99e Initial load duke parents: diff changeset	1418 igvn.register_new_node_with_optimizer(phi, n);
a61af66fc99e Initial load duke parents: diff changeset	1419 // Add the merge phi to the old Phi
a61af66fc99e Initial load duke parents: diff changeset	1420 while( n->req() > 3 ) n->del_req( n->req()-1 );
a61af66fc99e Initial load duke parents: diff changeset	1421 n->set_req(2, phi);
a61af66fc99e Initial load duke parents: diff changeset	1422 if( hot_idx ) n->add_req(hot_phi);
a61af66fc99e Initial load duke parents: diff changeset	1423 }
a61af66fc99e Initial load duke parents: diff changeset	1424 }
a61af66fc99e Initial load duke parents: diff changeset	1425
a61af66fc99e Initial load duke parents: diff changeset	1426
a61af66fc99e Initial load duke parents: diff changeset	1427 // Insert a new IdealLoopTree inserted below me. Turn it into a clone
a61af66fc99e Initial load duke parents: diff changeset	1428 // of self loop tree. Turn self into a loop headed by _head and with
a61af66fc99e Initial load duke parents: diff changeset	1429 // tail being the new merge point.
a61af66fc99e Initial load duke parents: diff changeset	1430 IdealLoopTree *ilt = new IdealLoopTree( phase, _head, _tail );
a61af66fc99e Initial load duke parents: diff changeset	1431 phase->set_loop(_tail,ilt); // Adjust tail
a61af66fc99e Initial load duke parents: diff changeset	1432 _tail = r; // Self's tail is new merge point
a61af66fc99e Initial load duke parents: diff changeset	1433 phase->set_loop(r,this);
a61af66fc99e Initial load duke parents: diff changeset	1434 ilt->_child = _child; // New guy has my children
a61af66fc99e Initial load duke parents: diff changeset	1435 _child = ilt; // Self has new guy as only child
a61af66fc99e Initial load duke parents: diff changeset	1436 ilt->_parent = this; // new guy has self for parent
a61af66fc99e Initial load duke parents: diff changeset	1437 ilt->_nest = _nest; // Same nesting depth (for now)
a61af66fc99e Initial load duke parents: diff changeset	1438
a61af66fc99e Initial load duke parents: diff changeset	1439 // Starting with 'ilt', look for child loop trees using the same shared
a61af66fc99e Initial load duke parents: diff changeset	1440 // header. Flatten these out; they will no longer be loops in the end.
a61af66fc99e Initial load duke parents: diff changeset	1441 IdealLoopTree **pilt = &_child;
a61af66fc99e Initial load duke parents: diff changeset	1442 while( ilt ) {
a61af66fc99e Initial load duke parents: diff changeset	1443 if( ilt->_head == _head ) {
a61af66fc99e Initial load duke parents: diff changeset	1444 uint i;
a61af66fc99e Initial load duke parents: diff changeset	1445 for( i = 2; i < _head->req(); i++ )
a61af66fc99e Initial load duke parents: diff changeset	1446 if( _head->in(i) == ilt->_tail )
a61af66fc99e Initial load duke parents: diff changeset	1447 break; // Still a loop
a61af66fc99e Initial load duke parents: diff changeset	1448 if( i == _head->req() ) { // No longer a loop
a61af66fc99e Initial load duke parents: diff changeset	1449 // Flatten ilt. Hang ilt's "_next" list from the end of
a61af66fc99e Initial load duke parents: diff changeset	1450 // ilt's '_child' list. Move the ilt's _child up to replace ilt.
a61af66fc99e Initial load duke parents: diff changeset	1451 IdealLoopTree **cp = &ilt->_child;
a61af66fc99e Initial load duke parents: diff changeset	1452 while( cp ) cp = &(cp)->_next; // Find end of child list
a61af66fc99e Initial load duke parents: diff changeset	1453 *cp = ilt->_next; // Hang next list at end of child list
a61af66fc99e Initial load duke parents: diff changeset	1454 *pilt = ilt->_child; // Move child up to replace ilt
a61af66fc99e Initial load duke parents: diff changeset	1455 ilt->_head = NULL; // Flag as a loop UNIONED into parent
a61af66fc99e Initial load duke parents: diff changeset	1456 ilt = ilt->_child; // Repeat using new ilt
a61af66fc99e Initial load duke parents: diff changeset	1457 continue; // do not advance over ilt->_child
a61af66fc99e Initial load duke parents: diff changeset	1458 }
a61af66fc99e Initial load duke parents: diff changeset	1459 assert( ilt->_tail == hot_tail, "expected to only find the hot inner loop here" );
a61af66fc99e Initial load duke parents: diff changeset	1460 phase->set_loop(_head,ilt);
a61af66fc99e Initial load duke parents: diff changeset	1461 }
a61af66fc99e Initial load duke parents: diff changeset	1462 pilt = &ilt->_child; // Advance to next
a61af66fc99e Initial load duke parents: diff changeset	1463 ilt = *pilt;
a61af66fc99e Initial load duke parents: diff changeset	1464 }
a61af66fc99e Initial load duke parents: diff changeset	1465
a61af66fc99e Initial load duke parents: diff changeset	1466 if( _child ) fix_parent( _child, this );
a61af66fc99e Initial load duke parents: diff changeset	1467 }
a61af66fc99e Initial load duke parents: diff changeset	1468
a61af66fc99e Initial load duke parents: diff changeset	1469 //------------------------------beautify_loops---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1470 // Split shared headers and insert loop landing pads.
a61af66fc99e Initial load duke parents: diff changeset	1471 // Insert a LoopNode to replace the RegionNode.
a61af66fc99e Initial load duke parents: diff changeset	1472 // Return TRUE if loop tree is structurally changed.
a61af66fc99e Initial load duke parents: diff changeset	1473 bool IdealLoopTree::beautify_loops( PhaseIdealLoop *phase ) {
a61af66fc99e Initial load duke parents: diff changeset	1474 bool result = false;
a61af66fc99e Initial load duke parents: diff changeset	1475 // Cache parts in locals for easy
a61af66fc99e Initial load duke parents: diff changeset	1476 PhaseIterGVN &igvn = phase->_igvn;
a61af66fc99e Initial load duke parents: diff changeset	1477
a61af66fc99e Initial load duke parents: diff changeset	1478 igvn.hash_delete(_head); // Yank from hash before hacking edges
a61af66fc99e Initial load duke parents: diff changeset	1479
a61af66fc99e Initial load duke parents: diff changeset	1480 // Check for multiple fall-in paths. Peel off a landing pad if need be.
a61af66fc99e Initial load duke parents: diff changeset	1481 int fall_in_cnt = 0;
a61af66fc99e Initial load duke parents: diff changeset	1482 for( uint i = 1; i < _head->req(); i++ )
a61af66fc99e Initial load duke parents: diff changeset	1483 if( !phase->is_member( this, _head->in(i) ) )
a61af66fc99e Initial load duke parents: diff changeset	1484 fall_in_cnt++;
a61af66fc99e Initial load duke parents: diff changeset	1485 assert( fall_in_cnt, "at least 1 fall-in path" );
a61af66fc99e Initial load duke parents: diff changeset	1486 if( fall_in_cnt > 1 ) // Need a loop landing pad to merge fall-ins
a61af66fc99e Initial load duke parents: diff changeset	1487 split_fall_in( phase, fall_in_cnt );
a61af66fc99e Initial load duke parents: diff changeset	1488
a61af66fc99e Initial load duke parents: diff changeset	1489 // Swap inputs to the _head and all Phis to move the fall-in edge to
a61af66fc99e Initial load duke parents: diff changeset	1490 // the left.
a61af66fc99e Initial load duke parents: diff changeset	1491 fall_in_cnt = 1;
a61af66fc99e Initial load duke parents: diff changeset	1492 while( phase->is_member( this, _head->in(fall_in_cnt) ) )
a61af66fc99e Initial load duke parents: diff changeset	1493 fall_in_cnt++;
a61af66fc99e Initial load duke parents: diff changeset	1494 if( fall_in_cnt > 1 ) {
a61af66fc99e Initial load duke parents: diff changeset	1495 // Since I am just swapping inputs I do not need to update def-use info
a61af66fc99e Initial load duke parents: diff changeset	1496 Node *tmp = _head->in(1);
a61af66fc99e Initial load duke parents: diff changeset	1497 _head->set_req( 1, _head->in(fall_in_cnt) );
a61af66fc99e Initial load duke parents: diff changeset	1498 _head->set_req( fall_in_cnt, tmp );
a61af66fc99e Initial load duke parents: diff changeset	1499 // Swap also all Phis
a61af66fc99e Initial load duke parents: diff changeset	1500 for (DUIterator_Fast imax, i = _head->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1501 Node* phi = _head->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	1502 if( phi->is_Phi() ) {
a61af66fc99e Initial load duke parents: diff changeset	1503 igvn.hash_delete(phi); // Yank from hash before hacking edges
a61af66fc99e Initial load duke parents: diff changeset	1504 tmp = phi->in(1);
a61af66fc99e Initial load duke parents: diff changeset	1505 phi->set_req( 1, phi->in(fall_in_cnt) );
a61af66fc99e Initial load duke parents: diff changeset	1506 phi->set_req( fall_in_cnt, tmp );
a61af66fc99e Initial load duke parents: diff changeset	1507 }
a61af66fc99e Initial load duke parents: diff changeset	1508 }
a61af66fc99e Initial load duke parents: diff changeset	1509 }
a61af66fc99e Initial load duke parents: diff changeset	1510 assert( !phase->is_member( this, _head->in(1) ), "left edge is fall-in" );
a61af66fc99e Initial load duke parents: diff changeset	1511 assert( phase->is_member( this, _head->in(2) ), "right edge is loop" );
a61af66fc99e Initial load duke parents: diff changeset	1512
a61af66fc99e Initial load duke parents: diff changeset	1513 // If I am a shared header (multiple backedges), peel off the many
a61af66fc99e Initial load duke parents: diff changeset	1514 // backedges into a private merge point and use the merge point as
a61af66fc99e Initial load duke parents: diff changeset	1515 // the one true backedge.
a61af66fc99e Initial load duke parents: diff changeset	1516 if( _head->req() > 3 ) {
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	1517 // Merge the many backedges into a single backedge but leave
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	1518 // the hottest backedge as separate edge for the following peel.
0 a61af66fc99e Initial load duke parents: diff changeset	1519 merge_many_backedges( phase );
a61af66fc99e Initial load duke parents: diff changeset	1520 result = true;
a61af66fc99e Initial load duke parents: diff changeset	1521 }
a61af66fc99e Initial load duke parents: diff changeset	1522
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	1523 // If I have one hot backedge, peel off myself loop.
0 a61af66fc99e Initial load duke parents: diff changeset	1524 // I better be the outermost loop.
a61af66fc99e Initial load duke parents: diff changeset	1525 if( _head->req() > 3 ) {
a61af66fc99e Initial load duke parents: diff changeset	1526 split_outer_loop( phase );
a61af66fc99e Initial load duke parents: diff changeset	1527 result = true;
a61af66fc99e Initial load duke parents: diff changeset	1528
a61af66fc99e Initial load duke parents: diff changeset	1529 } else if( !_head->is_Loop() && !_irreducible ) {
a61af66fc99e Initial load duke parents: diff changeset	1530 // Make a new LoopNode to replace the old loop head
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1531 Node *l = new (phase->C) LoopNode( _head->in(1), _head->in(2) );
0 a61af66fc99e Initial load duke parents: diff changeset	1532 l = igvn.register_new_node_with_optimizer(l, _head);
a61af66fc99e Initial load duke parents: diff changeset	1533 phase->set_created_loop_node();
a61af66fc99e Initial load duke parents: diff changeset	1534 // Go ahead and replace _head
1621 6027dddc26c6 6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist() kvn parents: 1552 diff changeset	1535 phase->_igvn.replace_node( _head, l );
0 a61af66fc99e Initial load duke parents: diff changeset	1536 _head = l;
a61af66fc99e Initial load duke parents: diff changeset	1537 phase->set_loop(_head, this);
a61af66fc99e Initial load duke parents: diff changeset	1538 }
a61af66fc99e Initial load duke parents: diff changeset	1539
a61af66fc99e Initial load duke parents: diff changeset	1540 // Now recursively beautify nested loops
a61af66fc99e Initial load duke parents: diff changeset	1541 if( _child ) result \|= _child->beautify_loops( phase );
a61af66fc99e Initial load duke parents: diff changeset	1542 if( _next ) result \|= _next ->beautify_loops( phase );
a61af66fc99e Initial load duke parents: diff changeset	1543 return result;
a61af66fc99e Initial load duke parents: diff changeset	1544 }
a61af66fc99e Initial load duke parents: diff changeset	1545
a61af66fc99e Initial load duke parents: diff changeset	1546 //------------------------------allpaths_check_safepts----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1547 // Allpaths backwards scan from loop tail, terminating each path at first safepoint
a61af66fc99e Initial load duke parents: diff changeset	1548 // encountered. Helper for check_safepts.
a61af66fc99e Initial load duke parents: diff changeset	1549 void IdealLoopTree::allpaths_check_safepts(VectorSet &visited, Node_List &stack) {
a61af66fc99e Initial load duke parents: diff changeset	1550 assert(stack.size() == 0, "empty stack");
a61af66fc99e Initial load duke parents: diff changeset	1551 stack.push(_tail);
a61af66fc99e Initial load duke parents: diff changeset	1552 visited.Clear();
a61af66fc99e Initial load duke parents: diff changeset	1553 visited.set(_tail->_idx);
a61af66fc99e Initial load duke parents: diff changeset	1554 while (stack.size() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1555 Node* n = stack.pop();
a61af66fc99e Initial load duke parents: diff changeset	1556 if (n->is_Call() && n->as_Call()->guaranteed_safepoint()) {
a61af66fc99e Initial load duke parents: diff changeset	1557 // Terminate this path
a61af66fc99e Initial load duke parents: diff changeset	1558 } else if (n->Opcode() == Op_SafePoint) {
a61af66fc99e Initial load duke parents: diff changeset	1559 if (_phase->get_loop(n) != this) {
a61af66fc99e Initial load duke parents: diff changeset	1560 if (_required_safept == NULL) _required_safept = new Node_List();
a61af66fc99e Initial load duke parents: diff changeset	1561 _required_safept->push(n); // save the one closest to the tail
a61af66fc99e Initial load duke parents: diff changeset	1562 }
a61af66fc99e Initial load duke parents: diff changeset	1563 // Terminate this path
a61af66fc99e Initial load duke parents: diff changeset	1564 } else {
a61af66fc99e Initial load duke parents: diff changeset	1565 uint start = n->is_Region() ? 1 : 0;
a61af66fc99e Initial load duke parents: diff changeset	1566 uint end = n->is_Region() && !n->is_Loop() ? n->req() : start + 1;
a61af66fc99e Initial load duke parents: diff changeset	1567 for (uint i = start; i < end; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1568 Node* in = n->in(i);
a61af66fc99e Initial load duke parents: diff changeset	1569 assert(in->is_CFG(), "must be");
a61af66fc99e Initial load duke parents: diff changeset	1570 if (!visited.test_set(in->_idx) && is_member(_phase->get_loop(in))) {
a61af66fc99e Initial load duke parents: diff changeset	1571 stack.push(in);
a61af66fc99e Initial load duke parents: diff changeset	1572 }
a61af66fc99e Initial load duke parents: diff changeset	1573 }
a61af66fc99e Initial load duke parents: diff changeset	1574 }
a61af66fc99e Initial load duke parents: diff changeset	1575 }
a61af66fc99e Initial load duke parents: diff changeset	1576 }
a61af66fc99e Initial load duke parents: diff changeset	1577
a61af66fc99e Initial load duke parents: diff changeset	1578 //------------------------------check_safepts----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1579 // Given dominators, try to find loops with calls that must always be
a61af66fc99e Initial load duke parents: diff changeset	1580 // executed (call dominates loop tail). These loops do not need non-call
a61af66fc99e Initial load duke parents: diff changeset	1581 // safepoints (ncsfpt).
a61af66fc99e Initial load duke parents: diff changeset	1582 //
a61af66fc99e Initial load duke parents: diff changeset	1583 // A complication is that a safepoint in a inner loop may be needed
a61af66fc99e Initial load duke parents: diff changeset	1584 // by an outer loop. In the following, the inner loop sees it has a
a61af66fc99e Initial load duke parents: diff changeset	1585 // call (block 3) on every path from the head (block 2) to the
a61af66fc99e Initial load duke parents: diff changeset	1586 // backedge (arc 3->2). So it deletes the ncsfpt (non-call safepoint)
a61af66fc99e Initial load duke parents: diff changeset	1587 // in block 2, _but_ this leaves the outer loop without a safepoint.
a61af66fc99e Initial load duke parents: diff changeset	1588 //
a61af66fc99e Initial load duke parents: diff changeset	1589 // entry 0
a61af66fc99e Initial load duke parents: diff changeset	1590 // \|
a61af66fc99e Initial load duke parents: diff changeset	1591 // v
a61af66fc99e Initial load duke parents: diff changeset	1592 // outer 1,2 +->1
a61af66fc99e Initial load duke parents: diff changeset	1593 // \| \|
a61af66fc99e Initial load duke parents: diff changeset	1594 // \| v
a61af66fc99e Initial load duke parents: diff changeset	1595 // \| 2<---+ ncsfpt in 2
a61af66fc99e Initial load duke parents: diff changeset	1596 // \|_/\|\ \|
a61af66fc99e Initial load duke parents: diff changeset	1597 // \| v \|
a61af66fc99e Initial load duke parents: diff changeset	1598 // inner 2,3 / 3 \| call in 3
a61af66fc99e Initial load duke parents: diff changeset	1599 // / \| \|
a61af66fc99e Initial load duke parents: diff changeset	1600 // v +--+
a61af66fc99e Initial load duke parents: diff changeset	1601 // exit 4
a61af66fc99e Initial load duke parents: diff changeset	1602 //
a61af66fc99e Initial load duke parents: diff changeset	1603 //
a61af66fc99e Initial load duke parents: diff changeset	1604 // This method creates a list (_required_safept) of ncsfpt nodes that must
a61af66fc99e Initial load duke parents: diff changeset	1605 // be protected is created for each loop. When a ncsfpt maybe deleted, it
a61af66fc99e Initial load duke parents: diff changeset	1606 // is first looked for in the lists for the outer loops of the current loop.
a61af66fc99e Initial load duke parents: diff changeset	1607 //
a61af66fc99e Initial load duke parents: diff changeset	1608 // The insights into the problem:
a61af66fc99e Initial load duke parents: diff changeset	1609 // A) counted loops are okay
a61af66fc99e Initial load duke parents: diff changeset	1610 // B) innermost loops are okay (only an inner loop can delete
a61af66fc99e Initial load duke parents: diff changeset	1611 // a ncsfpt needed by an outer loop)
a61af66fc99e Initial load duke parents: diff changeset	1612 // C) a loop is immune from an inner loop deleting a safepoint
a61af66fc99e Initial load duke parents: diff changeset	1613 // if the loop has a call on the idom-path
a61af66fc99e Initial load duke parents: diff changeset	1614 // D) a loop is also immune if it has a ncsfpt (non-call safepoint) on the
a61af66fc99e Initial load duke parents: diff changeset	1615 // idom-path that is not in a nested loop
a61af66fc99e Initial load duke parents: diff changeset	1616 // E) otherwise, an ncsfpt on the idom-path that is nested in an inner
a61af66fc99e Initial load duke parents: diff changeset	1617 // loop needs to be prevented from deletion by an inner loop
a61af66fc99e Initial load duke parents: diff changeset	1618 //
a61af66fc99e Initial load duke parents: diff changeset	1619 // There are two analyses:
a61af66fc99e Initial load duke parents: diff changeset	1620 // 1) The first, and cheaper one, scans the loop body from
a61af66fc99e Initial load duke parents: diff changeset	1621 // tail to head following the idom (immediate dominator)
a61af66fc99e Initial load duke parents: diff changeset	1622 // chain, looking for the cases (C,D,E) above.
a61af66fc99e Initial load duke parents: diff changeset	1623 // Since inner loops are scanned before outer loops, there is summary
a61af66fc99e Initial load duke parents: diff changeset	1624 // information about inner loops. Inner loops can be skipped over
a61af66fc99e Initial load duke parents: diff changeset	1625 // when the tail of an inner loop is encountered.
a61af66fc99e Initial load duke parents: diff changeset	1626 //
a61af66fc99e Initial load duke parents: diff changeset	1627 // 2) The second, invoked if the first fails to find a call or ncsfpt on
a61af66fc99e Initial load duke parents: diff changeset	1628 // the idom path (which is rare), scans all predecessor control paths
a61af66fc99e Initial load duke parents: diff changeset	1629 // from the tail to the head, terminating a path when a call or sfpt
a61af66fc99e Initial load duke parents: diff changeset	1630 // is encountered, to find the ncsfpt's that are closest to the tail.
a61af66fc99e Initial load duke parents: diff changeset	1631 //
a61af66fc99e Initial load duke parents: diff changeset	1632 void IdealLoopTree::check_safepts(VectorSet &visited, Node_List &stack) {
a61af66fc99e Initial load duke parents: diff changeset	1633 // Bottom up traversal
a61af66fc99e Initial load duke parents: diff changeset	1634 IdealLoopTree* ch = _child;
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1635 if (_child) _child->check_safepts(visited, stack);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1636 if (_next) _next ->check_safepts(visited, stack);
0 a61af66fc99e Initial load duke parents: diff changeset	1637
a61af66fc99e Initial load duke parents: diff changeset	1638 if (!_head->is_CountedLoop() && !_has_sfpt && _parent != NULL && !_irreducible) {
a61af66fc99e Initial load duke parents: diff changeset	1639 bool has_call = false; // call on dom-path
a61af66fc99e Initial load duke parents: diff changeset	1640 bool has_local_ncsfpt = false; // ncsfpt on dom-path at this loop depth
a61af66fc99e Initial load duke parents: diff changeset	1641 Node* nonlocal_ncsfpt = NULL; // ncsfpt on dom-path at a deeper depth
a61af66fc99e Initial load duke parents: diff changeset	1642 // Scan the dom-path nodes from tail to head
a61af66fc99e Initial load duke parents: diff changeset	1643 for (Node* n = tail(); n != _head; n = _phase->idom(n)) {
a61af66fc99e Initial load duke parents: diff changeset	1644 if (n->is_Call() && n->as_Call()->guaranteed_safepoint()) {
a61af66fc99e Initial load duke parents: diff changeset	1645 has_call = true;
a61af66fc99e Initial load duke parents: diff changeset	1646 _has_sfpt = 1; // Then no need for a safept!
a61af66fc99e Initial load duke parents: diff changeset	1647 break;
a61af66fc99e Initial load duke parents: diff changeset	1648 } else if (n->Opcode() == Op_SafePoint) {
a61af66fc99e Initial load duke parents: diff changeset	1649 if (_phase->get_loop(n) == this) {
a61af66fc99e Initial load duke parents: diff changeset	1650 has_local_ncsfpt = true;
a61af66fc99e Initial load duke parents: diff changeset	1651 break;
a61af66fc99e Initial load duke parents: diff changeset	1652 }
a61af66fc99e Initial load duke parents: diff changeset	1653 if (nonlocal_ncsfpt == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1654 nonlocal_ncsfpt = n; // save the one closest to the tail
a61af66fc99e Initial load duke parents: diff changeset	1655 }
a61af66fc99e Initial load duke parents: diff changeset	1656 } else {
a61af66fc99e Initial load duke parents: diff changeset	1657 IdealLoopTree* nlpt = _phase->get_loop(n);
a61af66fc99e Initial load duke parents: diff changeset	1658 if (this != nlpt) {
a61af66fc99e Initial load duke parents: diff changeset	1659 // If at an inner loop tail, see if the inner loop has already
a61af66fc99e Initial load duke parents: diff changeset	1660 // recorded seeing a call on the dom-path (and stop.) If not,
a61af66fc99e Initial load duke parents: diff changeset	1661 // jump to the head of the inner loop.
a61af66fc99e Initial load duke parents: diff changeset	1662 assert(is_member(nlpt), "nested loop");
a61af66fc99e Initial load duke parents: diff changeset	1663 Node* tail = nlpt->_tail;
a61af66fc99e Initial load duke parents: diff changeset	1664 if (tail->in(0)->is_If()) tail = tail->in(0);
a61af66fc99e Initial load duke parents: diff changeset	1665 if (n == tail) {
a61af66fc99e Initial load duke parents: diff changeset	1666 // If inner loop has call on dom-path, so does outer loop
a61af66fc99e Initial load duke parents: diff changeset	1667 if (nlpt->_has_sfpt) {
a61af66fc99e Initial load duke parents: diff changeset	1668 has_call = true;
a61af66fc99e Initial load duke parents: diff changeset	1669 _has_sfpt = 1;
a61af66fc99e Initial load duke parents: diff changeset	1670 break;
a61af66fc99e Initial load duke parents: diff changeset	1671 }
a61af66fc99e Initial load duke parents: diff changeset	1672 // Skip to head of inner loop
a61af66fc99e Initial load duke parents: diff changeset	1673 assert(_phase->is_dominator(_head, nlpt->_head), "inner head dominated by outer head");
a61af66fc99e Initial load duke parents: diff changeset	1674 n = nlpt->_head;
a61af66fc99e Initial load duke parents: diff changeset	1675 }
a61af66fc99e Initial load duke parents: diff changeset	1676 }
a61af66fc99e Initial load duke parents: diff changeset	1677 }
a61af66fc99e Initial load duke parents: diff changeset	1678 }
a61af66fc99e Initial load duke parents: diff changeset	1679 // Record safept's that this loop needs preserved when an
a61af66fc99e Initial load duke parents: diff changeset	1680 // inner loop attempts to delete it's safepoints.
a61af66fc99e Initial load duke parents: diff changeset	1681 if (_child != NULL && !has_call && !has_local_ncsfpt) {
a61af66fc99e Initial load duke parents: diff changeset	1682 if (nonlocal_ncsfpt != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1683 if (_required_safept == NULL) _required_safept = new Node_List();
a61af66fc99e Initial load duke parents: diff changeset	1684 _required_safept->push(nonlocal_ncsfpt);
a61af66fc99e Initial load duke parents: diff changeset	1685 } else {
a61af66fc99e Initial load duke parents: diff changeset	1686 // Failed to find a suitable safept on the dom-path. Now use
a61af66fc99e Initial load duke parents: diff changeset	1687 // an all paths walk from tail to head, looking for safepoints to preserve.
a61af66fc99e Initial load duke parents: diff changeset	1688 allpaths_check_safepts(visited, stack);
a61af66fc99e Initial load duke parents: diff changeset	1689 }
a61af66fc99e Initial load duke parents: diff changeset	1690 }
a61af66fc99e Initial load duke parents: diff changeset	1691 }
a61af66fc99e Initial load duke parents: diff changeset	1692 }
a61af66fc99e Initial load duke parents: diff changeset	1693
a61af66fc99e Initial load duke parents: diff changeset	1694 //---------------------------is_deleteable_safept----------------------------
a61af66fc99e Initial load duke parents: diff changeset	1695 // Is safept not required by an outer loop?
a61af66fc99e Initial load duke parents: diff changeset	1696 bool PhaseIdealLoop::is_deleteable_safept(Node* sfpt) {
a61af66fc99e Initial load duke parents: diff changeset	1697 assert(sfpt->Opcode() == Op_SafePoint, "");
a61af66fc99e Initial load duke parents: diff changeset	1698 IdealLoopTree* lp = get_loop(sfpt)->_parent;
a61af66fc99e Initial load duke parents: diff changeset	1699 while (lp != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1700 Node_List* sfpts = lp->_required_safept;
a61af66fc99e Initial load duke parents: diff changeset	1701 if (sfpts != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1702 for (uint i = 0; i < sfpts->size(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1703 if (sfpt == sfpts->at(i))
a61af66fc99e Initial load duke parents: diff changeset	1704 return false;
a61af66fc99e Initial load duke parents: diff changeset	1705 }
a61af66fc99e Initial load duke parents: diff changeset	1706 }
a61af66fc99e Initial load duke parents: diff changeset	1707 lp = lp->_parent;
a61af66fc99e Initial load duke parents: diff changeset	1708 }
a61af66fc99e Initial load duke parents: diff changeset	1709 return true;
a61af66fc99e Initial load duke parents: diff changeset	1710 }
a61af66fc99e Initial load duke parents: diff changeset	1711
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1712 //---------------------------replace_parallel_iv-------------------------------
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1713 // Replace parallel induction variable (parallel to trip counter)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1714 void PhaseIdealLoop::replace_parallel_iv(IdealLoopTree *loop) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1715 assert(loop->_head->is_CountedLoop(), "");
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1716 CountedLoopNode *cl = loop->_head->as_CountedLoop();
3850 6987871cfb9b 7077439: Possible reference through NULL in loopPredicate.cpp:726 kvn parents: 3845 diff changeset	1717 if (!cl->is_valid_counted_loop())
6987871cfb9b 7077439: Possible reference through NULL in loopPredicate.cpp:726 kvn parents: 3845 diff changeset	1718 return; // skip malformed counted loop
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1719 Node *incr = cl->incr();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1720 if (incr == NULL)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1721 return; // Dead loop?
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1722 Node *init = cl->init_trip();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1723 Node *phi = cl->phi();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1724 int stride_con = cl->stride_con();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1725
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1726 // Visit all children, looking for Phis
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1727 for (DUIterator i = cl->outs(); cl->has_out(i); i++) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1728 Node *out = cl->out(i);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1729 // Look for other phis (secondary IVs). Skip dead ones
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1730 if (!out->is_Phi() \|\| out == phi \|\| !has_node(out))
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1731 continue;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1732 PhiNode* phi2 = out->as_Phi();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1733 Node *incr2 = phi2->in( LoopNode::LoopBackControl );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1734 // Look for induction variables of the form: X += constant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1735 if (phi2->region() != loop->_head \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1736 incr2->req() != 3 \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1737 incr2->in(1) != phi2 \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1738 incr2 == incr \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1739 incr2->Opcode() != Op_AddI \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1740 !incr2->in(2)->is_Con())
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1741 continue;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1742
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1743 // Check for parallel induction variable (parallel to trip counter)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1744 // via an affine function. In particular, count-down loops with
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1745 // count-up array indices are common. We only RCE references off
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1746 // the trip-counter, so we need to convert all these to trip-counter
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1747 // expressions.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1748 Node *init2 = phi2->in( LoopNode::EntryControl );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1749 int stride_con2 = incr2->in(2)->get_int();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1750
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1751 // The general case here gets a little tricky. We want to find the
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1752 // GCD of all possible parallel IV's and make a new IV using this
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1753 // GCD for the loop. Then all possible IVs are simple multiples of
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1754 // the GCD. In practice, this will cover very few extra loops.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1755 // Instead we require 'stride_con2' to be a multiple of 'stride_con',
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1756 // where +/-1 is the common case, but other integer multiples are
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1757 // also easy to handle.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1758 int ratio_con = stride_con2/stride_con;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1759
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1760 if ((ratio_con * stride_con) == stride_con2) { // Check for exact
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1761 #ifndef PRODUCT
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1762 if (TraceLoopOpts) {
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1763 tty->print("Parallel IV: %d ", phi2->_idx);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1764 loop->dump_head();
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1765 }
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1766 #endif
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1767 // Convert to using the trip counter. The parallel induction
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1768 // variable differs from the trip counter by a loop-invariant
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1769 // amount, the difference between their respective initial values.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1770 // It is scaled by the 'ratio_con'.
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1771 Node* ratio = _igvn.intcon(ratio_con);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1772 set_ctrl(ratio, C->root());
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1773 Node* ratio_init = new (C) MulINode(init, ratio);
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1774 _igvn.register_new_node_with_optimizer(ratio_init, init);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1775 set_early_ctrl(ratio_init);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1776 Node* diff = new (C) SubINode(init2, ratio_init);
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1777 _igvn.register_new_node_with_optimizer(diff, init2);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1778 set_early_ctrl(diff);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1779 Node* ratio_idx = new (C) MulINode(phi, ratio);
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1780 _igvn.register_new_node_with_optimizer(ratio_idx, phi);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1781 set_ctrl(ratio_idx, cl);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	1782 Node* add = new (C) AddINode(ratio_idx, diff);
3936 2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1783 _igvn.register_new_node_with_optimizer(add);
2c24ef16533d 7035946: Up to 15% regression on JDK 7 b136 vs b135 on specjvm2008.crypto.rsa on x64 kvn parents: 3850 diff changeset	1784 set_ctrl(add, cl);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1785 _igvn.replace_node( phi2, add );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1786 // Sometimes an induction variable is unused
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1787 if (add->outcnt() == 0) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1788 _igvn.remove_dead_node(add);
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1789 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1790 --i; // deleted this phi; rescan starting with next position
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1791 continue;
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1792 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1793 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1794 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1795
0 a61af66fc99e Initial load duke parents: diff changeset	1796 //------------------------------counted_loop-----------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1797 // Convert to counted loops where possible
a61af66fc99e Initial load duke parents: diff changeset	1798 void IdealLoopTree::counted_loop( PhaseIdealLoop *phase ) {
a61af66fc99e Initial load duke parents: diff changeset	1799
a61af66fc99e Initial load duke parents: diff changeset	1800 // For grins, set the inner-loop flag here
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1801 if (!_child) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1802 if (_head->is_Loop()) _head->as_Loop()->set_inner_loop();
0 a61af66fc99e Initial load duke parents: diff changeset	1803 }
a61af66fc99e Initial load duke parents: diff changeset	1804
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1805 if (_head->is_CountedLoop() \|\|
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1806 phase->is_counted_loop(_head, this)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1807 _has_sfpt = 1; // Indicate we do not need a safepoint here
a61af66fc99e Initial load duke parents: diff changeset	1808
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1809 // Look for safepoints to remove.
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1810 Node_List* sfpts = _safepts;
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1811 if (sfpts != NULL) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1812 for (uint i = 0; i < sfpts->size(); i++) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1813 Node* n = sfpts->at(i);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1814 assert(phase->get_loop(n) == this, "");
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1815 if (phase->is_deleteable_safept(n)) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1816 phase->lazy_replace(n, n->in(TypeFunc::Control));
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1817 }
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1818 }
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1819 }
0 a61af66fc99e Initial load duke parents: diff changeset	1820
a61af66fc99e Initial load duke parents: diff changeset	1821 // Look for induction variables
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1822 phase->replace_parallel_iv(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1823
a61af66fc99e Initial load duke parents: diff changeset	1824 } else if (_parent != NULL && !_irreducible) {
a61af66fc99e Initial load duke parents: diff changeset	1825 // Not a counted loop.
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1826 // Look for a safepoint on the idom-path.
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1827 Node* sfpt = tail();
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1828 for (; sfpt != _head; sfpt = phase->idom(sfpt)) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1829 if (sfpt->Opcode() == Op_SafePoint && phase->get_loop(sfpt) == this)
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1830 break; // Found one
0 a61af66fc99e Initial load duke parents: diff changeset	1831 }
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1832 // Delete other safepoints in this loop.
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1833 Node_List* sfpts = _safepts;
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1834 if (sfpts != NULL && sfpt != _head && sfpt->Opcode() == Op_SafePoint) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1835 for (uint i = 0; i < sfpts->size(); i++) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1836 Node* n = sfpts->at(i);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1837 assert(phase->get_loop(n) == this, "");
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1838 if (n != sfpt && phase->is_deleteable_safept(n)) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1839 phase->lazy_replace(n, n->in(TypeFunc::Control));
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1840 }
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	1841 }
0 a61af66fc99e Initial load duke parents: diff changeset	1842 }
a61af66fc99e Initial load duke parents: diff changeset	1843 }
a61af66fc99e Initial load duke parents: diff changeset	1844
a61af66fc99e Initial load duke parents: diff changeset	1845 // Recursively
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1846 if (_child) _child->counted_loop( phase );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1847 if (_next) _next ->counted_loop( phase );
0 a61af66fc99e Initial load duke parents: diff changeset	1848 }
a61af66fc99e Initial load duke parents: diff changeset	1849
a61af66fc99e Initial load duke parents: diff changeset	1850 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1851 //------------------------------dump_head--------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1852 // Dump 1 liner for loop header info
a61af66fc99e Initial load duke parents: diff changeset	1853 void IdealLoopTree::dump_head( ) const {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1854 for (uint i=0; i<_nest; i++)
0 a61af66fc99e Initial load duke parents: diff changeset	1855 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	1856 tty->print("Loop: N%d/N%d ",_head->_idx,_tail->_idx);
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1857 if (_irreducible) tty->print(" IRREDUCIBLE");
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1858 Node* entry = _head->in(LoopNode::EntryControl);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1859 if (LoopLimitCheck) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1860 Node* predicate = PhaseIdealLoop::find_predicate_insertion_point(entry, Deoptimization::Reason_loop_limit_check);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1861 if (predicate != NULL ) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1862 tty->print(" limit_check");
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1863 entry = entry->in(0)->in(0);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1864 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1865 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1866 if (UseLoopPredicate) {
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1867 entry = PhaseIdealLoop::find_predicate_insertion_point(entry, Deoptimization::Reason_predicate);
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	1868 if (entry != NULL) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1869 tty->print(" predicated");
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1870 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1871 }
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1872 if (_head->is_CountedLoop()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1873 CountedLoopNode *cl = _head->as_CountedLoop();
a61af66fc99e Initial load duke parents: diff changeset	1874 tty->print(" counted");
2465 3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1875
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1876 Node* init_n = cl->init_trip();
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1877 if (init_n != NULL && init_n->is_Con())
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1878 tty->print(" [%d,", cl->init_trip()->get_int());
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1879 else
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1880 tty->print(" [int,");
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1881 Node* limit_n = cl->limit();
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1882 if (limit_n != NULL && limit_n->is_Con())
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1883 tty->print("%d),", cl->limit()->get_int());
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1884 else
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1885 tty->print("int),");
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1886 int stride_con = cl->stride_con();
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1887 if (stride_con > 0) tty->print("+");
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1888 tty->print("%d", stride_con);
3af54845df98 7004555: Add new policy for one iteration loops kvn parents: 2445 diff changeset	1889
6614 006050192a5a 6340864: Implement vectorization optimizations in hotspot-server kvn parents: 6179 diff changeset	1890 tty->print(" (%d iters) ", (int)cl->profile_trip_cnt());
006050192a5a 6340864: Implement vectorization optimizations in hotspot-server kvn parents: 6179 diff changeset	1891
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1892 if (cl->is_pre_loop ()) tty->print(" pre" );
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1893 if (cl->is_main_loop()) tty->print(" main");
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1894 if (cl->is_post_loop()) tty->print(" post");
0 a61af66fc99e Initial load duke parents: diff changeset	1895 }
a61af66fc99e Initial load duke parents: diff changeset	1896 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1897 }
a61af66fc99e Initial load duke parents: diff changeset	1898
a61af66fc99e Initial load duke parents: diff changeset	1899 //------------------------------dump-------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	1900 // Dump loops by loop tree
a61af66fc99e Initial load duke parents: diff changeset	1901 void IdealLoopTree::dump( ) const {
a61af66fc99e Initial load duke parents: diff changeset	1902 dump_head();
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1903 if (_child) _child->dump();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1904 if (_next) _next ->dump();
0 a61af66fc99e Initial load duke parents: diff changeset	1905 }
a61af66fc99e Initial load duke parents: diff changeset	1906
a61af66fc99e Initial load duke parents: diff changeset	1907 #endif
a61af66fc99e Initial load duke parents: diff changeset	1908
367 194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1909 static void log_loop_tree(IdealLoopTree* root, IdealLoopTree* loop, CompileLog* log) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1910 if (loop == root) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1911 if (loop->_child != NULL) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1912 log->begin_head("loop_tree");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1913 log->end_head();
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1914 if( loop->_child ) log_loop_tree(root, loop->_child, log);
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1915 log->tail("loop_tree");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1916 assert(loop->_next == NULL, "what?");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1917 }
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1918 } else {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1919 Node* head = loop->_head;
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1920 log->begin_head("loop");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1921 log->print(" idx='%d' ", head->_idx);
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1922 if (loop->_irreducible) log->print("irreducible='1' ");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1923 if (head->is_Loop()) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1924 if (head->as_Loop()->is_inner_loop()) log->print("inner_loop='1' ");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1925 if (head->as_Loop()->is_partial_peel_loop()) log->print("partial_peel_loop='1' ");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1926 }
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1927 if (head->is_CountedLoop()) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1928 CountedLoopNode* cl = head->as_CountedLoop();
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1929 if (cl->is_pre_loop()) log->print("pre_loop='%d' ", cl->main_idx());
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1930 if (cl->is_main_loop()) log->print("main_loop='%d' ", cl->_idx);
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1931 if (cl->is_post_loop()) log->print("post_loop='%d' ", cl->main_idx());
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1932 }
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1933 log->end_head();
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1934 if( loop->_child ) log_loop_tree(root, loop->_child, log);
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1935 log->tail("loop");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1936 if( loop->_next ) log_loop_tree(root, loop->_next, log);
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1937 }
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1938 }
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	1939
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1940 //---------------------collect_potentially_useful_predicates-----------------------
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1941 // Helper function to collect potentially useful predicates to prevent them from
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1942 // being eliminated by PhaseIdealLoop::eliminate_useless_predicates
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1943 void PhaseIdealLoop::collect_potentially_useful_predicates(
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1944 IdealLoopTree * loop, Unique_Node_List &useful_predicates) {
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1945 if (loop->_child) { // child
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1946 collect_potentially_useful_predicates(loop->_child, useful_predicates);
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1947 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1948
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1949 // self (only loops that we can apply loop predication may use their predicates)
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1950 if (loop->_head->is_Loop() &&
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1951 !loop->_irreducible &&
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1952 !loop->tail()->is_top()) {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1953 LoopNode* lpn = loop->_head->as_Loop();
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1954 Node* entry = lpn->in(LoopNode::EntryControl);
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1955 Node* predicate_proj = find_predicate(entry); // loop_limit_check first
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1956 if (predicate_proj != NULL ) { // right pattern that can be used by loop predication
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1957 assert(entry->in(0)->in(1)->in(1)->Opcode() == Op_Opaque1, "must be");
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1958 useful_predicates.push(entry->in(0)->in(1)->in(1)); // good one
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1959 entry = entry->in(0)->in(0);
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1960 }
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1961 predicate_proj = find_predicate(entry); // Predicate
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1962 if (predicate_proj != NULL ) {
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1963 useful_predicates.push(entry->in(0)->in(1)->in(1)); // good one
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1964 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1965 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1966
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1967 if (loop->_next) { // sibling
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1968 collect_potentially_useful_predicates(loop->_next, useful_predicates);
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1969 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1970 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1971
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1972 //------------------------eliminate_useless_predicates-----------------------------
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1973 // Eliminate all inserted predicates if they could not be used by loop predication.
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1974 // Note: it will also eliminates loop limits check predicate since it also uses
bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	1975 // Opaque1 node (see Parse::add_predicate()).
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1976 void PhaseIdealLoop::eliminate_useless_predicates() {
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1977 if (C->predicate_count() == 0)
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	1978 return; // no predicate left
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1979
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1980 Unique_Node_List useful_predicates; // to store useful predicates
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1981 if (C->has_loops()) {
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1982 collect_potentially_useful_predicates(_ltree_root->_child, useful_predicates);
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1983 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1984
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1985 for (int i = C->predicate_count(); i > 0; i--) {
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1986 Node * n = C->predicate_opaque1_node(i-1);
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1987 assert(n->Opcode() == Op_Opaque1, "must be");
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1988 if (!useful_predicates.member(n)) { // not in the useful list
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1989 _igvn.replace_node(n, n->in(1));
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1990 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1991 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1992 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	1993
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1994 //------------------------process_expensive_nodes-----------------------------
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1995 // Expensive nodes have their control input set to prevent the GVN
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1996 // from commoning them and as a result forcing the resulting node to
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1997 // be in a more frequent path. Use CFG information here, to change the
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1998 // control inputs so that some expensive nodes can be commoned while
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	1999 // not executed more frequently.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2000 bool PhaseIdealLoop::process_expensive_nodes() {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2001 assert(OptimizeExpensiveOps, "optimization off?");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2002
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2003 // Sort nodes to bring similar nodes together
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2004 C->sort_expensive_nodes();
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2005
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2006 bool progress = false;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2007
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2008 for (int i = 0; i < C->expensive_count(); ) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2009 Node* n = C->expensive_node(i);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2010 int start = i;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2011 // Find nodes similar to n
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2012 i++;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2013 for (; i < C->expensive_count() && Compile::cmp_expensive_nodes(n, C->expensive_node(i)) == 0; i++);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2014 int end = i;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2015 // And compare them two by two
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2016 for (int j = start; j < end; j++) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2017 Node* n1 = C->expensive_node(j);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2018 if (is_node_unreachable(n1)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2019 continue;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2020 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2021 for (int k = j+1; k < end; k++) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2022 Node* n2 = C->expensive_node(k);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2023 if (is_node_unreachable(n2)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2024 continue;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2025 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2026
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2027 assert(n1 != n2, "should be pair of nodes");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2028
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2029 Node* c1 = n1->in(0);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2030 Node* c2 = n2->in(0);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2031
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2032 Node* parent_c1 = c1;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2033 Node* parent_c2 = c2;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2034
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2035 // The call to get_early_ctrl_for_expensive() moves the
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2036 // expensive nodes up but stops at loops that are in a if
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2037 // branch. See whether we can exit the loop and move above the
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2038 // If.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2039 if (c1->is_Loop()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2040 parent_c1 = c1->in(1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2041 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2042 if (c2->is_Loop()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2043 parent_c2 = c2->in(1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2044 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2045
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2046 if (parent_c1 == parent_c2) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2047 _igvn._worklist.push(n1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2048 _igvn._worklist.push(n2);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2049 continue;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2050 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2051
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2052 // Look for identical expensive node up the dominator chain.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2053 if (is_dominator(c1, c2)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2054 c2 = c1;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2055 } else if (is_dominator(c2, c1)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2056 c1 = c2;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2057 } else if (parent_c1->is_Proj() && parent_c1->in(0)->is_If() &&
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2058 parent_c2->is_Proj() && parent_c1->in(0) == parent_c2->in(0)) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2059 // Both branches have the same expensive node so move it up
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2060 // before the if.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2061 c1 = c2 = idom(parent_c1->in(0));
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2062 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2063 // Do the actual moves
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2064 if (n1->in(0) != c1) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2065 _igvn.hash_delete(n1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2066 n1->set_req(0, c1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2067 _igvn.hash_insert(n1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2068 _igvn._worklist.push(n1);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2069 progress = true;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2070 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2071 if (n2->in(0) != c2) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2072 _igvn.hash_delete(n2);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2073 n2->set_req(0, c2);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2074 _igvn.hash_insert(n2);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2075 _igvn._worklist.push(n2);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2076 progress = true;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2077 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2078 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2079 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2080 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2081
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2082 return progress;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2083 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2084
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2085
0 a61af66fc99e Initial load duke parents: diff changeset	2086 //=============================================================================
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2087 //----------------------------build_and_optimize-------------------------------
0 a61af66fc99e Initial load duke parents: diff changeset	2088 // Create a PhaseLoop. Build the ideal Loop tree. Map each Ideal Node to
a61af66fc99e Initial load duke parents: diff changeset	2089 // its corresponding LoopNode. If 'optimize' is true, do some loop cleanups.
4064 670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2090 void PhaseIdealLoop::build_and_optimize(bool do_split_ifs, bool skip_loop_opts) {
2248 194c9fdee631 7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1 kvn parents: 1972 diff changeset	2091 ResourceMark rm;
194c9fdee631 7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1 kvn parents: 1972 diff changeset	2092
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2093 int old_progress = C->major_progress();
2403 1927db75dd85 7024475: loop doesn't terminate when compiled never parents: 2383 diff changeset	2094 uint orig_worklist_size = _igvn._worklist.size();
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2095
0 a61af66fc99e Initial load duke parents: diff changeset	2096 // Reset major-progress flag for the driver's heuristics
a61af66fc99e Initial load duke parents: diff changeset	2097 C->clear_major_progress();
a61af66fc99e Initial load duke parents: diff changeset	2098
a61af66fc99e Initial load duke parents: diff changeset	2099 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2100 // Capture for later assert
a61af66fc99e Initial load duke parents: diff changeset	2101 uint unique = C->unique();
a61af66fc99e Initial load duke parents: diff changeset	2102 _loop_invokes++;
a61af66fc99e Initial load duke parents: diff changeset	2103 _loop_work += unique;
a61af66fc99e Initial load duke parents: diff changeset	2104 #endif
a61af66fc99e Initial load duke parents: diff changeset	2105
a61af66fc99e Initial load duke parents: diff changeset	2106 // True if the method has at least 1 irreducible loop
a61af66fc99e Initial load duke parents: diff changeset	2107 _has_irreducible_loops = false;
a61af66fc99e Initial load duke parents: diff changeset	2108
a61af66fc99e Initial load duke parents: diff changeset	2109 _created_loop_node = false;
a61af66fc99e Initial load duke parents: diff changeset	2110
a61af66fc99e Initial load duke parents: diff changeset	2111 Arena *a = Thread::current()->resource_area();
a61af66fc99e Initial load duke parents: diff changeset	2112 VectorSet visited(a);
a61af66fc99e Initial load duke parents: diff changeset	2113 // Pre-grow the mapping from Nodes to IdealLoopTrees.
a61af66fc99e Initial load duke parents: diff changeset	2114 _nodes.map(C->unique(), NULL);
a61af66fc99e Initial load duke parents: diff changeset	2115 memset(_nodes.adr(), 0, wordSize * C->unique());
a61af66fc99e Initial load duke parents: diff changeset	2116
a61af66fc99e Initial load duke parents: diff changeset	2117 // Pre-build the top-level outermost loop tree entry
a61af66fc99e Initial load duke parents: diff changeset	2118 _ltree_root = new IdealLoopTree( this, C->root(), C->root() );
a61af66fc99e Initial load duke parents: diff changeset	2119 // Do not need a safepoint at the top level
a61af66fc99e Initial load duke parents: diff changeset	2120 _ltree_root->_has_sfpt = 1;
a61af66fc99e Initial load duke parents: diff changeset	2121
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2122 // Initialize Dominators.
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2123 // Checked in clone_loop_predicate() during beautify_loops().
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2124 _idom_size = 0;
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2125 _idom = NULL;
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2126 _dom_depth = NULL;
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2127 _dom_stk = NULL;
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2128
0 a61af66fc99e Initial load duke parents: diff changeset	2129 // Empty pre-order array
a61af66fc99e Initial load duke parents: diff changeset	2130 allocate_preorders();
a61af66fc99e Initial load duke parents: diff changeset	2131
a61af66fc99e Initial load duke parents: diff changeset	2132 // Build a loop tree on the fly. Build a mapping from CFG nodes to
a61af66fc99e Initial load duke parents: diff changeset	2133 // IdealLoopTree entries. Data nodes are NOT walked.
a61af66fc99e Initial load duke parents: diff changeset	2134 build_loop_tree();
a61af66fc99e Initial load duke parents: diff changeset	2135 // Check for bailout, and return
a61af66fc99e Initial load duke parents: diff changeset	2136 if (C->failing()) {
a61af66fc99e Initial load duke parents: diff changeset	2137 return;
a61af66fc99e Initial load duke parents: diff changeset	2138 }
a61af66fc99e Initial load duke parents: diff changeset	2139
a61af66fc99e Initial load duke parents: diff changeset	2140 // No loops after all
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2141 if( !_ltree_root->_child && !_verify_only ) C->set_has_loops(false);
0 a61af66fc99e Initial load duke parents: diff changeset	2142
a61af66fc99e Initial load duke parents: diff changeset	2143 // There should always be an outer loop containing the Root and Return nodes.
a61af66fc99e Initial load duke parents: diff changeset	2144 // If not, we have a degenerate empty program. Bail out in this case.
a61af66fc99e Initial load duke parents: diff changeset	2145 if (!has_node(C->root())) {
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2146 if (!_verify_only) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2147 C->clear_major_progress();
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2148 C->record_method_not_compilable("empty program detected during loop optimization");
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2149 }
0 a61af66fc99e Initial load duke parents: diff changeset	2150 return;
a61af66fc99e Initial load duke parents: diff changeset	2151 }
a61af66fc99e Initial load duke parents: diff changeset	2152
a61af66fc99e Initial load duke parents: diff changeset	2153 // Nothing to do, so get out
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2154 bool stop_early = !C->has_loops() && !skip_loop_opts && !do_split_ifs && !_verify_me && !_verify_only;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2155 bool do_expensive_nodes = C->should_optimize_expensive_nodes(_igvn);
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2156 if (stop_early && !do_expensive_nodes) {
0 a61af66fc99e Initial load duke parents: diff changeset	2157 _igvn.optimize(); // Cleanup NeverBranches
a61af66fc99e Initial load duke parents: diff changeset	2158 return;
a61af66fc99e Initial load duke parents: diff changeset	2159 }
a61af66fc99e Initial load duke parents: diff changeset	2160
a61af66fc99e Initial load duke parents: diff changeset	2161 // Set loop nesting depth
a61af66fc99e Initial load duke parents: diff changeset	2162 _ltree_root->set_nest( 0 );
a61af66fc99e Initial load duke parents: diff changeset	2163
a61af66fc99e Initial load duke parents: diff changeset	2164 // Split shared headers and insert loop landing pads.
a61af66fc99e Initial load duke parents: diff changeset	2165 // Do not bother doing this on the Root loop of course.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2166 if( !_verify_me && !_verify_only && _ltree_root->_child ) {
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8868 diff changeset	2167 C->print_method(PHASE_BEFORE_BEAUTIFY_LOOPS, 3);
0 a61af66fc99e Initial load duke parents: diff changeset	2168 if( _ltree_root->_child->beautify_loops( this ) ) {
a61af66fc99e Initial load duke parents: diff changeset	2169 // Re-build loop tree!
a61af66fc99e Initial load duke parents: diff changeset	2170 _ltree_root->_child = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2171 _nodes.clear();
a61af66fc99e Initial load duke parents: diff changeset	2172 reallocate_preorders();
a61af66fc99e Initial load duke parents: diff changeset	2173 build_loop_tree();
a61af66fc99e Initial load duke parents: diff changeset	2174 // Check for bailout, and return
a61af66fc99e Initial load duke parents: diff changeset	2175 if (C->failing()) {
a61af66fc99e Initial load duke parents: diff changeset	2176 return;
a61af66fc99e Initial load duke parents: diff changeset	2177 }
a61af66fc99e Initial load duke parents: diff changeset	2178 // Reset loop nesting depth
a61af66fc99e Initial load duke parents: diff changeset	2179 _ltree_root->set_nest( 0 );
222 2a1a77d3458f 6718676: putback for 6604014 is incomplete never parents: 169 diff changeset	2180
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 8868 diff changeset	2181 C->print_method(PHASE_AFTER_BEAUTIFY_LOOPS, 3);
0 a61af66fc99e Initial load duke parents: diff changeset	2182 }
a61af66fc99e Initial load duke parents: diff changeset	2183 }
a61af66fc99e Initial load duke parents: diff changeset	2184
a61af66fc99e Initial load duke parents: diff changeset	2185 // Build Dominators for elision of NULL checks & loop finding.
a61af66fc99e Initial load duke parents: diff changeset	2186 // Since nodes do not have a slot for immediate dominator, make
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	2187 // a persistent side array for that info indexed on node->_idx.
0 a61af66fc99e Initial load duke parents: diff changeset	2188 _idom_size = C->unique();
a61af66fc99e Initial load duke parents: diff changeset	2189 _idom = NEW_RESOURCE_ARRAY( Node*, _idom_size );
a61af66fc99e Initial load duke parents: diff changeset	2190 _dom_depth = NEW_RESOURCE_ARRAY( uint, _idom_size );
a61af66fc99e Initial load duke parents: diff changeset	2191 _dom_stk = NULL; // Allocated on demand in recompute_dom_depth
a61af66fc99e Initial load duke parents: diff changeset	2192 memset( _dom_depth, 0, _idom_size * sizeof(uint) );
a61af66fc99e Initial load duke parents: diff changeset	2193
a61af66fc99e Initial load duke parents: diff changeset	2194 Dominators();
a61af66fc99e Initial load duke parents: diff changeset	2195
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2196 if (!_verify_only) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2197 // As a side effect, Dominators removed any unreachable CFG paths
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2198 // into RegionNodes. It doesn't do this test against Root, so
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2199 // we do it here.
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2200 for( uint i = 1; i < C->root()->req(); i++ ) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2201 if( !_nodes[C->root()->in(i)->_idx] ) { // Dead path into Root?
6144 5e990493719e 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node, int, Node) where applicable kvn parents: 4862 diff changeset	2202 _igvn.delete_input_of(C->root(), i);
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2203 i--; // Rerun same iteration on compressed edges
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2204 }
0 a61af66fc99e Initial load duke parents: diff changeset	2205 }
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2206
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2207 // Given dominators, try to find inner loops with calls that must
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2208 // always be executed (call dominates loop tail). These loops do
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2209 // not need a separate safepoint.
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2210 Node_List cisstack(a);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2211 _ltree_root->check_safepts(visited, cisstack);
0 a61af66fc99e Initial load duke parents: diff changeset	2212 }
a61af66fc99e Initial load duke parents: diff changeset	2213
a61af66fc99e Initial load duke parents: diff changeset	2214 // Walk the DATA nodes and place into loops. Find earliest control
a61af66fc99e Initial load duke parents: diff changeset	2215 // node. For CFG nodes, the _nodes array starts out and remains
a61af66fc99e Initial load duke parents: diff changeset	2216 // holding the associated IdealLoopTree pointer. For DATA nodes, the
a61af66fc99e Initial load duke parents: diff changeset	2217 // _nodes array holds the earliest legal controlling CFG node.
a61af66fc99e Initial load duke parents: diff changeset	2218
a61af66fc99e Initial load duke parents: diff changeset	2219 // Allocate stack with enough space to avoid frequent realloc
a61af66fc99e Initial load duke parents: diff changeset	2220 int stack_size = (C->unique() >> 1) + 16; // (unique>>1)+16 from Java2D stats
a61af66fc99e Initial load duke parents: diff changeset	2221 Node_Stack nstack( a, stack_size );
a61af66fc99e Initial load duke parents: diff changeset	2222
a61af66fc99e Initial load duke parents: diff changeset	2223 visited.Clear();
a61af66fc99e Initial load duke parents: diff changeset	2224 Node_List worklist(a);
a61af66fc99e Initial load duke parents: diff changeset	2225 // Don't need C->root() on worklist since
a61af66fc99e Initial load duke parents: diff changeset	2226 // it will be processed among C->top() inputs
a61af66fc99e Initial load duke parents: diff changeset	2227 worklist.push( C->top() );
a61af66fc99e Initial load duke parents: diff changeset	2228 visited.set( C->top()->_idx ); // Set C->top() as visited now
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2229 build_loop_early( visited, worklist, nstack );
0 a61af66fc99e Initial load duke parents: diff changeset	2230
a61af66fc99e Initial load duke parents: diff changeset	2231 // Given early legal placement, try finding counted loops. This placement
a61af66fc99e Initial load duke parents: diff changeset	2232 // is good enough to discover most loop invariants.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2233 if( !_verify_me && !_verify_only )
0 a61af66fc99e Initial load duke parents: diff changeset	2234 _ltree_root->counted_loop( this );
a61af66fc99e Initial load duke parents: diff changeset	2235
a61af66fc99e Initial load duke parents: diff changeset	2236 // Find latest loop placement. Find ideal loop placement.
a61af66fc99e Initial load duke parents: diff changeset	2237 visited.Clear();
a61af66fc99e Initial load duke parents: diff changeset	2238 init_dom_lca_tags();
a61af66fc99e Initial load duke parents: diff changeset	2239 // Need C->root() on worklist when processing outs
a61af66fc99e Initial load duke parents: diff changeset	2240 worklist.push( C->root() );
a61af66fc99e Initial load duke parents: diff changeset	2241 NOT_PRODUCT( C->verify_graph_edges(); )
a61af66fc99e Initial load duke parents: diff changeset	2242 worklist.push( C->top() );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2243 build_loop_late( visited, worklist, nstack );
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2244
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2245 if (_verify_only) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2246 // restore major progress flag
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2247 for (int i = 0; i < old_progress; i++)
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2248 C->set_major_progress();
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2249 assert(C->unique() == unique, "verification mode made Nodes? ? ?");
2403 1927db75dd85 7024475: loop doesn't terminate when compiled never parents: 2383 diff changeset	2250 assert(_igvn._worklist.size() == orig_worklist_size, "shouldn't push anything");
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2251 return;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2252 }
0 a61af66fc99e Initial load duke parents: diff changeset	2253
8868 30f42e691e70 8004640: C2 assert failure in memnode.cpp: NULL+offs not RAW address kvn parents: 8048 diff changeset	2254 // clear out the dead code after build_loop_late
30f42e691e70 8004640: C2 assert failure in memnode.cpp: NULL+offs not RAW address kvn parents: 8048 diff changeset	2255 while (_deadlist.size()) {
30f42e691e70 8004640: C2 assert failure in memnode.cpp: NULL+offs not RAW address kvn parents: 8048 diff changeset	2256 _igvn.remove_globally_dead_node(_deadlist.pop());
30f42e691e70 8004640: C2 assert failure in memnode.cpp: NULL+offs not RAW address kvn parents: 8048 diff changeset	2257 }
30f42e691e70 8004640: C2 assert failure in memnode.cpp: NULL+offs not RAW address kvn parents: 8048 diff changeset	2258
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2259 if (stop_early) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2260 assert(do_expensive_nodes, "why are we here?");
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2261 if (process_expensive_nodes()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2262 // If we made some progress when processing expensive nodes then
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2263 // the IGVN may modify the graph in a way that will allow us to
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2264 // make some more progress: we need to try processing expensive
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2265 // nodes again.
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2266 C->set_major_progress();
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2267 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2268 _igvn.optimize();
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2269 return;
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2270 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2271
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2272 // Some parser-inserted loop predicates could never be used by loop
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2273 // predication or they were moved away from loop during some optimizations.
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2274 // For example, peeling. Eliminate them before next loop optimizations.
3345 bad7ecd0b6ed 5091921: Sign flip issues in loop optimizer kvn parents: 2465 diff changeset	2275 if (UseLoopPredicate \|\| LoopLimitCheck) {
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2276 eliminate_useless_predicates();
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2277 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2278
0 a61af66fc99e Initial load duke parents: diff changeset	2279 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2280 C->verify_graph_edges();
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	2281 if (_verify_me) { // Nested verify pass?
0 a61af66fc99e Initial load duke parents: diff changeset	2282 // Check to see if the verify mode is broken
a61af66fc99e Initial load duke parents: diff changeset	2283 assert(C->unique() == unique, "non-optimize mode made Nodes? ? ?");
a61af66fc99e Initial load duke parents: diff changeset	2284 return;
a61af66fc99e Initial load duke parents: diff changeset	2285 }
2383 9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	2286 if(VerifyLoopOptimizations) verify();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	2287 if(TraceLoopOpts && C->has_loops()) {
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	2288 _ltree_root->dump();
9dc311b8473e 7008866: Missing loop predicate for loop with multiple entries kvn parents: 2248 diff changeset	2289 }
0 a61af66fc99e Initial load duke parents: diff changeset	2290 #endif
a61af66fc99e Initial load duke parents: diff changeset	2291
4064 670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2292 if (skip_loop_opts) {
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2293 // Cleanup any modified bits
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2294 _igvn.optimize();
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2295
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2296 if (C->log() != NULL) {
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2297 log_loop_tree(_ltree_root, _ltree_root, C->log());
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2298 }
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2299 return;
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2300 }
670a74b863fc 7107042: assert(no_dead_loop) failed: dead loop detected kvn parents: 3936 diff changeset	2301
0 a61af66fc99e Initial load duke parents: diff changeset	2302 if (ReassociateInvariants) {
a61af66fc99e Initial load duke parents: diff changeset	2303 // Reassociate invariants and prep for split_thru_phi
a61af66fc99e Initial load duke parents: diff changeset	2304 for (LoopTreeIterator iter(_ltree_root); !iter.done(); iter.next()) {
a61af66fc99e Initial load duke parents: diff changeset	2305 IdealLoopTree* lpt = iter.current();
a61af66fc99e Initial load duke parents: diff changeset	2306 if (!lpt->is_counted() \|\| !lpt->is_inner()) continue;
a61af66fc99e Initial load duke parents: diff changeset	2307
a61af66fc99e Initial load duke parents: diff changeset	2308 lpt->reassociate_invariants(this);
a61af66fc99e Initial load duke parents: diff changeset	2309
a61af66fc99e Initial load duke parents: diff changeset	2310 // Because RCE opportunities can be masked by split_thru_phi,
a61af66fc99e Initial load duke parents: diff changeset	2311 // look for RCE candidates and inhibit split_thru_phi
a61af66fc99e Initial load duke parents: diff changeset	2312 // on just their loop-phi's for this pass of loop opts
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2313 if (SplitIfBlocks && do_split_ifs) {
0 a61af66fc99e Initial load duke parents: diff changeset	2314 if (lpt->policy_range_check(this)) {
39 76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2315 lpt->_rce_candidate = 1; // = true
0 a61af66fc99e Initial load duke parents: diff changeset	2316 }
a61af66fc99e Initial load duke parents: diff changeset	2317 }
a61af66fc99e Initial load duke parents: diff changeset	2318 }
a61af66fc99e Initial load duke parents: diff changeset	2319 }
a61af66fc99e Initial load duke parents: diff changeset	2320
a61af66fc99e Initial load duke parents: diff changeset	2321 // Check for aggressive application of split-if and other transforms
a61af66fc99e Initial load duke parents: diff changeset	2322 // that require basic-block info (like cloning through Phi's)
a61af66fc99e Initial load duke parents: diff changeset	2323 if( SplitIfBlocks && do_split_ifs ) {
a61af66fc99e Initial load duke parents: diff changeset	2324 visited.Clear();
a61af66fc99e Initial load duke parents: diff changeset	2325 split_if_with_blocks( visited, nstack );
a61af66fc99e Initial load duke parents: diff changeset	2326 NOT_PRODUCT( if( VerifyLoopOptimizations ) verify(); );
a61af66fc99e Initial load duke parents: diff changeset	2327 }
a61af66fc99e Initial load duke parents: diff changeset	2328
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2329 if (!C->major_progress() && do_expensive_nodes && process_expensive_nodes()) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2330 C->set_major_progress();
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2331 }
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	2332
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2333 // Perform loop predication before iteration splitting
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2334 if (C->has_loops() && !C->major_progress() && (C->predicate_count() > 0)) {
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2335 _ltree_root->_child->loop_predication(this);
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2336 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2337
1763 d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2338 if (OptimizeFill && UseLoopPredicate && C->has_loops() && !C->major_progress()) {
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2339 if (do_intrinsify_fill()) {
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2340 C->set_major_progress();
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2341 }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2342 }
d6f45b55c972 4809552: Optimize Arrays.fill(...) never parents: 1621 diff changeset	2343
0 a61af66fc99e Initial load duke parents: diff changeset	2344 // Perform iteration-splitting on inner loops. Split iterations to avoid
a61af66fc99e Initial load duke parents: diff changeset	2345 // range checks or one-shot null checks.
a61af66fc99e Initial load duke parents: diff changeset	2346
a61af66fc99e Initial load duke parents: diff changeset	2347 // If split-if's didn't hack the graph too bad (no CFG changes)
a61af66fc99e Initial load duke parents: diff changeset	2348 // then do loop opts.
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2349 if (C->has_loops() && !C->major_progress()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2350 memset( worklist.adr(), 0, worklist.Size()sizeof(Node) );
a61af66fc99e Initial load duke parents: diff changeset	2351 _ltree_root->_child->iteration_split( this, worklist );
a61af66fc99e Initial load duke parents: diff changeset	2352 // No verify after peeling! GCM has hoisted code out of the loop.
a61af66fc99e Initial load duke parents: diff changeset	2353 // After peeling, the hoisted code could sink inside the peeled area.
a61af66fc99e Initial load duke parents: diff changeset	2354 // The peeling code does not try to recompute the best location for
a61af66fc99e Initial load duke parents: diff changeset	2355 // all the code before the peeled area, so the verify pass will always
a61af66fc99e Initial load duke parents: diff changeset	2356 // complain about it.
a61af66fc99e Initial load duke parents: diff changeset	2357 }
a61af66fc99e Initial load duke parents: diff changeset	2358 // Do verify graph edges in any case
a61af66fc99e Initial load duke parents: diff changeset	2359 NOT_PRODUCT( C->verify_graph_edges(); );
a61af66fc99e Initial load duke parents: diff changeset	2360
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	2361 if (!do_split_ifs) {
0 a61af66fc99e Initial load duke parents: diff changeset	2362 // We saw major progress in Split-If to get here. We forced a
a61af66fc99e Initial load duke parents: diff changeset	2363 // pass with unrolling and not split-if, however more split-if's
a61af66fc99e Initial load duke parents: diff changeset	2364 // might make progress. If the unrolling didn't make progress
a61af66fc99e Initial load duke parents: diff changeset	2365 // then the major-progress flag got cleared and we won't try
a61af66fc99e Initial load duke parents: diff changeset	2366 // another round of Split-If. In particular the ever-common
a61af66fc99e Initial load duke parents: diff changeset	2367 // instance-of/check-cast pattern requires at least 2 rounds of
a61af66fc99e Initial load duke parents: diff changeset	2368 // Split-If to clear out.
a61af66fc99e Initial load duke parents: diff changeset	2369 C->set_major_progress();
a61af66fc99e Initial load duke parents: diff changeset	2370 }
a61af66fc99e Initial load duke parents: diff changeset	2371
a61af66fc99e Initial load duke parents: diff changeset	2372 // Repeat loop optimizations if new loops were seen
a61af66fc99e Initial load duke parents: diff changeset	2373 if (created_loop_node()) {
a61af66fc99e Initial load duke parents: diff changeset	2374 C->set_major_progress();
a61af66fc99e Initial load duke parents: diff changeset	2375 }
a61af66fc99e Initial load duke parents: diff changeset	2376
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2377 // Keep loop predicates and perform optimizations with them
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2378 // until no more loop optimizations could be done.
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2379 // After that switch predicates off and do more loop optimizations.
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2380 if (!C->major_progress() && (C->predicate_count() > 0)) {
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2381 C->cleanup_loop_predicates(_igvn);
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2382 #ifndef PRODUCT
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2383 if (TraceLoopOpts) {
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2384 tty->print_cr("PredicatesOff");
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2385 }
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2386 #endif
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2387 C->set_major_progress();
08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2388 }
0 a61af66fc99e Initial load duke parents: diff changeset	2389
2445 08eb13460b3a 7004535: Clone loop predicate during loop unswitch kvn parents: 2403 diff changeset	2390 // Convert scalar to superword operations at the end of all loop opts.
0 a61af66fc99e Initial load duke parents: diff changeset	2391 if (UseSuperWord && C->has_loops() && !C->major_progress()) {
a61af66fc99e Initial load duke parents: diff changeset	2392 // SuperWord transform
a61af66fc99e Initial load duke parents: diff changeset	2393 SuperWord sw(this);
a61af66fc99e Initial load duke parents: diff changeset	2394 for (LoopTreeIterator iter(_ltree_root); !iter.done(); iter.next()) {
a61af66fc99e Initial load duke parents: diff changeset	2395 IdealLoopTree* lpt = iter.current();
a61af66fc99e Initial load duke parents: diff changeset	2396 if (lpt->is_counted()) {
a61af66fc99e Initial load duke parents: diff changeset	2397 sw.transform_loop(lpt);
a61af66fc99e Initial load duke parents: diff changeset	2398 }
a61af66fc99e Initial load duke parents: diff changeset	2399 }
a61af66fc99e Initial load duke parents: diff changeset	2400 }
a61af66fc99e Initial load duke parents: diff changeset	2401
a61af66fc99e Initial load duke parents: diff changeset	2402 // Cleanup any modified bits
a61af66fc99e Initial load duke parents: diff changeset	2403 _igvn.optimize();
a61af66fc99e Initial load duke parents: diff changeset	2404
367 194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2405 // disable assert until issue with split_flow_path is resolved (6742111)
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2406 // assert(!_has_irreducible_loops \|\| C->parsed_irreducible_loop() \|\| C->is_osr_compilation(),
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2407 // "shouldn't introduce irreducible loops");
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2408
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2409 if (C->log() != NULL) {
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2410 log_loop_tree(_ltree_root, _ltree_root, C->log());
194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	2411 }
0 a61af66fc99e Initial load duke parents: diff changeset	2412 }
a61af66fc99e Initial load duke parents: diff changeset	2413
a61af66fc99e Initial load duke parents: diff changeset	2414 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2415 //------------------------------print_statistics-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2416 int PhaseIdealLoop::_loop_invokes=0;// Count of PhaseIdealLoop invokes
a61af66fc99e Initial load duke parents: diff changeset	2417 int PhaseIdealLoop::_loop_work=0; // Sum of PhaseIdealLoop x unique
a61af66fc99e Initial load duke parents: diff changeset	2418 void PhaseIdealLoop::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	2419 tty->print_cr("PhaseIdealLoop=%d, sum _unique=%d", _loop_invokes, _loop_work);
a61af66fc99e Initial load duke parents: diff changeset	2420 }
a61af66fc99e Initial load duke parents: diff changeset	2421
a61af66fc99e Initial load duke parents: diff changeset	2422 //------------------------------verify-----------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2423 // Build a verify-only PhaseIdealLoop, and see that it agrees with me.
a61af66fc99e Initial load duke parents: diff changeset	2424 static int fail; // debug only, so its multi-thread dont care
a61af66fc99e Initial load duke parents: diff changeset	2425 void PhaseIdealLoop::verify() const {
a61af66fc99e Initial load duke parents: diff changeset	2426 int old_progress = C->major_progress();
a61af66fc99e Initial load duke parents: diff changeset	2427 ResourceMark rm;
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2428 PhaseIdealLoop loop_verify( _igvn, this );
0 a61af66fc99e Initial load duke parents: diff changeset	2429 VectorSet visited(Thread::current()->resource_area());
a61af66fc99e Initial load duke parents: diff changeset	2430
a61af66fc99e Initial load duke parents: diff changeset	2431 fail = 0;
a61af66fc99e Initial load duke parents: diff changeset	2432 verify_compare( C->root(), &loop_verify, visited );
a61af66fc99e Initial load duke parents: diff changeset	2433 assert( fail == 0, "verify loops failed" );
a61af66fc99e Initial load duke parents: diff changeset	2434 // Verify loop structure is the same
a61af66fc99e Initial load duke parents: diff changeset	2435 _ltree_root->verify_tree(loop_verify._ltree_root, NULL);
a61af66fc99e Initial load duke parents: diff changeset	2436 // Reset major-progress. It was cleared by creating a verify version of
a61af66fc99e Initial load duke parents: diff changeset	2437 // PhaseIdealLoop.
a61af66fc99e Initial load duke parents: diff changeset	2438 for( int i=0; i<old_progress; i++ )
a61af66fc99e Initial load duke parents: diff changeset	2439 C->set_major_progress();
a61af66fc99e Initial load duke parents: diff changeset	2440 }
a61af66fc99e Initial load duke parents: diff changeset	2441
a61af66fc99e Initial load duke parents: diff changeset	2442 //------------------------------verify_compare---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2443 // Make sure me and the given PhaseIdealLoop agree on key data structures
a61af66fc99e Initial load duke parents: diff changeset	2444 void PhaseIdealLoop::verify_compare( Node n, const PhaseIdealLoop loop_verify, VectorSet &visited ) const {
a61af66fc99e Initial load duke parents: diff changeset	2445 if( !n ) return;
a61af66fc99e Initial load duke parents: diff changeset	2446 if( visited.test_set( n->_idx ) ) return;
a61af66fc99e Initial load duke parents: diff changeset	2447 if( !_nodes[n->_idx] ) { // Unreachable
a61af66fc99e Initial load duke parents: diff changeset	2448 assert( !loop_verify->_nodes[n->_idx], "both should be unreachable" );
a61af66fc99e Initial load duke parents: diff changeset	2449 return;
a61af66fc99e Initial load duke parents: diff changeset	2450 }
a61af66fc99e Initial load duke parents: diff changeset	2451
a61af66fc99e Initial load duke parents: diff changeset	2452 uint i;
a61af66fc99e Initial load duke parents: diff changeset	2453 for( i = 0; i < n->req(); i++ )
a61af66fc99e Initial load duke parents: diff changeset	2454 verify_compare( n->in(i), loop_verify, visited );
a61af66fc99e Initial load duke parents: diff changeset	2455
a61af66fc99e Initial load duke parents: diff changeset	2456 // Check the '_nodes' block/loop structure
a61af66fc99e Initial load duke parents: diff changeset	2457 i = n->_idx;
a61af66fc99e Initial load duke parents: diff changeset	2458 if( has_ctrl(n) ) { // We have control; verify has loop or ctrl
a61af66fc99e Initial load duke parents: diff changeset	2459 if( _nodes[i] != loop_verify->_nodes[i] &&
a61af66fc99e Initial load duke parents: diff changeset	2460 get_ctrl_no_update(n) != loop_verify->get_ctrl_no_update(n) ) {
a61af66fc99e Initial load duke parents: diff changeset	2461 tty->print("Mismatched control setting for: ");
a61af66fc99e Initial load duke parents: diff changeset	2462 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2463 if( fail++ > 10 ) return;
a61af66fc99e Initial load duke parents: diff changeset	2464 Node *c = get_ctrl_no_update(n);
a61af66fc99e Initial load duke parents: diff changeset	2465 tty->print("We have it as: ");
a61af66fc99e Initial load duke parents: diff changeset	2466 if( c->in(0) ) c->dump();
a61af66fc99e Initial load duke parents: diff changeset	2467 else tty->print_cr("N%d",c->_idx);
a61af66fc99e Initial load duke parents: diff changeset	2468 tty->print("Verify thinks: ");
a61af66fc99e Initial load duke parents: diff changeset	2469 if( loop_verify->has_ctrl(n) )
a61af66fc99e Initial load duke parents: diff changeset	2470 loop_verify->get_ctrl_no_update(n)->dump();
a61af66fc99e Initial load duke parents: diff changeset	2471 else
a61af66fc99e Initial load duke parents: diff changeset	2472 loop_verify->get_loop_idx(n)->dump();
a61af66fc99e Initial load duke parents: diff changeset	2473 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	2474 }
a61af66fc99e Initial load duke parents: diff changeset	2475 } else { // We have a loop
a61af66fc99e Initial load duke parents: diff changeset	2476 IdealLoopTree *us = get_loop_idx(n);
a61af66fc99e Initial load duke parents: diff changeset	2477 if( loop_verify->has_ctrl(n) ) {
a61af66fc99e Initial load duke parents: diff changeset	2478 tty->print("Mismatched loop setting for: ");
a61af66fc99e Initial load duke parents: diff changeset	2479 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2480 if( fail++ > 10 ) return;
a61af66fc99e Initial load duke parents: diff changeset	2481 tty->print("We have it as: ");
a61af66fc99e Initial load duke parents: diff changeset	2482 us->dump();
a61af66fc99e Initial load duke parents: diff changeset	2483 tty->print("Verify thinks: ");
a61af66fc99e Initial load duke parents: diff changeset	2484 loop_verify->get_ctrl_no_update(n)->dump();
a61af66fc99e Initial load duke parents: diff changeset	2485 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	2486 } else if (!C->major_progress()) {
a61af66fc99e Initial load duke parents: diff changeset	2487 // Loop selection can be messed up if we did a major progress
a61af66fc99e Initial load duke parents: diff changeset	2488 // operation, like split-if. Do not verify in that case.
a61af66fc99e Initial load duke parents: diff changeset	2489 IdealLoopTree *them = loop_verify->get_loop_idx(n);
a61af66fc99e Initial load duke parents: diff changeset	2490 if( us->_head != them->_head \|\| us->_tail != them->_tail ) {
a61af66fc99e Initial load duke parents: diff changeset	2491 tty->print("Unequals loops for: ");
a61af66fc99e Initial load duke parents: diff changeset	2492 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2493 if( fail++ > 10 ) return;
a61af66fc99e Initial load duke parents: diff changeset	2494 tty->print("We have it as: ");
a61af66fc99e Initial load duke parents: diff changeset	2495 us->dump();
a61af66fc99e Initial load duke parents: diff changeset	2496 tty->print("Verify thinks: ");
a61af66fc99e Initial load duke parents: diff changeset	2497 them->dump();
a61af66fc99e Initial load duke parents: diff changeset	2498 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	2499 }
a61af66fc99e Initial load duke parents: diff changeset	2500 }
a61af66fc99e Initial load duke parents: diff changeset	2501 }
a61af66fc99e Initial load duke parents: diff changeset	2502
a61af66fc99e Initial load duke parents: diff changeset	2503 // Check for immediate dominators being equal
a61af66fc99e Initial load duke parents: diff changeset	2504 if( i >= _idom_size ) {
a61af66fc99e Initial load duke parents: diff changeset	2505 if( !n->is_CFG() ) return;
a61af66fc99e Initial load duke parents: diff changeset	2506 tty->print("CFG Node with no idom: ");
a61af66fc99e Initial load duke parents: diff changeset	2507 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2508 return;
a61af66fc99e Initial load duke parents: diff changeset	2509 }
a61af66fc99e Initial load duke parents: diff changeset	2510 if( !n->is_CFG() ) return;
a61af66fc99e Initial load duke parents: diff changeset	2511 if( n == C->root() ) return; // No IDOM here
a61af66fc99e Initial load duke parents: diff changeset	2512
a61af66fc99e Initial load duke parents: diff changeset	2513 assert(n->_idx == i, "sanity");
a61af66fc99e Initial load duke parents: diff changeset	2514 Node *id = idom_no_update(n);
a61af66fc99e Initial load duke parents: diff changeset	2515 if( id != loop_verify->idom_no_update(n) ) {
a61af66fc99e Initial load duke parents: diff changeset	2516 tty->print("Unequals idoms for: ");
a61af66fc99e Initial load duke parents: diff changeset	2517 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2518 if( fail++ > 10 ) return;
a61af66fc99e Initial load duke parents: diff changeset	2519 tty->print("We have it as: ");
a61af66fc99e Initial load duke parents: diff changeset	2520 id->dump();
a61af66fc99e Initial load duke parents: diff changeset	2521 tty->print("Verify thinks: ");
a61af66fc99e Initial load duke parents: diff changeset	2522 loop_verify->idom_no_update(n)->dump();
a61af66fc99e Initial load duke parents: diff changeset	2523 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	2524 }
a61af66fc99e Initial load duke parents: diff changeset	2525
a61af66fc99e Initial load duke parents: diff changeset	2526 }
a61af66fc99e Initial load duke parents: diff changeset	2527
a61af66fc99e Initial load duke parents: diff changeset	2528 //------------------------------verify_tree------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2529 // Verify that tree structures match. Because the CFG can change, siblings
a61af66fc99e Initial load duke parents: diff changeset	2530 // within the loop tree can be reordered. We attempt to deal with that by
a61af66fc99e Initial load duke parents: diff changeset	2531 // reordering the verify's loop tree if possible.
a61af66fc99e Initial load duke parents: diff changeset	2532 void IdealLoopTree::verify_tree(IdealLoopTree loop, const IdealLoopTree parent) const {
a61af66fc99e Initial load duke parents: diff changeset	2533 assert( _parent == parent, "Badly formed loop tree" );
a61af66fc99e Initial load duke parents: diff changeset	2534
a61af66fc99e Initial load duke parents: diff changeset	2535 // Siblings not in same order? Attempt to re-order.
a61af66fc99e Initial load duke parents: diff changeset	2536 if( _head != loop->_head ) {
a61af66fc99e Initial load duke parents: diff changeset	2537 // Find _next pointer to update
a61af66fc99e Initial load duke parents: diff changeset	2538 IdealLoopTree **pp = &loop->_parent->_child;
a61af66fc99e Initial load duke parents: diff changeset	2539 while( *pp != loop )
a61af66fc99e Initial load duke parents: diff changeset	2540 pp = &((*pp)->_next);
a61af66fc99e Initial load duke parents: diff changeset	2541 // Find proper sibling to be next
a61af66fc99e Initial load duke parents: diff changeset	2542 IdealLoopTree **nn = &loop->_next;
a61af66fc99e Initial load duke parents: diff changeset	2543 while( (nn) && (nn)->_head != _head )
a61af66fc99e Initial load duke parents: diff changeset	2544 nn = &((*nn)->_next);
a61af66fc99e Initial load duke parents: diff changeset	2545
a61af66fc99e Initial load duke parents: diff changeset	2546 // Check for no match.
a61af66fc99e Initial load duke parents: diff changeset	2547 if( !(*nn) ) {
a61af66fc99e Initial load duke parents: diff changeset	2548 // Annoyingly, irreducible loops can pick different headers
a61af66fc99e Initial load duke parents: diff changeset	2549 // after a major_progress operation, so the rest of the loop
a61af66fc99e Initial load duke parents: diff changeset	2550 // tree cannot be matched.
a61af66fc99e Initial load duke parents: diff changeset	2551 if (_irreducible && Compile::current()->major_progress()) return;
a61af66fc99e Initial load duke parents: diff changeset	2552 assert( 0, "failed to match loop tree" );
a61af66fc99e Initial load duke parents: diff changeset	2553 }
a61af66fc99e Initial load duke parents: diff changeset	2554
a61af66fc99e Initial load duke parents: diff changeset	2555 // Move (nn) to (pp)
a61af66fc99e Initial load duke parents: diff changeset	2556 IdealLoopTree hit = nn;
a61af66fc99e Initial load duke parents: diff changeset	2557 *nn = hit->_next;
a61af66fc99e Initial load duke parents: diff changeset	2558 hit->_next = loop;
a61af66fc99e Initial load duke parents: diff changeset	2559 *pp = loop;
a61af66fc99e Initial load duke parents: diff changeset	2560 loop = hit;
a61af66fc99e Initial load duke parents: diff changeset	2561 // Now try again to verify
a61af66fc99e Initial load duke parents: diff changeset	2562 }
a61af66fc99e Initial load duke parents: diff changeset	2563
a61af66fc99e Initial load duke parents: diff changeset	2564 assert( _head == loop->_head , "mismatched loop head" );
a61af66fc99e Initial load duke parents: diff changeset	2565 Node *tail = _tail; // Inline a non-updating version of
a61af66fc99e Initial load duke parents: diff changeset	2566 while( !tail->in(0) ) // the 'tail()' call.
a61af66fc99e Initial load duke parents: diff changeset	2567 tail = tail->in(1);
a61af66fc99e Initial load duke parents: diff changeset	2568 assert( tail == loop->_tail, "mismatched loop tail" );
a61af66fc99e Initial load duke parents: diff changeset	2569
a61af66fc99e Initial load duke parents: diff changeset	2570 // Counted loops that are guarded should be able to find their guards
a61af66fc99e Initial load duke parents: diff changeset	2571 if( _head->is_CountedLoop() && _head->as_CountedLoop()->is_main_loop() ) {
a61af66fc99e Initial load duke parents: diff changeset	2572 CountedLoopNode *cl = _head->as_CountedLoop();
a61af66fc99e Initial load duke parents: diff changeset	2573 Node *init = cl->init_trip();
a61af66fc99e Initial load duke parents: diff changeset	2574 Node *ctrl = cl->in(LoopNode::EntryControl);
a61af66fc99e Initial load duke parents: diff changeset	2575 assert( ctrl->Opcode() == Op_IfTrue \|\| ctrl->Opcode() == Op_IfFalse, "" );
a61af66fc99e Initial load duke parents: diff changeset	2576 Node *iff = ctrl->in(0);
a61af66fc99e Initial load duke parents: diff changeset	2577 assert( iff->Opcode() == Op_If, "" );
a61af66fc99e Initial load duke parents: diff changeset	2578 Node *bol = iff->in(1);
a61af66fc99e Initial load duke parents: diff changeset	2579 assert( bol->Opcode() == Op_Bool, "" );
a61af66fc99e Initial load duke parents: diff changeset	2580 Node *cmp = bol->in(1);
a61af66fc99e Initial load duke parents: diff changeset	2581 assert( cmp->Opcode() == Op_CmpI, "" );
a61af66fc99e Initial load duke parents: diff changeset	2582 Node *add = cmp->in(1);
a61af66fc99e Initial load duke parents: diff changeset	2583 Node *opaq;
a61af66fc99e Initial load duke parents: diff changeset	2584 if( add->Opcode() == Op_Opaque1 ) {
a61af66fc99e Initial load duke parents: diff changeset	2585 opaq = add;
a61af66fc99e Initial load duke parents: diff changeset	2586 } else {
a61af66fc99e Initial load duke parents: diff changeset	2587 assert( add->Opcode() == Op_AddI \|\| add->Opcode() == Op_ConI , "" );
a61af66fc99e Initial load duke parents: diff changeset	2588 assert( add == init, "" );
a61af66fc99e Initial load duke parents: diff changeset	2589 opaq = cmp->in(2);
a61af66fc99e Initial load duke parents: diff changeset	2590 }
a61af66fc99e Initial load duke parents: diff changeset	2591 assert( opaq->Opcode() == Op_Opaque1, "" );
a61af66fc99e Initial load duke parents: diff changeset	2592
a61af66fc99e Initial load duke parents: diff changeset	2593 }
a61af66fc99e Initial load duke parents: diff changeset	2594
a61af66fc99e Initial load duke parents: diff changeset	2595 if (_child != NULL) _child->verify_tree(loop->_child, this);
a61af66fc99e Initial load duke parents: diff changeset	2596 if (_next != NULL) _next ->verify_tree(loop->_next, parent);
a61af66fc99e Initial load duke parents: diff changeset	2597 // Innermost loops need to verify loop bodies,
a61af66fc99e Initial load duke parents: diff changeset	2598 // but only if no 'major_progress'
a61af66fc99e Initial load duke parents: diff changeset	2599 int fail = 0;
a61af66fc99e Initial load duke parents: diff changeset	2600 if (!Compile::current()->major_progress() && _child == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2601 for( uint i = 0; i < _body.size(); i++ ) {
a61af66fc99e Initial load duke parents: diff changeset	2602 Node *n = _body.at(i);
a61af66fc99e Initial load duke parents: diff changeset	2603 if (n->outcnt() == 0) continue; // Ignore dead
a61af66fc99e Initial load duke parents: diff changeset	2604 uint j;
a61af66fc99e Initial load duke parents: diff changeset	2605 for( j = 0; j < loop->_body.size(); j++ )
a61af66fc99e Initial load duke parents: diff changeset	2606 if( loop->_body.at(j) == n )
a61af66fc99e Initial load duke parents: diff changeset	2607 break;
a61af66fc99e Initial load duke parents: diff changeset	2608 if( j == loop->_body.size() ) { // Not found in loop body
a61af66fc99e Initial load duke parents: diff changeset	2609 // Last ditch effort to avoid assertion: Its possible that we
a61af66fc99e Initial load duke parents: diff changeset	2610 // have some users (so outcnt not zero) but are still dead.
a61af66fc99e Initial load duke parents: diff changeset	2611 // Try to find from root.
a61af66fc99e Initial load duke parents: diff changeset	2612 if (Compile::current()->root()->find(n->_idx)) {
a61af66fc99e Initial load duke parents: diff changeset	2613 fail++;
a61af66fc99e Initial load duke parents: diff changeset	2614 tty->print("We have that verify does not: ");
a61af66fc99e Initial load duke parents: diff changeset	2615 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2616 }
a61af66fc99e Initial load duke parents: diff changeset	2617 }
a61af66fc99e Initial load duke parents: diff changeset	2618 }
a61af66fc99e Initial load duke parents: diff changeset	2619 for( uint i2 = 0; i2 < loop->_body.size(); i2++ ) {
a61af66fc99e Initial load duke parents: diff changeset	2620 Node *n = loop->_body.at(i2);
a61af66fc99e Initial load duke parents: diff changeset	2621 if (n->outcnt() == 0) continue; // Ignore dead
a61af66fc99e Initial load duke parents: diff changeset	2622 uint j;
a61af66fc99e Initial load duke parents: diff changeset	2623 for( j = 0; j < _body.size(); j++ )
a61af66fc99e Initial load duke parents: diff changeset	2624 if( _body.at(j) == n )
a61af66fc99e Initial load duke parents: diff changeset	2625 break;
a61af66fc99e Initial load duke parents: diff changeset	2626 if( j == _body.size() ) { // Not found in loop body
a61af66fc99e Initial load duke parents: diff changeset	2627 // Last ditch effort to avoid assertion: Its possible that we
a61af66fc99e Initial load duke parents: diff changeset	2628 // have some users (so outcnt not zero) but are still dead.
a61af66fc99e Initial load duke parents: diff changeset	2629 // Try to find from root.
a61af66fc99e Initial load duke parents: diff changeset	2630 if (Compile::current()->root()->find(n->_idx)) {
a61af66fc99e Initial load duke parents: diff changeset	2631 fail++;
a61af66fc99e Initial load duke parents: diff changeset	2632 tty->print("Verify has that we do not: ");
a61af66fc99e Initial load duke parents: diff changeset	2633 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	2634 }
a61af66fc99e Initial load duke parents: diff changeset	2635 }
a61af66fc99e Initial load duke parents: diff changeset	2636 }
a61af66fc99e Initial load duke parents: diff changeset	2637 assert( !fail, "loop body mismatch" );
a61af66fc99e Initial load duke parents: diff changeset	2638 }
a61af66fc99e Initial load duke parents: diff changeset	2639 }
a61af66fc99e Initial load duke parents: diff changeset	2640
a61af66fc99e Initial load duke parents: diff changeset	2641 #endif
a61af66fc99e Initial load duke parents: diff changeset	2642
a61af66fc99e Initial load duke parents: diff changeset	2643 //------------------------------set_idom---------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2644 void PhaseIdealLoop::set_idom(Node* d, Node* n, uint dom_depth) {
a61af66fc99e Initial load duke parents: diff changeset	2645 uint idx = d->_idx;
a61af66fc99e Initial load duke parents: diff changeset	2646 if (idx >= _idom_size) {
a61af66fc99e Initial load duke parents: diff changeset	2647 uint newsize = _idom_size<<1;
a61af66fc99e Initial load duke parents: diff changeset	2648 while( idx >= newsize ) {
a61af66fc99e Initial load duke parents: diff changeset	2649 newsize <<= 1;
a61af66fc99e Initial load duke parents: diff changeset	2650 }
a61af66fc99e Initial load duke parents: diff changeset	2651 _idom = REALLOC_RESOURCE_ARRAY( Node*, _idom,_idom_size,newsize);
a61af66fc99e Initial load duke parents: diff changeset	2652 _dom_depth = REALLOC_RESOURCE_ARRAY( uint, _dom_depth,_idom_size,newsize);
a61af66fc99e Initial load duke parents: diff changeset	2653 memset( _dom_depth + _idom_size, 0, (newsize - _idom_size) * sizeof(uint) );
a61af66fc99e Initial load duke parents: diff changeset	2654 _idom_size = newsize;
a61af66fc99e Initial load duke parents: diff changeset	2655 }
a61af66fc99e Initial load duke parents: diff changeset	2656 _idom[idx] = n;
a61af66fc99e Initial load duke parents: diff changeset	2657 _dom_depth[idx] = dom_depth;
a61af66fc99e Initial load duke parents: diff changeset	2658 }
a61af66fc99e Initial load duke parents: diff changeset	2659
a61af66fc99e Initial load duke parents: diff changeset	2660 //------------------------------recompute_dom_depth---------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2661 // The dominator tree is constructed with only parent pointers.
a61af66fc99e Initial load duke parents: diff changeset	2662 // This recomputes the depth in the tree by first tagging all
a61af66fc99e Initial load duke parents: diff changeset	2663 // nodes as "no depth yet" marker. The next pass then runs up
a61af66fc99e Initial load duke parents: diff changeset	2664 // the dom tree from each node marked "no depth yet", and computes
a61af66fc99e Initial load duke parents: diff changeset	2665 // the depth on the way back down.
a61af66fc99e Initial load duke parents: diff changeset	2666 void PhaseIdealLoop::recompute_dom_depth() {
a61af66fc99e Initial load duke parents: diff changeset	2667 uint no_depth_marker = C->unique();
a61af66fc99e Initial load duke parents: diff changeset	2668 uint i;
a61af66fc99e Initial load duke parents: diff changeset	2669 // Initialize depth to "no depth yet"
a61af66fc99e Initial load duke parents: diff changeset	2670 for (i = 0; i < _idom_size; i++) {
a61af66fc99e Initial load duke parents: diff changeset	2671 if (_dom_depth[i] > 0 && _idom[i] != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2672 _dom_depth[i] = no_depth_marker;
a61af66fc99e Initial load duke parents: diff changeset	2673 }
a61af66fc99e Initial load duke parents: diff changeset	2674 }
a61af66fc99e Initial load duke parents: diff changeset	2675 if (_dom_stk == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2676 uint init_size = C->unique() / 100; // Guess that 1/100 is a reasonable initial size.
a61af66fc99e Initial load duke parents: diff changeset	2677 if (init_size < 10) init_size = 10;
2248 194c9fdee631 7017240: C2: native memory leak in nsk/regression/b4675027 on windows-x86 in comp mode with G1 kvn parents: 1972 diff changeset	2678 _dom_stk = new GrowableArray<uint>(init_size);
0 a61af66fc99e Initial load duke parents: diff changeset	2679 }
a61af66fc99e Initial load duke parents: diff changeset	2680 // Compute new depth for each node.
a61af66fc99e Initial load duke parents: diff changeset	2681 for (i = 0; i < _idom_size; i++) {
a61af66fc99e Initial load duke parents: diff changeset	2682 uint j = i;
a61af66fc99e Initial load duke parents: diff changeset	2683 // Run up the dom tree to find a node with a depth
a61af66fc99e Initial load duke parents: diff changeset	2684 while (_dom_depth[j] == no_depth_marker) {
a61af66fc99e Initial load duke parents: diff changeset	2685 _dom_stk->push(j);
a61af66fc99e Initial load duke parents: diff changeset	2686 j = _idom[j]->_idx;
a61af66fc99e Initial load duke parents: diff changeset	2687 }
a61af66fc99e Initial load duke parents: diff changeset	2688 // Compute the depth on the way back down this tree branch
a61af66fc99e Initial load duke parents: diff changeset	2689 uint dd = _dom_depth[j] + 1;
a61af66fc99e Initial load duke parents: diff changeset	2690 while (_dom_stk->length() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	2691 uint j = _dom_stk->pop();
a61af66fc99e Initial load duke parents: diff changeset	2692 _dom_depth[j] = dd;
a61af66fc99e Initial load duke parents: diff changeset	2693 dd++;
a61af66fc99e Initial load duke parents: diff changeset	2694 }
a61af66fc99e Initial load duke parents: diff changeset	2695 }
a61af66fc99e Initial load duke parents: diff changeset	2696 }
a61af66fc99e Initial load duke parents: diff changeset	2697
a61af66fc99e Initial load duke parents: diff changeset	2698 //------------------------------sort-------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2699 // Insert 'loop' into the existing loop tree. 'innermost' is a leaf of the
a61af66fc99e Initial load duke parents: diff changeset	2700 // loop tree, not the root.
a61af66fc99e Initial load duke parents: diff changeset	2701 IdealLoopTree PhaseIdealLoop::sort( IdealLoopTree loop, IdealLoopTree *innermost ) {
a61af66fc99e Initial load duke parents: diff changeset	2702 if( !innermost ) return loop; // New innermost loop
a61af66fc99e Initial load duke parents: diff changeset	2703
a61af66fc99e Initial load duke parents: diff changeset	2704 int loop_preorder = get_preorder(loop->_head); // Cache pre-order number
a61af66fc99e Initial load duke parents: diff changeset	2705 assert( loop_preorder, "not yet post-walked loop" );
a61af66fc99e Initial load duke parents: diff changeset	2706 IdealLoopTree **pp = &innermost; // Pointer to previous next-pointer
a61af66fc99e Initial load duke parents: diff changeset	2707 IdealLoopTree l = pp; // Do I go before or after 'l'?
a61af66fc99e Initial load duke parents: diff changeset	2708
a61af66fc99e Initial load duke parents: diff changeset	2709 // Insert at start of list
a61af66fc99e Initial load duke parents: diff changeset	2710 while( l ) { // Insertion sort based on pre-order
a61af66fc99e Initial load duke parents: diff changeset	2711 if( l == loop ) return innermost; // Already on list!
a61af66fc99e Initial load duke parents: diff changeset	2712 int l_preorder = get_preorder(l->_head); // Cache pre-order number
a61af66fc99e Initial load duke parents: diff changeset	2713 assert( l_preorder, "not yet post-walked l" );
a61af66fc99e Initial load duke parents: diff changeset	2714 // Check header pre-order number to figure proper nesting
a61af66fc99e Initial load duke parents: diff changeset	2715 if( loop_preorder > l_preorder )
a61af66fc99e Initial load duke parents: diff changeset	2716 break; // End of insertion
a61af66fc99e Initial load duke parents: diff changeset	2717 // If headers tie (e.g., shared headers) check tail pre-order numbers.
a61af66fc99e Initial load duke parents: diff changeset	2718 // Since I split shared headers, you'd think this could not happen.
a61af66fc99e Initial load duke parents: diff changeset	2719 // BUT: I must first do the preorder numbering before I can discover I
a61af66fc99e Initial load duke parents: diff changeset	2720 // have shared headers, so the split headers all get the same preorder
a61af66fc99e Initial load duke parents: diff changeset	2721 // number as the RegionNode they split from.
a61af66fc99e Initial load duke parents: diff changeset	2722 if( loop_preorder == l_preorder &&
a61af66fc99e Initial load duke parents: diff changeset	2723 get_preorder(loop->_tail) < get_preorder(l->_tail) )
a61af66fc99e Initial load duke parents: diff changeset	2724 break; // Also check for shared headers (same pre#)
a61af66fc99e Initial load duke parents: diff changeset	2725 pp = &l->_parent; // Chain up list
a61af66fc99e Initial load duke parents: diff changeset	2726 l = *pp;
a61af66fc99e Initial load duke parents: diff changeset	2727 }
a61af66fc99e Initial load duke parents: diff changeset	2728 // Link into list
a61af66fc99e Initial load duke parents: diff changeset	2729 // Point predecessor to me
a61af66fc99e Initial load duke parents: diff changeset	2730 *pp = loop;
a61af66fc99e Initial load duke parents: diff changeset	2731 // Point me to successor
a61af66fc99e Initial load duke parents: diff changeset	2732 IdealLoopTree *p = loop->_parent;
a61af66fc99e Initial load duke parents: diff changeset	2733 loop->_parent = l; // Point me to successor
a61af66fc99e Initial load duke parents: diff changeset	2734 if( p ) sort( p, innermost ); // Insert my parents into list as well
a61af66fc99e Initial load duke parents: diff changeset	2735 return innermost;
a61af66fc99e Initial load duke parents: diff changeset	2736 }
a61af66fc99e Initial load duke parents: diff changeset	2737
a61af66fc99e Initial load duke parents: diff changeset	2738 //------------------------------build_loop_tree--------------------------------
a61af66fc99e Initial load duke parents: diff changeset	2739 // I use a modified Vick/Tarjan algorithm. I need pre- and a post- visit
a61af66fc99e Initial load duke parents: diff changeset	2740 // bits. The _nodes[] array is mapped by Node index and holds a NULL for
a61af66fc99e Initial load duke parents: diff changeset	2741 // not-yet-pre-walked, pre-order # for pre-but-not-post-walked and holds the
a61af66fc99e Initial load duke parents: diff changeset	2742 // tightest enclosing IdealLoopTree for post-walked.
a61af66fc99e Initial load duke parents: diff changeset	2743 //
a61af66fc99e Initial load duke parents: diff changeset	2744 // During my forward walk I do a short 1-layer lookahead to see if I can find
a61af66fc99e Initial load duke parents: diff changeset	2745 // a loop backedge with that doesn't have any work on the backedge. This
a61af66fc99e Initial load duke parents: diff changeset	2746 // helps me construct nested loops with shared headers better.
a61af66fc99e Initial load duke parents: diff changeset	2747 //
a61af66fc99e Initial load duke parents: diff changeset	2748 // Once I've done the forward recursion, I do the post-work. For each child
a61af66fc99e Initial load duke parents: diff changeset	2749 // I check to see if there is a backedge. Backedges define a loop! I
a61af66fc99e Initial load duke parents: diff changeset	2750 // insert an IdealLoopTree at the target of the backedge.
a61af66fc99e Initial load duke parents: diff changeset	2751 //
a61af66fc99e Initial load duke parents: diff changeset	2752 // During the post-work I also check to see if I have several children
a61af66fc99e Initial load duke parents: diff changeset	2753 // belonging to different loops. If so, then this Node is a decision point
a61af66fc99e Initial load duke parents: diff changeset	2754 // where control flow can choose to change loop nests. It is at this
a61af66fc99e Initial load duke parents: diff changeset	2755 // decision point where I can figure out how loops are nested. At this
a61af66fc99e Initial load duke parents: diff changeset	2756 // time I can properly order the different loop nests from my children.
a61af66fc99e Initial load duke parents: diff changeset	2757 // Note that there may not be any backedges at the decision point!
a61af66fc99e Initial load duke parents: diff changeset	2758 //
a61af66fc99e Initial load duke parents: diff changeset	2759 // Since the decision point can be far removed from the backedges, I can't
a61af66fc99e Initial load duke parents: diff changeset	2760 // order my loops at the time I discover them. Thus at the decision point
a61af66fc99e Initial load duke parents: diff changeset	2761 // I need to inspect loop header pre-order numbers to properly nest my
a61af66fc99e Initial load duke parents: diff changeset	2762 // loops. This means I need to sort my childrens' loops by pre-order.
a61af66fc99e Initial load duke parents: diff changeset	2763 // The sort is of size number-of-control-children, which generally limits
a61af66fc99e Initial load duke parents: diff changeset	2764 // it to size 2 (i.e., I just choose between my 2 target loops).
a61af66fc99e Initial load duke parents: diff changeset	2765 void PhaseIdealLoop::build_loop_tree() {
a61af66fc99e Initial load duke parents: diff changeset	2766 // Allocate stack of size C->unique()/2 to avoid frequent realloc
a61af66fc99e Initial load duke parents: diff changeset	2767 GrowableArray <Node *> bltstack(C->unique() >> 1);
a61af66fc99e Initial load duke parents: diff changeset	2768 Node *n = C->root();
a61af66fc99e Initial load duke parents: diff changeset	2769 bltstack.push(n);
a61af66fc99e Initial load duke parents: diff changeset	2770 int pre_order = 1;
a61af66fc99e Initial load duke parents: diff changeset	2771 int stack_size;
a61af66fc99e Initial load duke parents: diff changeset	2772
a61af66fc99e Initial load duke parents: diff changeset	2773 while ( ( stack_size = bltstack.length() ) != 0 ) {
a61af66fc99e Initial load duke parents: diff changeset	2774 n = bltstack.top(); // Leave node on stack
a61af66fc99e Initial load duke parents: diff changeset	2775 if ( !is_visited(n) ) {
a61af66fc99e Initial load duke parents: diff changeset	2776 // ---- Pre-pass Work ----
a61af66fc99e Initial load duke parents: diff changeset	2777 // Pre-walked but not post-walked nodes need a pre_order number.
a61af66fc99e Initial load duke parents: diff changeset	2778
a61af66fc99e Initial load duke parents: diff changeset	2779 set_preorder_visited( n, pre_order ); // set as visited
a61af66fc99e Initial load duke parents: diff changeset	2780
a61af66fc99e Initial load duke parents: diff changeset	2781 // ---- Scan over children ----
a61af66fc99e Initial load duke parents: diff changeset	2782 // Scan first over control projections that lead to loop headers.
a61af66fc99e Initial load duke parents: diff changeset	2783 // This helps us find inner-to-outer loops with shared headers better.
a61af66fc99e Initial load duke parents: diff changeset	2784
a61af66fc99e Initial load duke parents: diff changeset	2785 // Scan children's children for loop headers.
a61af66fc99e Initial load duke parents: diff changeset	2786 for ( int i = n->outcnt() - 1; i >= 0; --i ) {
a61af66fc99e Initial load duke parents: diff changeset	2787 Node* m = n->raw_out(i); // Child
a61af66fc99e Initial load duke parents: diff changeset	2788 if( m->is_CFG() && !is_visited(m) ) { // Only for CFG children
a61af66fc99e Initial load duke parents: diff changeset	2789 // Scan over children's children to find loop
a61af66fc99e Initial load duke parents: diff changeset	2790 for (DUIterator_Fast jmax, j = m->fast_outs(jmax); j < jmax; j++) {
a61af66fc99e Initial load duke parents: diff changeset	2791 Node* l = m->fast_out(j);
a61af66fc99e Initial load duke parents: diff changeset	2792 if( is_visited(l) && // Been visited?
a61af66fc99e Initial load duke parents: diff changeset	2793 !is_postvisited(l) && // But not post-visited
a61af66fc99e Initial load duke parents: diff changeset	2794 get_preorder(l) < pre_order ) { // And smaller pre-order
a61af66fc99e Initial load duke parents: diff changeset	2795 // Found! Scan the DFS down this path before doing other paths
a61af66fc99e Initial load duke parents: diff changeset	2796 bltstack.push(m);
a61af66fc99e Initial load duke parents: diff changeset	2797 break;
a61af66fc99e Initial load duke parents: diff changeset	2798 }
a61af66fc99e Initial load duke parents: diff changeset	2799 }
a61af66fc99e Initial load duke parents: diff changeset	2800 }
a61af66fc99e Initial load duke parents: diff changeset	2801 }
a61af66fc99e Initial load duke parents: diff changeset	2802 pre_order++;
a61af66fc99e Initial load duke parents: diff changeset	2803 }
a61af66fc99e Initial load duke parents: diff changeset	2804 else if ( !is_postvisited(n) ) {
a61af66fc99e Initial load duke parents: diff changeset	2805 // Note: build_loop_tree_impl() adds out edges on rare occasions,
a61af66fc99e Initial load duke parents: diff changeset	2806 // such as com.sun.rsasign.am::a.
a61af66fc99e Initial load duke parents: diff changeset	2807 // For non-recursive version, first, process current children.
a61af66fc99e Initial load duke parents: diff changeset	2808 // On next iteration, check if additional children were added.
a61af66fc99e Initial load duke parents: diff changeset	2809 for ( int k = n->outcnt() - 1; k >= 0; --k ) {
a61af66fc99e Initial load duke parents: diff changeset	2810 Node* u = n->raw_out(k);
a61af66fc99e Initial load duke parents: diff changeset	2811 if ( u->is_CFG() && !is_visited(u) ) {
a61af66fc99e Initial load duke parents: diff changeset	2812 bltstack.push(u);
a61af66fc99e Initial load duke parents: diff changeset	2813 }
a61af66fc99e Initial load duke parents: diff changeset	2814 }
a61af66fc99e Initial load duke parents: diff changeset	2815 if ( bltstack.length() == stack_size ) {
a61af66fc99e Initial load duke parents: diff changeset	2816 // There were no additional children, post visit node now
a61af66fc99e Initial load duke parents: diff changeset	2817 (void)bltstack.pop(); // Remove node from stack
a61af66fc99e Initial load duke parents: diff changeset	2818 pre_order = build_loop_tree_impl( n, pre_order );
a61af66fc99e Initial load duke parents: diff changeset	2819 // Check for bailout
a61af66fc99e Initial load duke parents: diff changeset	2820 if (C->failing()) {
a61af66fc99e Initial load duke parents: diff changeset	2821 return;
a61af66fc99e Initial load duke parents: diff changeset	2822 }
a61af66fc99e Initial load duke parents: diff changeset	2823 // Check to grow _preorders[] array for the case when
a61af66fc99e Initial load duke parents: diff changeset	2824 // build_loop_tree_impl() adds new nodes.
a61af66fc99e Initial load duke parents: diff changeset	2825 check_grow_preorders();
a61af66fc99e Initial load duke parents: diff changeset	2826 }
a61af66fc99e Initial load duke parents: diff changeset	2827 }
a61af66fc99e Initial load duke parents: diff changeset	2828 else {
a61af66fc99e Initial load duke parents: diff changeset	2829 (void)bltstack.pop(); // Remove post-visited node from stack
a61af66fc99e Initial load duke parents: diff changeset	2830 }
a61af66fc99e Initial load duke parents: diff changeset	2831 }
a61af66fc99e Initial load duke parents: diff changeset	2832 }
a61af66fc99e Initial load duke parents: diff changeset	2833
a61af66fc99e Initial load duke parents: diff changeset	2834 //------------------------------build_loop_tree_impl---------------------------
a61af66fc99e Initial load duke parents: diff changeset	2835 int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
a61af66fc99e Initial load duke parents: diff changeset	2836 // ---- Post-pass Work ----
a61af66fc99e Initial load duke parents: diff changeset	2837 // Pre-walked but not post-walked nodes need a pre_order number.
a61af66fc99e Initial load duke parents: diff changeset	2838
a61af66fc99e Initial load duke parents: diff changeset	2839 // Tightest enclosing loop for this Node
a61af66fc99e Initial load duke parents: diff changeset	2840 IdealLoopTree *innermost = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2841
a61af66fc99e Initial load duke parents: diff changeset	2842 // For all children, see if any edge is a backedge. If so, make a loop
a61af66fc99e Initial load duke parents: diff changeset	2843 // for it. Then find the tightest enclosing loop for the self Node.
a61af66fc99e Initial load duke parents: diff changeset	2844 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	2845 Node* m = n->fast_out(i); // Child
a61af66fc99e Initial load duke parents: diff changeset	2846 if( n == m ) continue; // Ignore control self-cycles
a61af66fc99e Initial load duke parents: diff changeset	2847 if( !m->is_CFG() ) continue;// Ignore non-CFG edges
a61af66fc99e Initial load duke parents: diff changeset	2848
a61af66fc99e Initial load duke parents: diff changeset	2849 IdealLoopTree *l; // Child's loop
a61af66fc99e Initial load duke parents: diff changeset	2850 if( !is_postvisited(m) ) { // Child visited but not post-visited?
a61af66fc99e Initial load duke parents: diff changeset	2851 // Found a backedge
a61af66fc99e Initial load duke parents: diff changeset	2852 assert( get_preorder(m) < pre_order, "should be backedge" );
a61af66fc99e Initial load duke parents: diff changeset	2853 // Check for the RootNode, which is already a LoopNode and is allowed
a61af66fc99e Initial load duke parents: diff changeset	2854 // to have multiple "backedges".
a61af66fc99e Initial load duke parents: diff changeset	2855 if( m == C->root()) { // Found the root?
a61af66fc99e Initial load duke parents: diff changeset	2856 l = _ltree_root; // Root is the outermost LoopNode
a61af66fc99e Initial load duke parents: diff changeset	2857 } else { // Else found a nested loop
a61af66fc99e Initial load duke parents: diff changeset	2858 // Insert a LoopNode to mark this loop.
a61af66fc99e Initial load duke parents: diff changeset	2859 l = new IdealLoopTree(this, m, n);
a61af66fc99e Initial load duke parents: diff changeset	2860 } // End of Else found a nested loop
a61af66fc99e Initial load duke parents: diff changeset	2861 if( !has_loop(m) ) // If 'm' does not already have a loop set
a61af66fc99e Initial load duke parents: diff changeset	2862 set_loop(m, l); // Set loop header to loop now
a61af66fc99e Initial load duke parents: diff changeset	2863
a61af66fc99e Initial load duke parents: diff changeset	2864 } else { // Else not a nested loop
a61af66fc99e Initial load duke parents: diff changeset	2865 if( !_nodes[m->_idx] ) continue; // Dead code has no loop
a61af66fc99e Initial load duke parents: diff changeset	2866 l = get_loop(m); // Get previously determined loop
a61af66fc99e Initial load duke parents: diff changeset	2867 // If successor is header of a loop (nest), move up-loop till it
a61af66fc99e Initial load duke parents: diff changeset	2868 // is a member of some outer enclosing loop. Since there are no
a61af66fc99e Initial load duke parents: diff changeset	2869 // shared headers (I've split them already) I only need to go up
a61af66fc99e Initial load duke parents: diff changeset	2870 // at most 1 level.
a61af66fc99e Initial load duke parents: diff changeset	2871 while( l && l->_head == m ) // Successor heads loop?
a61af66fc99e Initial load duke parents: diff changeset	2872 l = l->_parent; // Move up 1 for me
a61af66fc99e Initial load duke parents: diff changeset	2873 // If this loop is not properly parented, then this loop
a61af66fc99e Initial load duke parents: diff changeset	2874 // has no exit path out, i.e. its an infinite loop.
a61af66fc99e Initial load duke parents: diff changeset	2875 if( !l ) {
a61af66fc99e Initial load duke parents: diff changeset	2876 // Make loop "reachable" from root so the CFG is reachable. Basically
a61af66fc99e Initial load duke parents: diff changeset	2877 // insert a bogus loop exit that is never taken. 'm', the loop head,
a61af66fc99e Initial load duke parents: diff changeset	2878 // points to 'n', one (of possibly many) fall-in paths. There may be
a61af66fc99e Initial load duke parents: diff changeset	2879 // many backedges as well.
a61af66fc99e Initial load duke parents: diff changeset	2880
a61af66fc99e Initial load duke parents: diff changeset	2881 // Here I set the loop to be the root loop. I could have, after
a61af66fc99e Initial load duke parents: diff changeset	2882 // inserting a bogus loop exit, restarted the recursion and found my
a61af66fc99e Initial load duke parents: diff changeset	2883 // new loop exit. This would make the infinite loop a first-class
a61af66fc99e Initial load duke parents: diff changeset	2884 // loop and it would then get properly optimized. What's the use of
a61af66fc99e Initial load duke parents: diff changeset	2885 // optimizing an infinite loop?
a61af66fc99e Initial load duke parents: diff changeset	2886 l = _ltree_root; // Oops, found infinite loop
a61af66fc99e Initial load duke parents: diff changeset	2887
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2888 if (!_verify_only) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2889 // Insert the NeverBranch between 'm' and it's control user.
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	2890 NeverBranchNode *iff = new (C) NeverBranchNode( m );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2891 _igvn.register_new_node_with_optimizer(iff);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2892 set_loop(iff, l);
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	2893 Node *if_t = new (C) CProjNode( iff, 0 );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2894 _igvn.register_new_node_with_optimizer(if_t);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2895 set_loop(if_t, l);
0 a61af66fc99e Initial load duke parents: diff changeset	2896
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2897 Node* cfg = NULL; // Find the One True Control User of m
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2898 for (DUIterator_Fast jmax, j = m->fast_outs(jmax); j < jmax; j++) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2899 Node* x = m->fast_out(j);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2900 if (x->is_CFG() && x != m && x != iff)
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2901 { cfg = x; break; }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2902 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2903 assert(cfg != NULL, "must find the control user of m");
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2904 uint k = 0; // Probably cfg->in(0)
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2905 while( cfg->in(k) != m ) k++; // But check incase cfg is a Region
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2906 cfg->set_req( k, if_t ); // Now point to NeverBranch
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2907
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2908 // Now create the never-taken loop exit
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	2909 Node *if_f = new (C) CProjNode( iff, 1 );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2910 _igvn.register_new_node_with_optimizer(if_f);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2911 set_loop(if_f, l);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2912 // Find frame ptr for Halt. Relies on the optimizer
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2913 // V-N'ing. Easier and quicker than searching through
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2914 // the program structure.
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	2915 Node *frame = new (C) ParmNode( C->start(), TypeFunc::FramePtr );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2916 _igvn.register_new_node_with_optimizer(frame);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2917 // Halt & Catch Fire
6804 e626685e9f6c 7193318: C2: remove number of inputs requirement from Node's new operator kvn parents: 6636 diff changeset	2918 Node *halt = new (C) HaltNode( if_f, frame );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2919 _igvn.register_new_node_with_optimizer(halt);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2920 set_loop(halt, l);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2921 C->root()->add_req(halt);
0 a61af66fc99e Initial load duke parents: diff changeset	2922 }
a61af66fc99e Initial load duke parents: diff changeset	2923 set_loop(C->root(), _ltree_root);
a61af66fc99e Initial load duke parents: diff changeset	2924 }
a61af66fc99e Initial load duke parents: diff changeset	2925 }
a61af66fc99e Initial load duke parents: diff changeset	2926 // Weeny check for irreducible. This child was already visited (this
a61af66fc99e Initial load duke parents: diff changeset	2927 // IS the post-work phase). Is this child's loop header post-visited
a61af66fc99e Initial load duke parents: diff changeset	2928 // as well? If so, then I found another entry into the loop.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2929 if (!_verify_only) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2930 while( is_postvisited(l->_head) ) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2931 // found irreducible
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2932 l->_irreducible = 1; // = true
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2933 l = l->_parent;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2934 _has_irreducible_loops = true;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2935 // Check for bad CFG here to prevent crash, and bailout of compile
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2936 if (l == NULL) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2937 C->record_method_not_compilable("unhandled CFG detected during loop optimization");
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2938 return pre_order;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	2939 }
0 a61af66fc99e Initial load duke parents: diff changeset	2940 }
a61af66fc99e Initial load duke parents: diff changeset	2941 }
a61af66fc99e Initial load duke parents: diff changeset	2942
a61af66fc99e Initial load duke parents: diff changeset	2943 // This Node might be a decision point for loops. It is only if
a61af66fc99e Initial load duke parents: diff changeset	2944 // it's children belong to several different loops. The sort call
a61af66fc99e Initial load duke parents: diff changeset	2945 // does a trivial amount of work if there is only 1 child or all
a61af66fc99e Initial load duke parents: diff changeset	2946 // children belong to the same loop. If however, the children
a61af66fc99e Initial load duke parents: diff changeset	2947 // belong to different loops, the sort call will properly set the
a61af66fc99e Initial load duke parents: diff changeset	2948 // _parent pointers to show how the loops nest.
a61af66fc99e Initial load duke parents: diff changeset	2949 //
a61af66fc99e Initial load duke parents: diff changeset	2950 // In any case, it returns the tightest enclosing loop.
a61af66fc99e Initial load duke parents: diff changeset	2951 innermost = sort( l, innermost );
a61af66fc99e Initial load duke parents: diff changeset	2952 }
a61af66fc99e Initial load duke parents: diff changeset	2953
a61af66fc99e Initial load duke parents: diff changeset	2954 // Def-use info will have some dead stuff; dead stuff will have no
a61af66fc99e Initial load duke parents: diff changeset	2955 // loop decided on.
a61af66fc99e Initial load duke parents: diff changeset	2956
a61af66fc99e Initial load duke parents: diff changeset	2957 // Am I a loop header? If so fix up my parent's child and next ptrs.
a61af66fc99e Initial load duke parents: diff changeset	2958 if( innermost && innermost->_head == n ) {
a61af66fc99e Initial load duke parents: diff changeset	2959 assert( get_loop(n) == innermost, "" );
a61af66fc99e Initial load duke parents: diff changeset	2960 IdealLoopTree *p = innermost->_parent;
a61af66fc99e Initial load duke parents: diff changeset	2961 IdealLoopTree *l = innermost;
a61af66fc99e Initial load duke parents: diff changeset	2962 while( p && l->_head == n ) {
a61af66fc99e Initial load duke parents: diff changeset	2963 l->_next = p->_child; // Put self on parents 'next child'
a61af66fc99e Initial load duke parents: diff changeset	2964 p->_child = l; // Make self as first child of parent
a61af66fc99e Initial load duke parents: diff changeset	2965 l = p; // Now walk up the parent chain
a61af66fc99e Initial load duke parents: diff changeset	2966 p = l->_parent;
a61af66fc99e Initial load duke parents: diff changeset	2967 }
a61af66fc99e Initial load duke parents: diff changeset	2968 } else {
a61af66fc99e Initial load duke parents: diff changeset	2969 // Note that it is possible for a LoopNode to reach here, if the
a61af66fc99e Initial load duke parents: diff changeset	2970 // backedge has been made unreachable (hence the LoopNode no longer
a61af66fc99e Initial load duke parents: diff changeset	2971 // denotes a Loop, and will eventually be removed).
a61af66fc99e Initial load duke parents: diff changeset	2972
a61af66fc99e Initial load duke parents: diff changeset	2973 // Record tightest enclosing loop for self. Mark as post-visited.
a61af66fc99e Initial load duke parents: diff changeset	2974 set_loop(n, innermost);
a61af66fc99e Initial load duke parents: diff changeset	2975 // Also record has_call flag early on
a61af66fc99e Initial load duke parents: diff changeset	2976 if( innermost ) {
a61af66fc99e Initial load duke parents: diff changeset	2977 if( n->is_Call() && !n->is_CallLeaf() && !n->is_macro() ) {
a61af66fc99e Initial load duke parents: diff changeset	2978 // Do not count uncommon calls
a61af66fc99e Initial load duke parents: diff changeset	2979 if( !n->is_CallStaticJava() \|\| !n->as_CallStaticJava()->_name ) {
a61af66fc99e Initial load duke parents: diff changeset	2980 Node *iff = n->in(0)->in(0);
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 6144 diff changeset	2981 // No any calls for vectorized loops.
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 6144 diff changeset	2982 if( UseSuperWord \|\| !iff->is_If() \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	2983 (n->in(0)->Opcode() == Op_IfFalse &&
a61af66fc99e Initial load duke parents: diff changeset	2984 (1.0 - iff->as_If()->_prob) >= 0.01) \|\|
a61af66fc99e Initial load duke parents: diff changeset	2985 (iff->as_If()->_prob >= 0.01) )
a61af66fc99e Initial load duke parents: diff changeset	2986 innermost->_has_call = 1;
a61af66fc99e Initial load duke parents: diff changeset	2987 }
39 76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2988 } else if( n->is_Allocate() && n->as_Allocate()->_is_scalar_replaceable ) {
76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2989 // Disable loop optimizations if the loop has a scalar replaceable
76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2990 // allocation. This disabling may cause a potential performance lost
76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2991 // if the allocation is not eliminated for some reason.
76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2992 innermost->_allow_optimizations = false;
76256d272075 6667612: (Escape Analysis) disable loop cloning if it has a scalar replaceable allocation kvn parents: 17 diff changeset	2993 innermost->_has_call = 1; // = true
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	2994 } else if (n->Opcode() == Op_SafePoint) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	2995 // Record all safepoints in this loop.
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	2996 if (innermost->_safepts == NULL) innermost->_safepts = new Node_List();
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	2997 innermost->_safepts->push(n);
0 a61af66fc99e Initial load duke parents: diff changeset	2998 }
a61af66fc99e Initial load duke parents: diff changeset	2999 }
a61af66fc99e Initial load duke parents: diff changeset	3000 }
a61af66fc99e Initial load duke parents: diff changeset	3001
a61af66fc99e Initial load duke parents: diff changeset	3002 // Flag as post-visited now
a61af66fc99e Initial load duke parents: diff changeset	3003 set_postvisited(n);
a61af66fc99e Initial load duke parents: diff changeset	3004 return pre_order;
a61af66fc99e Initial load duke parents: diff changeset	3005 }
a61af66fc99e Initial load duke parents: diff changeset	3006
a61af66fc99e Initial load duke parents: diff changeset	3007
a61af66fc99e Initial load duke parents: diff changeset	3008 //------------------------------build_loop_early-------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3009 // Put Data nodes into some loop nest, by setting the _nodes[]->loop mapping.
a61af66fc99e Initial load duke parents: diff changeset	3010 // First pass computes the earliest controlling node possible. This is the
a61af66fc99e Initial load duke parents: diff changeset	3011 // controlling input with the deepest dominating depth.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3012 void PhaseIdealLoop::build_loop_early( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ) {
0 a61af66fc99e Initial load duke parents: diff changeset	3013 while (worklist.size() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	3014 // Use local variables nstack_top_n & nstack_top_i to cache values
a61af66fc99e Initial load duke parents: diff changeset	3015 // on nstack's top.
a61af66fc99e Initial load duke parents: diff changeset	3016 Node *nstack_top_n = worklist.pop();
a61af66fc99e Initial load duke parents: diff changeset	3017 uint nstack_top_i = 0;
a61af66fc99e Initial load duke parents: diff changeset	3018 //while_nstack_nonempty:
a61af66fc99e Initial load duke parents: diff changeset	3019 while (true) {
a61af66fc99e Initial load duke parents: diff changeset	3020 // Get parent node and next input's index from stack's top.
a61af66fc99e Initial load duke parents: diff changeset	3021 Node *n = nstack_top_n;
a61af66fc99e Initial load duke parents: diff changeset	3022 uint i = nstack_top_i;
a61af66fc99e Initial load duke parents: diff changeset	3023 uint cnt = n->req(); // Count of inputs
a61af66fc99e Initial load duke parents: diff changeset	3024 if (i == 0) { // Pre-process the node.
a61af66fc99e Initial load duke parents: diff changeset	3025 if( has_node(n) && // Have either loop or control already?
a61af66fc99e Initial load duke parents: diff changeset	3026 !has_ctrl(n) ) { // Have loop picked out already?
a61af66fc99e Initial load duke parents: diff changeset	3027 // During "merge_many_backedges" we fold up several nested loops
a61af66fc99e Initial load duke parents: diff changeset	3028 // into a single loop. This makes the members of the original
a61af66fc99e Initial load duke parents: diff changeset	3029 // loop bodies pointing to dead loops; they need to move up
a61af66fc99e Initial load duke parents: diff changeset	3030 // to the new UNION'd larger loop. I set the _head field of these
a61af66fc99e Initial load duke parents: diff changeset	3031 // dead loops to NULL and the _parent field points to the owning
a61af66fc99e Initial load duke parents: diff changeset	3032 // loop. Shades of UNION-FIND algorithm.
a61af66fc99e Initial load duke parents: diff changeset	3033 IdealLoopTree *ilt;
a61af66fc99e Initial load duke parents: diff changeset	3034 while( !(ilt = get_loop(n))->_head ) {
a61af66fc99e Initial load duke parents: diff changeset	3035 // Normally I would use a set_loop here. But in this one special
a61af66fc99e Initial load duke parents: diff changeset	3036 // case, it is legal (and expected) to change what loop a Node
a61af66fc99e Initial load duke parents: diff changeset	3037 // belongs to.
a61af66fc99e Initial load duke parents: diff changeset	3038 _nodes.map(n->_idx, (Node*)(ilt->_parent) );
a61af66fc99e Initial load duke parents: diff changeset	3039 }
a61af66fc99e Initial load duke parents: diff changeset	3040 // Remove safepoints ONLY if I've already seen I don't need one.
a61af66fc99e Initial load duke parents: diff changeset	3041 // (the old code here would yank a 2nd safepoint after seeing a
a61af66fc99e Initial load duke parents: diff changeset	3042 // first one, even though the 1st did not dominate in the loop body
a61af66fc99e Initial load duke parents: diff changeset	3043 // and thus could be avoided indefinitely)
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3044 if( !_verify_only && !_verify_me && ilt->_has_sfpt && n->Opcode() == Op_SafePoint &&
0 a61af66fc99e Initial load duke parents: diff changeset	3045 is_deleteable_safept(n)) {
a61af66fc99e Initial load duke parents: diff changeset	3046 Node *in = n->in(TypeFunc::Control);
a61af66fc99e Initial load duke parents: diff changeset	3047 lazy_replace(n,in); // Pull safepoint now
6636 0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	3048 if (ilt->_safepts != NULL) {
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	3049 ilt->_safepts->yank(n);
0acd345fd810 7160161: Missed safepoint in non-Counted loop kvn parents: 6614 diff changeset	3050 }
0 a61af66fc99e Initial load duke parents: diff changeset	3051 // Carry on with the recursion "as if" we are walking
a61af66fc99e Initial load duke parents: diff changeset	3052 // only the control input
a61af66fc99e Initial load duke parents: diff changeset	3053 if( !visited.test_set( in->_idx ) ) {
a61af66fc99e Initial load duke parents: diff changeset	3054 worklist.push(in); // Visit this guy later, using worklist
a61af66fc99e Initial load duke parents: diff changeset	3055 }
a61af66fc99e Initial load duke parents: diff changeset	3056 // Get next node from nstack:
a61af66fc99e Initial load duke parents: diff changeset	3057 // - skip n's inputs processing by setting i > cnt;
a61af66fc99e Initial load duke parents: diff changeset	3058 // - we also will not call set_early_ctrl(n) since
a61af66fc99e Initial load duke parents: diff changeset	3059 // has_node(n) == true (see the condition above).
a61af66fc99e Initial load duke parents: diff changeset	3060 i = cnt + 1;
a61af66fc99e Initial load duke parents: diff changeset	3061 }
a61af66fc99e Initial load duke parents: diff changeset	3062 }
a61af66fc99e Initial load duke parents: diff changeset	3063 } // if (i == 0)
a61af66fc99e Initial load duke parents: diff changeset	3064
a61af66fc99e Initial load duke parents: diff changeset	3065 // Visit all inputs
a61af66fc99e Initial load duke parents: diff changeset	3066 bool done = true; // Assume all n's inputs will be processed
a61af66fc99e Initial load duke parents: diff changeset	3067 while (i < cnt) {
a61af66fc99e Initial load duke parents: diff changeset	3068 Node *in = n->in(i);
a61af66fc99e Initial load duke parents: diff changeset	3069 ++i;
a61af66fc99e Initial load duke parents: diff changeset	3070 if (in == NULL) continue;
a61af66fc99e Initial load duke parents: diff changeset	3071 if (in->pinned() && !in->is_CFG())
a61af66fc99e Initial load duke parents: diff changeset	3072 set_ctrl(in, in->in(0));
a61af66fc99e Initial load duke parents: diff changeset	3073 int is_visited = visited.test_set( in->_idx );
a61af66fc99e Initial load duke parents: diff changeset	3074 if (!has_node(in)) { // No controlling input yet?
a61af66fc99e Initial load duke parents: diff changeset	3075 assert( !in->is_CFG(), "CFG Node with no controlling input?" );
a61af66fc99e Initial load duke parents: diff changeset	3076 assert( !is_visited, "visit only once" );
a61af66fc99e Initial load duke parents: diff changeset	3077 nstack.push(n, i); // Save parent node and next input's index.
a61af66fc99e Initial load duke parents: diff changeset	3078 nstack_top_n = in; // Process current input now.
a61af66fc99e Initial load duke parents: diff changeset	3079 nstack_top_i = 0;
a61af66fc99e Initial load duke parents: diff changeset	3080 done = false; // Not all n's inputs processed.
a61af66fc99e Initial load duke parents: diff changeset	3081 break; // continue while_nstack_nonempty;
a61af66fc99e Initial load duke parents: diff changeset	3082 } else if (!is_visited) {
a61af66fc99e Initial load duke parents: diff changeset	3083 // This guy has a location picked out for him, but has not yet
a61af66fc99e Initial load duke parents: diff changeset	3084 // been visited. Happens to all CFG nodes, for instance.
a61af66fc99e Initial load duke parents: diff changeset	3085 // Visit him using the worklist instead of recursion, to break
a61af66fc99e Initial load duke parents: diff changeset	3086 // cycles. Since he has a location already we do not need to
a61af66fc99e Initial load duke parents: diff changeset	3087 // find his location before proceeding with the current Node.
a61af66fc99e Initial load duke parents: diff changeset	3088 worklist.push(in); // Visit this guy later, using worklist
a61af66fc99e Initial load duke parents: diff changeset	3089 }
a61af66fc99e Initial load duke parents: diff changeset	3090 }
a61af66fc99e Initial load duke parents: diff changeset	3091 if (done) {
a61af66fc99e Initial load duke parents: diff changeset	3092 // All of n's inputs have been processed, complete post-processing.
a61af66fc99e Initial load duke parents: diff changeset	3093
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3094 // Compute earliest point this Node can go.
0 a61af66fc99e Initial load duke parents: diff changeset	3095 // CFG, Phi, pinned nodes already know their controlling input.
a61af66fc99e Initial load duke parents: diff changeset	3096 if (!has_node(n)) {
a61af66fc99e Initial load duke parents: diff changeset	3097 // Record earliest legal location
a61af66fc99e Initial load duke parents: diff changeset	3098 set_early_ctrl( n );
a61af66fc99e Initial load duke parents: diff changeset	3099 }
a61af66fc99e Initial load duke parents: diff changeset	3100 if (nstack.is_empty()) {
a61af66fc99e Initial load duke parents: diff changeset	3101 // Finished all nodes on stack.
a61af66fc99e Initial load duke parents: diff changeset	3102 // Process next node on the worklist.
a61af66fc99e Initial load duke parents: diff changeset	3103 break;
a61af66fc99e Initial load duke parents: diff changeset	3104 }
a61af66fc99e Initial load duke parents: diff changeset	3105 // Get saved parent node and next input's index.
a61af66fc99e Initial load duke parents: diff changeset	3106 nstack_top_n = nstack.node();
a61af66fc99e Initial load duke parents: diff changeset	3107 nstack_top_i = nstack.index();
a61af66fc99e Initial load duke parents: diff changeset	3108 nstack.pop();
a61af66fc99e Initial load duke parents: diff changeset	3109 }
a61af66fc99e Initial load duke parents: diff changeset	3110 } // while (true)
a61af66fc99e Initial load duke parents: diff changeset	3111 }
a61af66fc99e Initial load duke parents: diff changeset	3112 }
a61af66fc99e Initial load duke parents: diff changeset	3113
a61af66fc99e Initial load duke parents: diff changeset	3114 //------------------------------dom_lca_internal--------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3115 // Pair-wise LCA
a61af66fc99e Initial load duke parents: diff changeset	3116 Node PhaseIdealLoop::dom_lca_internal( Node n1, Node *n2 ) const {
a61af66fc99e Initial load duke parents: diff changeset	3117 if( !n1 ) return n2; // Handle NULL original LCA
a61af66fc99e Initial load duke parents: diff changeset	3118 assert( n1->is_CFG(), "" );
a61af66fc99e Initial load duke parents: diff changeset	3119 assert( n2->is_CFG(), "" );
a61af66fc99e Initial load duke parents: diff changeset	3120 // find LCA of all uses
a61af66fc99e Initial load duke parents: diff changeset	3121 uint d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3122 uint d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3123 while (n1 != n2) {
a61af66fc99e Initial load duke parents: diff changeset	3124 if (d1 > d2) {
a61af66fc99e Initial load duke parents: diff changeset	3125 n1 = idom(n1);
a61af66fc99e Initial load duke parents: diff changeset	3126 d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3127 } else if (d1 < d2) {
a61af66fc99e Initial load duke parents: diff changeset	3128 n2 = idom(n2);
a61af66fc99e Initial load duke parents: diff changeset	3129 d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3130 } else {
a61af66fc99e Initial load duke parents: diff changeset	3131 // Here d1 == d2. Due to edits of the dominator-tree, sections
a61af66fc99e Initial load duke parents: diff changeset	3132 // of the tree might have the same depth. These sections have
a61af66fc99e Initial load duke parents: diff changeset	3133 // to be searched more carefully.
a61af66fc99e Initial load duke parents: diff changeset	3134
a61af66fc99e Initial load duke parents: diff changeset	3135 // Scan up all the n1's with equal depth, looking for n2.
a61af66fc99e Initial load duke parents: diff changeset	3136 Node *t1 = idom(n1);
a61af66fc99e Initial load duke parents: diff changeset	3137 while (dom_depth(t1) == d1) {
a61af66fc99e Initial load duke parents: diff changeset	3138 if (t1 == n2) return n2;
a61af66fc99e Initial load duke parents: diff changeset	3139 t1 = idom(t1);
a61af66fc99e Initial load duke parents: diff changeset	3140 }
a61af66fc99e Initial load duke parents: diff changeset	3141 // Scan up all the n2's with equal depth, looking for n1.
a61af66fc99e Initial load duke parents: diff changeset	3142 Node *t2 = idom(n2);
a61af66fc99e Initial load duke parents: diff changeset	3143 while (dom_depth(t2) == d2) {
a61af66fc99e Initial load duke parents: diff changeset	3144 if (t2 == n1) return n1;
a61af66fc99e Initial load duke parents: diff changeset	3145 t2 = idom(t2);
a61af66fc99e Initial load duke parents: diff changeset	3146 }
a61af66fc99e Initial load duke parents: diff changeset	3147 // Move up to a new dominator-depth value as well as up the dom-tree.
a61af66fc99e Initial load duke parents: diff changeset	3148 n1 = t1;
a61af66fc99e Initial load duke parents: diff changeset	3149 n2 = t2;
a61af66fc99e Initial load duke parents: diff changeset	3150 d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3151 d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3152 }
a61af66fc99e Initial load duke parents: diff changeset	3153 }
a61af66fc99e Initial load duke parents: diff changeset	3154 return n1;
a61af66fc99e Initial load duke parents: diff changeset	3155 }
a61af66fc99e Initial load duke parents: diff changeset	3156
a61af66fc99e Initial load duke parents: diff changeset	3157 //------------------------------compute_idom-----------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3158 // Locally compute IDOM using dom_lca call. Correct only if the incoming
a61af66fc99e Initial load duke parents: diff changeset	3159 // IDOMs are correct.
a61af66fc99e Initial load duke parents: diff changeset	3160 Node PhaseIdealLoop::compute_idom( Node region ) const {
a61af66fc99e Initial load duke parents: diff changeset	3161 assert( region->is_Region(), "" );
a61af66fc99e Initial load duke parents: diff changeset	3162 Node *LCA = NULL;
a61af66fc99e Initial load duke parents: diff changeset	3163 for( uint i = 1; i < region->req(); i++ ) {
a61af66fc99e Initial load duke parents: diff changeset	3164 if( region->in(i) != C->top() )
a61af66fc99e Initial load duke parents: diff changeset	3165 LCA = dom_lca( LCA, region->in(i) );
a61af66fc99e Initial load duke parents: diff changeset	3166 }
a61af66fc99e Initial load duke parents: diff changeset	3167 return LCA;
a61af66fc99e Initial load duke parents: diff changeset	3168 }
a61af66fc99e Initial load duke parents: diff changeset	3169
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3170 bool PhaseIdealLoop::verify_dominance(Node* n, Node* use, Node* LCA, Node* early) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3171 bool had_error = false;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3172 #ifdef ASSERT
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3173 if (early != C->root()) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3174 // Make sure that there's a dominance path from use to LCA
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3175 Node* d = use;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3176 while (d != LCA) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3177 d = idom(d);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3178 if (d == C->root()) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3179 tty->print_cr("*** Use %d isn't dominated by def %s", use->_idx, n->_idx);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3180 n->dump();
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3181 use->dump();
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3182 had_error = true;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3183 break;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3184 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3185 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3186 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3187 #endif
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3188 return had_error;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3189 }
0 a61af66fc99e Initial load duke parents: diff changeset	3190
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3191
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3192 Node* PhaseIdealLoop::compute_lca_of_uses(Node* n, Node* early, bool verify) {
0 a61af66fc99e Initial load duke parents: diff changeset	3193 // Compute LCA over list of uses
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3194 bool had_error = false;
0 a61af66fc99e Initial load duke parents: diff changeset	3195 Node *LCA = NULL;
a61af66fc99e Initial load duke parents: diff changeset	3196 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax && LCA != early; i++) {
a61af66fc99e Initial load duke parents: diff changeset	3197 Node* c = n->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	3198 if (_nodes[c->_idx] == NULL)
a61af66fc99e Initial load duke parents: diff changeset	3199 continue; // Skip the occasional dead node
a61af66fc99e Initial load duke parents: diff changeset	3200 if( c->is_Phi() ) { // For Phis, we must land above on the path
a61af66fc99e Initial load duke parents: diff changeset	3201 for( uint j=1; j<c->req(); j++ ) {// For all inputs
a61af66fc99e Initial load duke parents: diff changeset	3202 if( c->in(j) == n ) { // Found matching input?
a61af66fc99e Initial load duke parents: diff changeset	3203 Node *use = c->in(0)->in(j);
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3204 if (_verify_only && use->is_top()) continue;
0 a61af66fc99e Initial load duke parents: diff changeset	3205 LCA = dom_lca_for_get_late_ctrl( LCA, use, n );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3206 if (verify) had_error = verify_dominance(n, use, LCA, early) \|\| had_error;
0 a61af66fc99e Initial load duke parents: diff changeset	3207 }
a61af66fc99e Initial load duke parents: diff changeset	3208 }
a61af66fc99e Initial load duke parents: diff changeset	3209 } else {
a61af66fc99e Initial load duke parents: diff changeset	3210 // For CFG data-users, use is in the block just prior
a61af66fc99e Initial load duke parents: diff changeset	3211 Node *use = has_ctrl(c) ? get_ctrl(c) : c->in(0);
a61af66fc99e Initial load duke parents: diff changeset	3212 LCA = dom_lca_for_get_late_ctrl( LCA, use, n );
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3213 if (verify) had_error = verify_dominance(n, use, LCA, early) \|\| had_error;
0 a61af66fc99e Initial load duke parents: diff changeset	3214 }
a61af66fc99e Initial load duke parents: diff changeset	3215 }
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3216 assert(!had_error, "bad dominance");
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3217 return LCA;
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3218 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3219
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3220 //------------------------------get_late_ctrl----------------------------------
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3221 // Compute latest legal control.
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3222 Node PhaseIdealLoop::get_late_ctrl( Node n, Node *early ) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3223 assert(early != NULL, "early control should not be NULL");
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3224
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3225 Node* LCA = compute_lca_of_uses(n, early);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3226 #ifdef ASSERT
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3227 if (LCA == C->root() && LCA != early) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3228 // def doesn't dominate uses so print some useful debugging output
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3229 compute_lca_of_uses(n, early, true);
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3230 }
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3231 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	3232
a61af66fc99e Initial load duke parents: diff changeset	3233 // if this is a load, check for anti-dependent stores
a61af66fc99e Initial load duke parents: diff changeset	3234 // We use a conservative algorithm to identify potential interfering
a61af66fc99e Initial load duke parents: diff changeset	3235 // instructions and for rescheduling the load. The users of the memory
a61af66fc99e Initial load duke parents: diff changeset	3236 // input of this load are examined. Any use which is not a load and is
a61af66fc99e Initial load duke parents: diff changeset	3237 // dominated by early is considered a potentially interfering store.
a61af66fc99e Initial load duke parents: diff changeset	3238 // This can produce false positives.
a61af66fc99e Initial load duke parents: diff changeset	3239 if (n->is_Load() && LCA != early) {
a61af66fc99e Initial load duke parents: diff changeset	3240 Node_List worklist;
a61af66fc99e Initial load duke parents: diff changeset	3241
a61af66fc99e Initial load duke parents: diff changeset	3242 Node *mem = n->in(MemNode::Memory);
a61af66fc99e Initial load duke parents: diff changeset	3243 for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	3244 Node* s = mem->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	3245 worklist.push(s);
a61af66fc99e Initial load duke parents: diff changeset	3246 }
a61af66fc99e Initial load duke parents: diff changeset	3247 while(worklist.size() != 0 && LCA != early) {
a61af66fc99e Initial load duke parents: diff changeset	3248 Node* s = worklist.pop();
a61af66fc99e Initial load duke parents: diff changeset	3249 if (s->is_Load()) {
a61af66fc99e Initial load duke parents: diff changeset	3250 continue;
a61af66fc99e Initial load duke parents: diff changeset	3251 } else if (s->is_MergeMem()) {
a61af66fc99e Initial load duke parents: diff changeset	3252 for (DUIterator_Fast imax, i = s->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load duke parents: diff changeset	3253 Node* s1 = s->fast_out(i);
a61af66fc99e Initial load duke parents: diff changeset	3254 worklist.push(s1);
a61af66fc99e Initial load duke parents: diff changeset	3255 }
a61af66fc99e Initial load duke parents: diff changeset	3256 } else {
a61af66fc99e Initial load duke parents: diff changeset	3257 Node *sctrl = has_ctrl(s) ? get_ctrl(s) : s->in(0);
a61af66fc99e Initial load duke parents: diff changeset	3258 assert(sctrl != NULL \|\| s->outcnt() == 0, "must have control");
a61af66fc99e Initial load duke parents: diff changeset	3259 if (sctrl != NULL && !sctrl->is_top() && is_dominator(early, sctrl)) {
a61af66fc99e Initial load duke parents: diff changeset	3260 LCA = dom_lca_for_get_late_ctrl(LCA, sctrl, n);
a61af66fc99e Initial load duke parents: diff changeset	3261 }
a61af66fc99e Initial load duke parents: diff changeset	3262 }
a61af66fc99e Initial load duke parents: diff changeset	3263 }
a61af66fc99e Initial load duke parents: diff changeset	3264 }
a61af66fc99e Initial load duke parents: diff changeset	3265
a61af66fc99e Initial load duke parents: diff changeset	3266 assert(LCA == find_non_split_ctrl(LCA), "unexpected late control");
a61af66fc99e Initial load duke parents: diff changeset	3267 return LCA;
a61af66fc99e Initial load duke parents: diff changeset	3268 }
a61af66fc99e Initial load duke parents: diff changeset	3269
a61af66fc99e Initial load duke parents: diff changeset	3270 // true if CFG node d dominates CFG node n
a61af66fc99e Initial load duke parents: diff changeset	3271 bool PhaseIdealLoop::is_dominator(Node d, Node n) {
a61af66fc99e Initial load duke parents: diff changeset	3272 if (d == n)
a61af66fc99e Initial load duke parents: diff changeset	3273 return true;
a61af66fc99e Initial load duke parents: diff changeset	3274 assert(d->is_CFG() && n->is_CFG(), "must have CFG nodes");
a61af66fc99e Initial load duke parents: diff changeset	3275 uint dd = dom_depth(d);
a61af66fc99e Initial load duke parents: diff changeset	3276 while (dom_depth(n) >= dd) {
a61af66fc99e Initial load duke parents: diff changeset	3277 if (n == d)
a61af66fc99e Initial load duke parents: diff changeset	3278 return true;
a61af66fc99e Initial load duke parents: diff changeset	3279 n = idom(n);
a61af66fc99e Initial load duke parents: diff changeset	3280 }
a61af66fc99e Initial load duke parents: diff changeset	3281 return false;
a61af66fc99e Initial load duke parents: diff changeset	3282 }
a61af66fc99e Initial load duke parents: diff changeset	3283
a61af66fc99e Initial load duke parents: diff changeset	3284 //------------------------------dom_lca_for_get_late_ctrl_internal-------------
a61af66fc99e Initial load duke parents: diff changeset	3285 // Pair-wise LCA with tags.
a61af66fc99e Initial load duke parents: diff changeset	3286 // Tag each index with the node 'tag' currently being processed
a61af66fc99e Initial load duke parents: diff changeset	3287 // before advancing up the dominator chain using idom().
a61af66fc99e Initial load duke parents: diff changeset	3288 // Later calls that find a match to 'tag' know that this path has already
a61af66fc99e Initial load duke parents: diff changeset	3289 // been considered in the current LCA (which is input 'n1' by convention).
a61af66fc99e Initial load duke parents: diff changeset	3290 // Since get_late_ctrl() is only called once for each node, the tag array
a61af66fc99e Initial load duke parents: diff changeset	3291 // does not need to be cleared between calls to get_late_ctrl().
a61af66fc99e Initial load duke parents: diff changeset	3292 // Algorithm trades a larger constant factor for better asymptotic behavior
a61af66fc99e Initial load duke parents: diff changeset	3293 //
a61af66fc99e Initial load duke parents: diff changeset	3294 Node PhaseIdealLoop::dom_lca_for_get_late_ctrl_internal( Node n1, Node n2, Node tag ) {
a61af66fc99e Initial load duke parents: diff changeset	3295 uint d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3296 uint d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3297
a61af66fc99e Initial load duke parents: diff changeset	3298 do {
a61af66fc99e Initial load duke parents: diff changeset	3299 if (d1 > d2) {
a61af66fc99e Initial load duke parents: diff changeset	3300 // current lca is deeper than n2
a61af66fc99e Initial load duke parents: diff changeset	3301 _dom_lca_tags.map(n1->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3302 n1 = idom(n1);
a61af66fc99e Initial load duke parents: diff changeset	3303 d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3304 } else if (d1 < d2) {
a61af66fc99e Initial load duke parents: diff changeset	3305 // n2 is deeper than current lca
a61af66fc99e Initial load duke parents: diff changeset	3306 Node *memo = _dom_lca_tags[n2->_idx];
a61af66fc99e Initial load duke parents: diff changeset	3307 if( memo == tag ) {
a61af66fc99e Initial load duke parents: diff changeset	3308 return n1; // Return the current LCA
a61af66fc99e Initial load duke parents: diff changeset	3309 }
a61af66fc99e Initial load duke parents: diff changeset	3310 _dom_lca_tags.map(n2->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3311 n2 = idom(n2);
a61af66fc99e Initial load duke parents: diff changeset	3312 d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3313 } else {
a61af66fc99e Initial load duke parents: diff changeset	3314 // Here d1 == d2. Due to edits of the dominator-tree, sections
a61af66fc99e Initial load duke parents: diff changeset	3315 // of the tree might have the same depth. These sections have
a61af66fc99e Initial load duke parents: diff changeset	3316 // to be searched more carefully.
a61af66fc99e Initial load duke parents: diff changeset	3317
a61af66fc99e Initial load duke parents: diff changeset	3318 // Scan up all the n1's with equal depth, looking for n2.
a61af66fc99e Initial load duke parents: diff changeset	3319 _dom_lca_tags.map(n1->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3320 Node *t1 = idom(n1);
a61af66fc99e Initial load duke parents: diff changeset	3321 while (dom_depth(t1) == d1) {
a61af66fc99e Initial load duke parents: diff changeset	3322 if (t1 == n2) return n2;
a61af66fc99e Initial load duke parents: diff changeset	3323 _dom_lca_tags.map(t1->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3324 t1 = idom(t1);
a61af66fc99e Initial load duke parents: diff changeset	3325 }
a61af66fc99e Initial load duke parents: diff changeset	3326 // Scan up all the n2's with equal depth, looking for n1.
a61af66fc99e Initial load duke parents: diff changeset	3327 _dom_lca_tags.map(n2->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3328 Node *t2 = idom(n2);
a61af66fc99e Initial load duke parents: diff changeset	3329 while (dom_depth(t2) == d2) {
a61af66fc99e Initial load duke parents: diff changeset	3330 if (t2 == n1) return n1;
a61af66fc99e Initial load duke parents: diff changeset	3331 _dom_lca_tags.map(t2->_idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	3332 t2 = idom(t2);
a61af66fc99e Initial load duke parents: diff changeset	3333 }
a61af66fc99e Initial load duke parents: diff changeset	3334 // Move up to a new dominator-depth value as well as up the dom-tree.
a61af66fc99e Initial load duke parents: diff changeset	3335 n1 = t1;
a61af66fc99e Initial load duke parents: diff changeset	3336 n2 = t2;
a61af66fc99e Initial load duke parents: diff changeset	3337 d1 = dom_depth(n1);
a61af66fc99e Initial load duke parents: diff changeset	3338 d2 = dom_depth(n2);
a61af66fc99e Initial load duke parents: diff changeset	3339 }
a61af66fc99e Initial load duke parents: diff changeset	3340 } while (n1 != n2);
a61af66fc99e Initial load duke parents: diff changeset	3341 return n1;
a61af66fc99e Initial load duke parents: diff changeset	3342 }
a61af66fc99e Initial load duke parents: diff changeset	3343
a61af66fc99e Initial load duke parents: diff changeset	3344 //------------------------------init_dom_lca_tags------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3345 // Tag could be a node's integer index, 32bits instead of 64bits in some cases
a61af66fc99e Initial load duke parents: diff changeset	3346 // Intended use does not involve any growth for the array, so it could
a61af66fc99e Initial load duke parents: diff changeset	3347 // be of fixed size.
a61af66fc99e Initial load duke parents: diff changeset	3348 void PhaseIdealLoop::init_dom_lca_tags() {
a61af66fc99e Initial load duke parents: diff changeset	3349 uint limit = C->unique() + 1;
a61af66fc99e Initial load duke parents: diff changeset	3350 _dom_lca_tags.map( limit, NULL );
a61af66fc99e Initial load duke parents: diff changeset	3351 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3352 for( uint i = 0; i < limit; ++i ) {
a61af66fc99e Initial load duke parents: diff changeset	3353 assert(_dom_lca_tags[i] == NULL, "Must be distinct from each node pointer");
a61af66fc99e Initial load duke parents: diff changeset	3354 }
a61af66fc99e Initial load duke parents: diff changeset	3355 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3356 }
a61af66fc99e Initial load duke parents: diff changeset	3357
a61af66fc99e Initial load duke parents: diff changeset	3358 //------------------------------clear_dom_lca_tags------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3359 // Tag could be a node's integer index, 32bits instead of 64bits in some cases
a61af66fc99e Initial load duke parents: diff changeset	3360 // Intended use does not involve any growth for the array, so it could
a61af66fc99e Initial load duke parents: diff changeset	3361 // be of fixed size.
a61af66fc99e Initial load duke parents: diff changeset	3362 void PhaseIdealLoop::clear_dom_lca_tags() {
a61af66fc99e Initial load duke parents: diff changeset	3363 uint limit = C->unique() + 1;
a61af66fc99e Initial load duke parents: diff changeset	3364 _dom_lca_tags.map( limit, NULL );
a61af66fc99e Initial load duke parents: diff changeset	3365 _dom_lca_tags.clear();
a61af66fc99e Initial load duke parents: diff changeset	3366 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3367 for( uint i = 0; i < limit; ++i ) {
a61af66fc99e Initial load duke parents: diff changeset	3368 assert(_dom_lca_tags[i] == NULL, "Must be distinct from each node pointer");
a61af66fc99e Initial load duke parents: diff changeset	3369 }
a61af66fc99e Initial load duke parents: diff changeset	3370 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3371 }
a61af66fc99e Initial load duke parents: diff changeset	3372
a61af66fc99e Initial load duke parents: diff changeset	3373 //------------------------------build_loop_late--------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3374 // Put Data nodes into some loop nest, by setting the _nodes[]->loop mapping.
a61af66fc99e Initial load duke parents: diff changeset	3375 // Second pass finds latest legal placement, and ideal loop placement.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3376 void PhaseIdealLoop::build_loop_late( VectorSet &visited, Node_List &worklist, Node_Stack &nstack ) {
0 a61af66fc99e Initial load duke parents: diff changeset	3377 while (worklist.size() != 0) {
a61af66fc99e Initial load duke parents: diff changeset	3378 Node *n = worklist.pop();
a61af66fc99e Initial load duke parents: diff changeset	3379 // Only visit once
a61af66fc99e Initial load duke parents: diff changeset	3380 if (visited.test_set(n->_idx)) continue;
a61af66fc99e Initial load duke parents: diff changeset	3381 uint cnt = n->outcnt();
a61af66fc99e Initial load duke parents: diff changeset	3382 uint i = 0;
a61af66fc99e Initial load duke parents: diff changeset	3383 while (true) {
a61af66fc99e Initial load duke parents: diff changeset	3384 assert( _nodes[n->_idx], "no dead nodes" );
a61af66fc99e Initial load duke parents: diff changeset	3385 // Visit all children
a61af66fc99e Initial load duke parents: diff changeset	3386 if (i < cnt) {
a61af66fc99e Initial load duke parents: diff changeset	3387 Node* use = n->raw_out(i);
a61af66fc99e Initial load duke parents: diff changeset	3388 ++i;
a61af66fc99e Initial load duke parents: diff changeset	3389 // Check for dead uses. Aggressively prune such junk. It might be
a61af66fc99e Initial load duke parents: diff changeset	3390 // dead in the global sense, but still have local uses so I cannot
a61af66fc99e Initial load duke parents: diff changeset	3391 // easily call 'remove_dead_node'.
a61af66fc99e Initial load duke parents: diff changeset	3392 if( _nodes[use->_idx] != NULL \|\| use->is_top() ) { // Not dead?
a61af66fc99e Initial load duke parents: diff changeset	3393 // Due to cycles, we might not hit the same fixed point in the verify
a61af66fc99e Initial load duke parents: diff changeset	3394 // pass as we do in the regular pass. Instead, visit such phis as
a61af66fc99e Initial load duke parents: diff changeset	3395 // simple uses of the loop head.
a61af66fc99e Initial load duke parents: diff changeset	3396 if( use->in(0) && (use->is_CFG() \|\| use->is_Phi()) ) {
a61af66fc99e Initial load duke parents: diff changeset	3397 if( !visited.test(use->_idx) )
a61af66fc99e Initial load duke parents: diff changeset	3398 worklist.push(use);
a61af66fc99e Initial load duke parents: diff changeset	3399 } else if( !visited.test_set(use->_idx) ) {
a61af66fc99e Initial load duke parents: diff changeset	3400 nstack.push(n, i); // Save parent and next use's index.
a61af66fc99e Initial load duke parents: diff changeset	3401 n = use; // Process all children of current use.
a61af66fc99e Initial load duke parents: diff changeset	3402 cnt = use->outcnt();
a61af66fc99e Initial load duke parents: diff changeset	3403 i = 0;
a61af66fc99e Initial load duke parents: diff changeset	3404 }
a61af66fc99e Initial load duke parents: diff changeset	3405 } else {
a61af66fc99e Initial load duke parents: diff changeset	3406 // Do not visit around the backedge of loops via data edges.
a61af66fc99e Initial load duke parents: diff changeset	3407 // push dead code onto a worklist
a61af66fc99e Initial load duke parents: diff changeset	3408 _deadlist.push(use);
a61af66fc99e Initial load duke parents: diff changeset	3409 }
a61af66fc99e Initial load duke parents: diff changeset	3410 } else {
a61af66fc99e Initial load duke parents: diff changeset	3411 // All of n's children have been processed, complete post-processing.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3412 build_loop_late_post(n);
0 a61af66fc99e Initial load duke parents: diff changeset	3413 if (nstack.is_empty()) {
a61af66fc99e Initial load duke parents: diff changeset	3414 // Finished all nodes on stack.
a61af66fc99e Initial load duke parents: diff changeset	3415 // Process next node on the worklist.
a61af66fc99e Initial load duke parents: diff changeset	3416 break;
a61af66fc99e Initial load duke parents: diff changeset	3417 }
a61af66fc99e Initial load duke parents: diff changeset	3418 // Get saved parent node and next use's index. Visit the rest of uses.
a61af66fc99e Initial load duke parents: diff changeset	3419 n = nstack.node();
a61af66fc99e Initial load duke parents: diff changeset	3420 cnt = n->outcnt();
a61af66fc99e Initial load duke parents: diff changeset	3421 i = nstack.index();
a61af66fc99e Initial load duke parents: diff changeset	3422 nstack.pop();
a61af66fc99e Initial load duke parents: diff changeset	3423 }
a61af66fc99e Initial load duke parents: diff changeset	3424 }
a61af66fc99e Initial load duke parents: diff changeset	3425 }
a61af66fc99e Initial load duke parents: diff changeset	3426 }
a61af66fc99e Initial load duke parents: diff changeset	3427
a61af66fc99e Initial load duke parents: diff changeset	3428 //------------------------------build_loop_late_post---------------------------
a61af66fc99e Initial load duke parents: diff changeset	3429 // Put Data nodes into some loop nest, by setting the _nodes[]->loop mapping.
a61af66fc99e Initial load duke parents: diff changeset	3430 // Second pass finds latest legal placement, and ideal loop placement.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3431 void PhaseIdealLoop::build_loop_late_post( Node *n ) {
0 a61af66fc99e Initial load duke parents: diff changeset	3432
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3433 if (n->req() == 2 && n->Opcode() == Op_ConvI2L && !C->major_progress() && !_verify_only) {
0 a61af66fc99e Initial load duke parents: diff changeset	3434 _igvn._worklist.push(n); // Maybe we'll normalize it, if no more loops.
a61af66fc99e Initial load duke parents: diff changeset	3435 }
a61af66fc99e Initial load duke parents: diff changeset	3436
a61af66fc99e Initial load duke parents: diff changeset	3437 // CFG and pinned nodes already handled
a61af66fc99e Initial load duke parents: diff changeset	3438 if( n->in(0) ) {
a61af66fc99e Initial load duke parents: diff changeset	3439 if( n->in(0)->is_top() ) return; // Dead?
a61af66fc99e Initial load duke parents: diff changeset	3440
a61af66fc99e Initial load duke parents: diff changeset	3441 // We'd like +VerifyLoopOptimizations to not believe that Mod's/Loads
a61af66fc99e Initial load duke parents: diff changeset	3442 // _must_ be pinned (they have to observe their control edge of course).
a61af66fc99e Initial load duke parents: diff changeset	3443 // Unlike Stores (which modify an unallocable resource, the memory
a61af66fc99e Initial load duke parents: diff changeset	3444 // state), Mods/Loads can float around. So free them up.
a61af66fc99e Initial load duke parents: diff changeset	3445 bool pinned = true;
a61af66fc99e Initial load duke parents: diff changeset	3446 switch( n->Opcode() ) {
a61af66fc99e Initial load duke parents: diff changeset	3447 case Op_DivI:
a61af66fc99e Initial load duke parents: diff changeset	3448 case Op_DivF:
a61af66fc99e Initial load duke parents: diff changeset	3449 case Op_DivD:
a61af66fc99e Initial load duke parents: diff changeset	3450 case Op_ModI:
a61af66fc99e Initial load duke parents: diff changeset	3451 case Op_ModF:
a61af66fc99e Initial load duke parents: diff changeset	3452 case Op_ModD:
a61af66fc99e Initial load duke parents: diff changeset	3453 case Op_LoadB: // Same with Loads; they can sink
6179 8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 6144 diff changeset	3454 case Op_LoadUB: // during loop optimizations.
8c92982cbbc4 7119644: Increase superword's vector size up to 256 bits kvn parents: 6144 diff changeset	3455 case Op_LoadUS:
0 a61af66fc99e Initial load duke parents: diff changeset	3456 case Op_LoadD:
a61af66fc99e Initial load duke parents: diff changeset	3457 case Op_LoadF:
a61af66fc99e Initial load duke parents: diff changeset	3458 case Op_LoadI:
a61af66fc99e Initial load duke parents: diff changeset	3459 case Op_LoadKlass:
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 235 diff changeset	3460 case Op_LoadNKlass:
0 a61af66fc99e Initial load duke parents: diff changeset	3461 case Op_LoadL:
a61af66fc99e Initial load duke parents: diff changeset	3462 case Op_LoadS:
a61af66fc99e Initial load duke parents: diff changeset	3463 case Op_LoadP:
293 c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type") kvn parents: 235 diff changeset	3464 case Op_LoadN:
0 a61af66fc99e Initial load duke parents: diff changeset	3465 case Op_LoadRange:
a61af66fc99e Initial load duke parents: diff changeset	3466 case Op_LoadD_unaligned:
a61af66fc99e Initial load duke parents: diff changeset	3467 case Op_LoadL_unaligned:
a61af66fc99e Initial load duke parents: diff changeset	3468 case Op_StrComp: // Does a bunch of load-like effects
681 fbde8ec322d0 6761600: Use sse 4.2 in intrinsics cfang parents: 628 diff changeset	3469 case Op_StrEquals:
fbde8ec322d0 6761600: Use sse 4.2 in intrinsics cfang parents: 628 diff changeset	3470 case Op_StrIndexOf:
169 9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals rasbold parents: 39 diff changeset	3471 case Op_AryEq:
0 a61af66fc99e Initial load duke parents: diff changeset	3472 pinned = false;
a61af66fc99e Initial load duke parents: diff changeset	3473 }
a61af66fc99e Initial load duke parents: diff changeset	3474 if( pinned ) {
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3475 IdealLoopTree *chosen_loop = get_loop(n->is_CFG() ? n : get_ctrl(n));
98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3476 if( !chosen_loop->_child ) // Inner loop?
98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3477 chosen_loop->_body.push(n); // Collect inner loops
0 a61af66fc99e Initial load duke parents: diff changeset	3478 return;
a61af66fc99e Initial load duke parents: diff changeset	3479 }
a61af66fc99e Initial load duke parents: diff changeset	3480 } else { // No slot zero
a61af66fc99e Initial load duke parents: diff changeset	3481 if( n->is_CFG() ) { // CFG with no slot 0 is dead
a61af66fc99e Initial load duke parents: diff changeset	3482 _nodes.map(n->_idx,0); // No block setting, it's globally dead
a61af66fc99e Initial load duke parents: diff changeset	3483 return;
a61af66fc99e Initial load duke parents: diff changeset	3484 }
a61af66fc99e Initial load duke parents: diff changeset	3485 assert(!n->is_CFG() \|\| n->outcnt() == 0, "");
a61af66fc99e Initial load duke parents: diff changeset	3486 }
a61af66fc99e Initial load duke parents: diff changeset	3487
a61af66fc99e Initial load duke parents: diff changeset	3488 // Do I have a "safe range" I can select over?
a61af66fc99e Initial load duke parents: diff changeset	3489 Node *early = get_ctrl(n);// Early location already computed
a61af66fc99e Initial load duke parents: diff changeset	3490
a61af66fc99e Initial load duke parents: diff changeset	3491 // Compute latest point this Node can go
a61af66fc99e Initial load duke parents: diff changeset	3492 Node *LCA = get_late_ctrl( n, early );
a61af66fc99e Initial load duke parents: diff changeset	3493 // LCA is NULL due to uses being dead
a61af66fc99e Initial load duke parents: diff changeset	3494 if( LCA == NULL ) {
a61af66fc99e Initial load duke parents: diff changeset	3495 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3496 for (DUIterator i1 = n->outs(); n->has_out(i1); i1++) {
a61af66fc99e Initial load duke parents: diff changeset	3497 assert( _nodes[n->out(i1)->_idx] == NULL, "all uses must also be dead");
a61af66fc99e Initial load duke parents: diff changeset	3498 }
a61af66fc99e Initial load duke parents: diff changeset	3499 #endif
a61af66fc99e Initial load duke parents: diff changeset	3500 _nodes.map(n->_idx, 0); // This node is useless
a61af66fc99e Initial load duke parents: diff changeset	3501 _deadlist.push(n);
a61af66fc99e Initial load duke parents: diff changeset	3502 return;
a61af66fc99e Initial load duke parents: diff changeset	3503 }
a61af66fc99e Initial load duke parents: diff changeset	3504 assert(LCA != NULL && !LCA->is_top(), "no dead nodes");
a61af66fc99e Initial load duke parents: diff changeset	3505
a61af66fc99e Initial load duke parents: diff changeset	3506 Node *legal = LCA; // Walk 'legal' up the IDOM chain
a61af66fc99e Initial load duke parents: diff changeset	3507 Node *least = legal; // Best legal position so far
a61af66fc99e Initial load duke parents: diff changeset	3508 while( early != legal ) { // While not at earliest legal
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3509 #ifdef ASSERT
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3510 if (legal->is_Start() && !early->is_Root()) {
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3511 // Bad graph. Print idom path and fail.
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	3512 dump_bad_graph("Bad graph detected in build_loop_late", n, early, LCA);
1172 b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3513 assert(false, "Bad graph detected in build_loop_late");
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3514 }
b2b6a9bf6238 6894779: Loop Predication for Loop Optimizer in C2 cfang parents: 1083 diff changeset	3515 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	3516 // Find least loop nesting depth
a61af66fc99e Initial load duke parents: diff changeset	3517 legal = idom(legal); // Bump up the IDOM tree
a61af66fc99e Initial load duke parents: diff changeset	3518 // Check for lower nesting depth
a61af66fc99e Initial load duke parents: diff changeset	3519 if( get_loop(legal)->_nest < get_loop(least)->_nest )
a61af66fc99e Initial load duke parents: diff changeset	3520 least = legal;
a61af66fc99e Initial load duke parents: diff changeset	3521 }
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3522 assert(early == legal \|\| legal != C->root(), "bad dominance of inputs");
0 a61af66fc99e Initial load duke parents: diff changeset	3523
a61af66fc99e Initial load duke parents: diff changeset	3524 // Try not to place code on a loop entry projection
a61af66fc99e Initial load duke parents: diff changeset	3525 // which can inhibit range check elimination.
a61af66fc99e Initial load duke parents: diff changeset	3526 if (least != early) {
a61af66fc99e Initial load duke parents: diff changeset	3527 Node* ctrl_out = least->unique_ctrl_out();
a61af66fc99e Initial load duke parents: diff changeset	3528 if (ctrl_out && ctrl_out->is_CountedLoop() &&
a61af66fc99e Initial load duke parents: diff changeset	3529 least == ctrl_out->in(LoopNode::EntryControl)) {
a61af66fc99e Initial load duke parents: diff changeset	3530 Node* least_dom = idom(least);
a61af66fc99e Initial load duke parents: diff changeset	3531 if (get_loop(least_dom)->is_member(get_loop(least))) {
a61af66fc99e Initial load duke parents: diff changeset	3532 least = least_dom;
a61af66fc99e Initial load duke parents: diff changeset	3533 }
a61af66fc99e Initial load duke parents: diff changeset	3534 }
a61af66fc99e Initial load duke parents: diff changeset	3535 }
a61af66fc99e Initial load duke parents: diff changeset	3536
a61af66fc99e Initial load duke parents: diff changeset	3537 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	3538 // If verifying, verify that 'verify_me' has a legal location
a61af66fc99e Initial load duke parents: diff changeset	3539 // and choose it as our location.
921 046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3540 if( _verify_me ) {
046932b72aa2 6862956: PhaseIdealLoop should have a CFG verification mode never parents: 681 diff changeset	3541 Node *v_ctrl = _verify_me->get_ctrl_no_update(n);
0 a61af66fc99e Initial load duke parents: diff changeset	3542 Node *legal = LCA;
a61af66fc99e Initial load duke parents: diff changeset	3543 while( early != legal ) { // While not at earliest legal
a61af66fc99e Initial load duke parents: diff changeset	3544 if( legal == v_ctrl ) break; // Check for prior good location
a61af66fc99e Initial load duke parents: diff changeset	3545 legal = idom(legal) ;// Bump up the IDOM tree
a61af66fc99e Initial load duke parents: diff changeset	3546 }
a61af66fc99e Initial load duke parents: diff changeset	3547 // Check for prior good location
a61af66fc99e Initial load duke parents: diff changeset	3548 if( legal == v_ctrl ) least = legal; // Keep prior if found
a61af66fc99e Initial load duke parents: diff changeset	3549 }
a61af66fc99e Initial load duke parents: diff changeset	3550 #endif
a61af66fc99e Initial load duke parents: diff changeset	3551
a61af66fc99e Initial load duke parents: diff changeset	3552 // Assign discovered "here or above" point
a61af66fc99e Initial load duke parents: diff changeset	3553 least = find_non_split_ctrl(least);
a61af66fc99e Initial load duke parents: diff changeset	3554 set_ctrl(n, least);
a61af66fc99e Initial load duke parents: diff changeset	3555
a61af66fc99e Initial load duke parents: diff changeset	3556 // Collect inner loop bodies
605 98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3557 IdealLoopTree *chosen_loop = get_loop(least);
98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3558 if( !chosen_loop->_child ) // Inner loop?
98cb887364d3 6810672: Comment typos twisti parents: 558 diff changeset	3559 chosen_loop->_body.push(n);// Collect inner loops
0 a61af66fc99e Initial load duke parents: diff changeset	3560 }
a61af66fc99e Initial load duke parents: diff changeset	3561
4779 c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3562 #ifdef ASSERT
8048 8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	3563 void PhaseIdealLoop::dump_bad_graph(const char* msg, Node* n, Node* early, Node* LCA) {
8b3da8d14c93 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob roland parents: 6846 diff changeset	3564 tty->print_cr(msg);
4779 c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3565 tty->print("n: "); n->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3566 tty->print("early(n): "); early->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3567 if (n->in(0) != NULL && !n->in(0)->is_top() &&
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3568 n->in(0) != early && !n->in(0)->is_Root()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3569 tty->print("n->in(0): "); n->in(0)->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3570 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3571 for (uint i = 1; i < n->req(); i++) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3572 Node* in1 = n->in(i);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3573 if (in1 != NULL && in1 != n && !in1->is_top()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3574 tty->print("n->in(%d): ", i); in1->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3575 Node* in1_early = get_ctrl(in1);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3576 tty->print("early(n->in(%d)): ", i); in1_early->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3577 if (in1->in(0) != NULL && !in1->in(0)->is_top() &&
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3578 in1->in(0) != in1_early && !in1->in(0)->is_Root()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3579 tty->print("n->in(%d)->in(0): ", i); in1->in(0)->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3580 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3581 for (uint j = 1; j < in1->req(); j++) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3582 Node* in2 = in1->in(j);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3583 if (in2 != NULL && in2 != n && in2 != in1 && !in2->is_top()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3584 tty->print("n->in(%d)->in(%d): ", i, j); in2->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3585 Node* in2_early = get_ctrl(in2);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3586 tty->print("early(n->in(%d)->in(%d)): ", i, j); in2_early->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3587 if (in2->in(0) != NULL && !in2->in(0)->is_top() &&
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3588 in2->in(0) != in2_early && !in2->in(0)->is_Root()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3589 tty->print("n->in(%d)->in(%d)->in(0): ", i, j); in2->in(0)->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3590 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3591 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3592 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3593 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3594 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3595 tty->cr();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3596 tty->print("LCA(n): "); LCA->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3597 for (uint i = 0; i < n->outcnt(); i++) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3598 Node* u1 = n->raw_out(i);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3599 if (u1 == n)
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3600 continue;
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3601 tty->print("n->out(%d): ", i); u1->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3602 if (u1->is_CFG()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3603 for (uint j = 0; j < u1->outcnt(); j++) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3604 Node* u2 = u1->raw_out(j);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3605 if (u2 != u1 && u2 != n && u2->is_CFG()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3606 tty->print("n->out(%d)->out(%d): ", i, j); u2->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3607 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3608 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3609 } else {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3610 Node* u1_later = get_ctrl(u1);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3611 tty->print("later(n->out(%d)): ", i); u1_later->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3612 if (u1->in(0) != NULL && !u1->in(0)->is_top() &&
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3613 u1->in(0) != u1_later && !u1->in(0)->is_Root()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3614 tty->print("n->out(%d)->in(0): ", i); u1->in(0)->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3615 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3616 for (uint j = 0; j < u1->outcnt(); j++) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3617 Node* u2 = u1->raw_out(j);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3618 if (u2 == n \|\| u2 == u1)
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3619 continue;
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3620 tty->print("n->out(%d)->out(%d): ", i, j); u2->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3621 if (!u2->is_CFG()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3622 Node* u2_later = get_ctrl(u2);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3623 tty->print("later(n->out(%d)->out(%d)): ", i, j); u2_later->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3624 if (u2->in(0) != NULL && !u2->in(0)->is_top() &&
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3625 u2->in(0) != u2_later && !u2->in(0)->is_Root()) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3626 tty->print("n->out(%d)->in(0): ", i); u2->in(0)->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3627 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3628 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3629 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3630 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3631 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3632 tty->cr();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3633 int ct = 0;
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3634 Node *dbg_legal = LCA;
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3635 while(!dbg_legal->is_Start() && ct < 100) {
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3636 tty->print("idom[%d] ",ct); dbg_legal->dump();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3637 ct++;
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3638 dbg_legal = idom(dbg_legal);
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3639 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3640 tty->cr();
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3641 }
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3642 #endif
c8d8e124380c 7064302: JDK7 build 147 crashed after testing my java 6-compiled web app kvn parents: 4115 diff changeset	3643
0 a61af66fc99e Initial load duke parents: diff changeset	3644 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	3645 //------------------------------dump-------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3646 void PhaseIdealLoop::dump( ) const {
a61af66fc99e Initial load duke parents: diff changeset	3647 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	3648 Arena* arena = Thread::current()->resource_area();
a61af66fc99e Initial load duke parents: diff changeset	3649 Node_Stack stack(arena, C->unique() >> 2);
a61af66fc99e Initial load duke parents: diff changeset	3650 Node_List rpo_list;
a61af66fc99e Initial load duke parents: diff changeset	3651 VectorSet visited(arena);
a61af66fc99e Initial load duke parents: diff changeset	3652 visited.set(C->top()->_idx);
a61af66fc99e Initial load duke parents: diff changeset	3653 rpo( C->root(), stack, visited, rpo_list );
a61af66fc99e Initial load duke parents: diff changeset	3654 // Dump root loop indexed by last element in PO order
a61af66fc99e Initial load duke parents: diff changeset	3655 dump( _ltree_root, rpo_list.size(), rpo_list );
a61af66fc99e Initial load duke parents: diff changeset	3656 }
a61af66fc99e Initial load duke parents: diff changeset	3657
a61af66fc99e Initial load duke parents: diff changeset	3658 void PhaseIdealLoop::dump( IdealLoopTree *loop, uint idx, Node_List &rpo_list ) const {
367 194b8e3a2fc4 6384206: Phis which are later unneeded are impairing our ability to inline based on static types never parents: 293 diff changeset	3659 loop->dump_head();
0 a61af66fc99e Initial load duke parents: diff changeset	3660
a61af66fc99e Initial load duke parents: diff changeset	3661 // Now scan for CFG nodes in the same loop
a61af66fc99e Initial load duke parents: diff changeset	3662 for( uint j=idx; j > 0; j-- ) {
a61af66fc99e Initial load duke parents: diff changeset	3663 Node *n = rpo_list[j-1];
a61af66fc99e Initial load duke parents: diff changeset	3664 if( !_nodes[n->_idx] ) // Skip dead nodes
a61af66fc99e Initial load duke parents: diff changeset	3665 continue;
a61af66fc99e Initial load duke parents: diff changeset	3666 if( get_loop(n) != loop ) { // Wrong loop nest
a61af66fc99e Initial load duke parents: diff changeset	3667 if( get_loop(n)->_head == n && // Found nested loop?
a61af66fc99e Initial load duke parents: diff changeset	3668 get_loop(n)->_parent == loop )
a61af66fc99e Initial load duke parents: diff changeset	3669 dump(get_loop(n),rpo_list.size(),rpo_list); // Print it nested-ly
a61af66fc99e Initial load duke parents: diff changeset	3670 continue;
a61af66fc99e Initial load duke parents: diff changeset	3671 }
a61af66fc99e Initial load duke parents: diff changeset	3672
a61af66fc99e Initial load duke parents: diff changeset	3673 // Dump controlling node
a61af66fc99e Initial load duke parents: diff changeset	3674 for( uint x = 0; x < loop->_nest; x++ )
a61af66fc99e Initial load duke parents: diff changeset	3675 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	3676 tty->print("C");
a61af66fc99e Initial load duke parents: diff changeset	3677 if( n == C->root() ) {
a61af66fc99e Initial load duke parents: diff changeset	3678 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	3679 } else {
a61af66fc99e Initial load duke parents: diff changeset	3680 Node* cached_idom = idom_no_update(n);
a61af66fc99e Initial load duke parents: diff changeset	3681 Node *computed_idom = n->in(0);
a61af66fc99e Initial load duke parents: diff changeset	3682 if( n->is_Region() ) {
a61af66fc99e Initial load duke parents: diff changeset	3683 computed_idom = compute_idom(n);
a61af66fc99e Initial load duke parents: diff changeset	3684 // computed_idom() will return n->in(0) when idom(n) is an IfNode (or
a61af66fc99e Initial load duke parents: diff changeset	3685 // any MultiBranch ctrl node), so apply a similar transform to
a61af66fc99e Initial load duke parents: diff changeset	3686 // the cached idom returned from idom_no_update.
a61af66fc99e Initial load duke parents: diff changeset	3687 cached_idom = find_non_split_ctrl(cached_idom);
a61af66fc99e Initial load duke parents: diff changeset	3688 }
a61af66fc99e Initial load duke parents: diff changeset	3689 tty->print(" ID:%d",computed_idom->_idx);
a61af66fc99e Initial load duke parents: diff changeset	3690 n->dump();
a61af66fc99e Initial load duke parents: diff changeset	3691 if( cached_idom != computed_idom ) {
a61af66fc99e Initial load duke parents: diff changeset	3692 tty->print_cr("*** BROKEN IDOM! Computed as: %d, cached as: %d",
a61af66fc99e Initial load duke parents: diff changeset	3693 computed_idom->_idx, cached_idom->_idx);
a61af66fc99e Initial load duke parents: diff changeset	3694 }
a61af66fc99e Initial load duke parents: diff changeset	3695 }
a61af66fc99e Initial load duke parents: diff changeset	3696 // Dump nodes it controls
a61af66fc99e Initial load duke parents: diff changeset	3697 for( uint k = 0; k < _nodes.Size(); k++ ) {
a61af66fc99e Initial load duke parents: diff changeset	3698 // (k < C->unique() && get_ctrl(find(k)) == n)
a61af66fc99e Initial load duke parents: diff changeset	3699 if (k < C->unique() && _nodes[k] == (Node*)((intptr_t)n + 1)) {
a61af66fc99e Initial load duke parents: diff changeset	3700 Node *m = C->root()->find(k);
a61af66fc99e Initial load duke parents: diff changeset	3701 if( m && m->outcnt() > 0 ) {
a61af66fc99e Initial load duke parents: diff changeset	3702 if (!(has_ctrl(m) && get_ctrl_no_update(m) == n)) {
a61af66fc99e Initial load duke parents: diff changeset	3703 tty->print_cr("*** BROKEN CTRL ACCESSOR! _nodes[k] is %p, ctrl is %p",
a61af66fc99e Initial load duke parents: diff changeset	3704 _nodes[k], has_ctrl(m) ? get_ctrl_no_update(m) : NULL);
a61af66fc99e Initial load duke parents: diff changeset	3705 }
a61af66fc99e Initial load duke parents: diff changeset	3706 for( uint j = 0; j < loop->_nest; j++ )
a61af66fc99e Initial load duke parents: diff changeset	3707 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	3708 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	3709 m->dump();
a61af66fc99e Initial load duke parents: diff changeset	3710 }
a61af66fc99e Initial load duke parents: diff changeset	3711 }
a61af66fc99e Initial load duke parents: diff changeset	3712 }
a61af66fc99e Initial load duke parents: diff changeset	3713 }
a61af66fc99e Initial load duke parents: diff changeset	3714 }
a61af66fc99e Initial load duke parents: diff changeset	3715
a61af66fc99e Initial load duke parents: diff changeset	3716 // Collect a R-P-O for the whole CFG.
a61af66fc99e Initial load duke parents: diff changeset	3717 // Result list is in post-order (scan backwards for RPO)
a61af66fc99e Initial load duke parents: diff changeset	3718 void PhaseIdealLoop::rpo( Node *start, Node_Stack &stk, VectorSet &visited, Node_List &rpo_list ) const {
a61af66fc99e Initial load duke parents: diff changeset	3719 stk.push(start, 0);
a61af66fc99e Initial load duke parents: diff changeset	3720 visited.set(start->_idx);
a61af66fc99e Initial load duke parents: diff changeset	3721
a61af66fc99e Initial load duke parents: diff changeset	3722 while (stk.is_nonempty()) {
a61af66fc99e Initial load duke parents: diff changeset	3723 Node* m = stk.node();
a61af66fc99e Initial load duke parents: diff changeset	3724 uint idx = stk.index();
a61af66fc99e Initial load duke parents: diff changeset	3725 if (idx < m->outcnt()) {
a61af66fc99e Initial load duke parents: diff changeset	3726 stk.set_index(idx + 1);
a61af66fc99e Initial load duke parents: diff changeset	3727 Node* n = m->raw_out(idx);
a61af66fc99e Initial load duke parents: diff changeset	3728 if (n->is_CFG() && !visited.test_set(n->_idx)) {
a61af66fc99e Initial load duke parents: diff changeset	3729 stk.push(n, 0);
a61af66fc99e Initial load duke parents: diff changeset	3730 }
a61af66fc99e Initial load duke parents: diff changeset	3731 } else {
a61af66fc99e Initial load duke parents: diff changeset	3732 rpo_list.push(m);
a61af66fc99e Initial load duke parents: diff changeset	3733 stk.pop();
a61af66fc99e Initial load duke parents: diff changeset	3734 }
a61af66fc99e Initial load duke parents: diff changeset	3735 }
a61af66fc99e Initial load duke parents: diff changeset	3736 }
a61af66fc99e Initial load duke parents: diff changeset	3737 #endif
a61af66fc99e Initial load duke parents: diff changeset	3738
a61af66fc99e Initial load duke parents: diff changeset	3739
a61af66fc99e Initial load duke parents: diff changeset	3740 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	3741 //------------------------------LoopTreeIterator-----------------------------------
a61af66fc99e Initial load duke parents: diff changeset	3742
a61af66fc99e Initial load duke parents: diff changeset	3743 // Advance to next loop tree using a preorder, left-to-right traversal.
a61af66fc99e Initial load duke parents: diff changeset	3744 void LoopTreeIterator::next() {
a61af66fc99e Initial load duke parents: diff changeset	3745 assert(!done(), "must not be done.");
a61af66fc99e Initial load duke parents: diff changeset	3746 if (_curnt->_child != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3747 _curnt = _curnt->_child;
a61af66fc99e Initial load duke parents: diff changeset	3748 } else if (_curnt->_next != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3749 _curnt = _curnt->_next;
a61af66fc99e Initial load duke parents: diff changeset	3750 } else {
a61af66fc99e Initial load duke parents: diff changeset	3751 while (_curnt != _root && _curnt->_next == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3752 _curnt = _curnt->_parent;
a61af66fc99e Initial load duke parents: diff changeset	3753 }
a61af66fc99e Initial load duke parents: diff changeset	3754 if (_curnt == _root) {
a61af66fc99e Initial load duke parents: diff changeset	3755 _curnt = NULL;
a61af66fc99e Initial load duke parents: diff changeset	3756 assert(done(), "must be done.");
a61af66fc99e Initial load duke parents: diff changeset	3757 } else {
a61af66fc99e Initial load duke parents: diff changeset	3758 assert(_curnt->_next != NULL, "must be more to do");
a61af66fc99e Initial load duke parents: diff changeset	3759 _curnt = _curnt->_next;
a61af66fc99e Initial load duke parents: diff changeset	3760 }
a61af66fc99e Initial load duke parents: diff changeset	3761 }
a61af66fc99e Initial load duke parents: diff changeset	3762 }

Mercurial > hg > truffle

annotate src/share/vm/opto/loopnode.cpp @ 14649:f6301b007a16