1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "opto/addnode.hpp"
27 #include "opto/connode.hpp"
28 #include "opto/convertnode.hpp"
29 #include "opto/movenode.hpp"
30 #include "opto/phaseX.hpp"
31 #include "opto/subnode.hpp"
32
33 //=============================================================================
34 /*
35 The major change is for CMoveP and StrComp. They have related but slightly
36 different problems. They both take in TWO oops which are both null-checked
37 independently before the using Node. After CCP removes the CastPP's they need
38 to pick up the guarding test edge - in this case TWO control edges. I tried
39 various solutions, all have problems:
40
41 (1) Do nothing. This leads to a bug where we hoist a Load from a CMoveP or a
42 StrComp above a guarding null check. I've seen both cases in normal -Xcomp
43 testing.
44
45 (2) Plug the control edge from 1 of the 2 oops in. Apparent problem here is
46 to figure out which test post-dominates. The real problem is that it doesn't
47 matter which one you pick. After you pick up, the dominating-test elider in
48 IGVN can remove the test and allow you to hoist up to the dominating test on
49 the chosen oop bypassing the test on the not-chosen oop. Seen in testing.
50 Oops.
51
52 (3) Leave the CastPP's in. This makes the graph more accurate in some sense;
53 we get to keep around the knowledge that an oop is not-null after some test.
54 Alas, the CastPP's interfere with GVN (some values are the regular oop, some
55 are the CastPP of the oop, all merge at Phi's which cannot collapse, etc).
56 This cost us 10% on SpecJVM, even when I removed some of the more trivial
57 cases in the optimizer. Removing more useless Phi's started allowing Loads to
58 illegally float above null checks. I gave up on this approach.
59
60 (4) Add BOTH control edges to both tests. Alas, too much code knows that
61 control edges are in slot-zero ONLY. Many quick asserts fail; no way to do
62 this one. Note that I really want to allow the CMoveP to float and add both
63 control edges to the dependent Load op - meaning I can select early but I
64 cannot Load until I pass both tests.
65
66 (5) Do not hoist CMoveP and StrComp. To this end I added the v-call
67 depends_only_on_test(). No obvious performance loss on Spec, but we are
68 clearly conservative on CMoveP (also so on StrComp but that's unlikely to
69 matter ever).
70
71 */
72
73
74 //------------------------------Ideal------------------------------------------
75 // Return a node which is more "ideal" than the current node.
76 // Move constants to the right.
77 Node *CMoveNode::Ideal(PhaseGVN *phase, bool can_reshape) {
78 if( in(0) && remove_dead_region(phase, can_reshape) ) return this;
79 // Don't bother trying to transform a dead node
80 if( in(0) && in(0)->is_top() ) return NULL;
81 assert( !phase->eqv(in(Condition), this) &&
82 !phase->eqv(in(IfFalse), this) &&
83 !phase->eqv(in(IfTrue), this), "dead loop in CMoveNode::Ideal" );
84 if( phase->type(in(Condition)) == Type::TOP )
85 return NULL; // return NULL when Condition is dead
86
87 if( in(IfFalse)->is_Con() && !in(IfTrue)->is_Con() ) {
88 if( in(Condition)->is_Bool() ) {
89 BoolNode* b = in(Condition)->as_Bool();
90 BoolNode* b2 = b->negate(phase);
91 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );
92 }
93 }
94 return NULL;
95 }
96
97 //------------------------------is_cmove_id------------------------------------
98 // Helper function to check for CMOVE identity. Shared with PhiNode::Identity
99 Node *CMoveNode::is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b ) {
100 // Check for Cmp'ing and CMove'ing same values
101 if( (phase->eqv(cmp->in(1),f) &&
102 phase->eqv(cmp->in(2),t)) ||
103 // Swapped Cmp is OK
104 (phase->eqv(cmp->in(2),f) &&
105 phase->eqv(cmp->in(1),t)) ) {
106 // Give up this identity check for floating points because it may choose incorrect
107 // value around 0.0 and -0.0
108 if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD )
109 return NULL;
110 // Check for "(t==f)?t:f;" and replace with "f"
111 if( b->_test._test == BoolTest::eq )
112 return f;
113 // Allow the inverted case as well
114 // Check for "(t!=f)?t:f;" and replace with "t"
115 if( b->_test._test == BoolTest::ne )
116 return t;
117 }
118 return NULL;
119 }
120
121 //------------------------------Identity---------------------------------------
122 // Conditional-move is an identity if both inputs are the same, or the test
123 // true or false.
124 Node *CMoveNode::Identity( PhaseTransform *phase ) {
125 if( phase->eqv(in(IfFalse),in(IfTrue)) ) // C-moving identical inputs?
126 return in(IfFalse); // Then it doesn't matter
127 if( phase->type(in(Condition)) == TypeInt::ZERO )
128 return in(IfFalse); // Always pick left(false) input
129 if( phase->type(in(Condition)) == TypeInt::ONE )
130 return in(IfTrue); // Always pick right(true) input
131
132 // Check for CMove'ing a constant after comparing against the constant.
133 // Happens all the time now, since if we compare equality vs a constant in
134 // the parser, we "know" the variable is constant on one path and we force
135 // it. Thus code like "if( x==0 ) {/*EMPTY*/}" ends up inserting a
136 // conditional move: "x = (x==0)?0:x;". Yucko. This fix is slightly more
137 // general in that we don't need constants.
138 if( in(Condition)->is_Bool() ) {
139 BoolNode *b = in(Condition)->as_Bool();
140 Node *cmp = b->in(1);
141 if( cmp->is_Cmp() ) {
142 Node *id = is_cmove_id( phase, cmp, in(IfTrue), in(IfFalse), b );
143 if( id ) return id;
144 }
145 }
146
147 return this;
148 }
149
150 //------------------------------Value------------------------------------------
151 // Result is the meet of inputs
152 const Type *CMoveNode::Value( PhaseTransform *phase ) const {
153 if( phase->type(in(Condition)) == Type::TOP )
154 return Type::TOP;
155 return phase->type(in(IfFalse))->meet_speculative(phase->type(in(IfTrue)));
156 }
157
158 //------------------------------make-------------------------------------------
159 // Make a correctly-flavored CMove. Since _type is directly determined
160 // from the inputs we do not need to specify it here.
161 CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) {
162 switch( t->basic_type() ) {
163 case T_INT: return new CMoveINode( bol, left, right, t->is_int() );
164 case T_FLOAT: return new CMoveFNode( bol, left, right, t );
165 case T_DOUBLE: return new CMoveDNode( bol, left, right, t );
166 case T_LONG: return new CMoveLNode( bol, left, right, t->is_long() );
167 case T_OBJECT: return new CMovePNode( c, bol, left, right, t->is_oopptr() );
168 case T_ADDRESS: return new CMovePNode( c, bol, left, right, t->is_ptr() );
169 case T_NARROWOOP: return new CMoveNNode( c, bol, left, right, t );
170 default:
171 ShouldNotReachHere();
172 return NULL;
173 }
174 }
175
176 //=============================================================================
177 //------------------------------Ideal------------------------------------------
178 // Return a node which is more "ideal" than the current node.
179 // Check for conversions to boolean
180 Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) {
181 // Try generic ideal's first
182 Node *x = CMoveNode::Ideal(phase, can_reshape);
183 if( x ) return x;
184
185 // If zero is on the left (false-case, no-move-case) it must mean another
186 // constant is on the right (otherwise the shared CMove::Ideal code would
187 // have moved the constant to the right). This situation is bad for Intel
188 // and a don't-care for Sparc. It's bad for Intel because the zero has to
189 // be manifested in a register with a XOR which kills flags, which are live
190 // on input to the CMoveI, leading to a situation which causes excessive
191 // spilling on Intel. For Sparc, if the zero in on the left the Sparc will
192 // zero a register via G0 and conditionally-move the other constant. If the
193 // zero is on the right, the Sparc will load the first constant with a
194 // 13-bit set-lo and conditionally move G0. See bug 4677505.
195 if( phase->type(in(IfFalse)) == TypeInt::ZERO && !(phase->type(in(IfTrue)) == TypeInt::ZERO) ) {
196 if( in(Condition)->is_Bool() ) {
197 BoolNode* b = in(Condition)->as_Bool();
198 BoolNode* b2 = b->negate(phase);
199 return make( phase->C, in(Control), phase->transform(b2), in(IfTrue), in(IfFalse), _type );
200 }
201 }
202
203 // Now check for booleans
204 int flip = 0;
205
206 // Check for picking from zero/one
207 if( phase->type(in(IfFalse)) == TypeInt::ZERO && phase->type(in(IfTrue)) == TypeInt::ONE ) {
208 flip = 1 - flip;
209 } else if( phase->type(in(IfFalse)) == TypeInt::ONE && phase->type(in(IfTrue)) == TypeInt::ZERO ) {
210 } else return NULL;
211
212 // Check for eq/ne test
213 if( !in(1)->is_Bool() ) return NULL;
214 BoolNode *bol = in(1)->as_Bool();
215 if( bol->_test._test == BoolTest::eq ) {
216 } else if( bol->_test._test == BoolTest::ne ) {
217 flip = 1-flip;
218 } else return NULL;
219
220 // Check for vs 0 or 1
221 if( !bol->in(1)->is_Cmp() ) return NULL;
222 const CmpNode *cmp = bol->in(1)->as_Cmp();
223 if( phase->type(cmp->in(2)) == TypeInt::ZERO ) {
224 } else if( phase->type(cmp->in(2)) == TypeInt::ONE ) {
225 // Allow cmp-vs-1 if the other input is bounded by 0-1
226 if( phase->type(cmp->in(1)) != TypeInt::BOOL )
227 return NULL;
228 flip = 1 - flip;
229 } else return NULL;
230
231 // Convert to a bool (flipped)
232 // Build int->bool conversion
233 #ifndef PRODUCT
234 if( PrintOpto ) tty->print_cr("CMOV to I2B");
235 #endif
236 Node *n = new Conv2BNode( cmp->in(1) );
237 if( flip )
238 n = new XorINode( phase->transform(n), phase->intcon(1) );
239
240 return n;
241 }
242
243 //=============================================================================
244 //------------------------------Ideal------------------------------------------
245 // Return a node which is more "ideal" than the current node.
246 // Check for absolute value
247 Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
248 // Try generic ideal's first
249 Node *x = CMoveNode::Ideal(phase, can_reshape);
250 if( x ) return x;
251
252 int cmp_zero_idx = 0; // Index of compare input where to look for zero
253 int phi_x_idx = 0; // Index of phi input where to find naked x
254
255 // Find the Bool
256 if( !in(1)->is_Bool() ) return NULL;
257 BoolNode *bol = in(1)->as_Bool();
258 // Check bool sense
259 switch( bol->_test._test ) {
260 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break;
261 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;
262 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break;
263 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;
264 default: return NULL; break;
265 }
266
267 // Find zero input of CmpF; the other input is being abs'd
268 Node *cmpf = bol->in(1);
269 if( cmpf->Opcode() != Op_CmpF ) return NULL;
270 Node *X = NULL;
271 bool flip = false;
272 if( phase->type(cmpf->in(cmp_zero_idx)) == TypeF::ZERO ) {
273 X = cmpf->in(3 - cmp_zero_idx);
274 } else if (phase->type(cmpf->in(3 - cmp_zero_idx)) == TypeF::ZERO) {
275 // The test is inverted, we should invert the result...
276 X = cmpf->in(cmp_zero_idx);
277 flip = true;
278 } else {
279 return NULL;
280 }
281
282 // If X is found on the appropriate phi input, find the subtract on the other
283 if( X != in(phi_x_idx) ) return NULL;
284 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;
285 Node *sub = in(phi_sub_idx);
286
287 // Allow only SubF(0,X) and fail out for all others; NegF is not OK
288 if( sub->Opcode() != Op_SubF ||
289 sub->in(2) != X ||
290 phase->type(sub->in(1)) != TypeF::ZERO ) return NULL;
291
292 Node *abs = new AbsFNode( X );
293 if( flip )
294 abs = new SubFNode(sub->in(1), phase->transform(abs));
295
296 return abs;
297 }
298
299 //=============================================================================
300 //------------------------------Ideal------------------------------------------
301 // Return a node which is more "ideal" than the current node.
302 // Check for absolute value
303 Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
304 // Try generic ideal's first
305 Node *x = CMoveNode::Ideal(phase, can_reshape);
306 if( x ) return x;
307
308 int cmp_zero_idx = 0; // Index of compare input where to look for zero
309 int phi_x_idx = 0; // Index of phi input where to find naked x
310
311 // Find the Bool
312 if( !in(1)->is_Bool() ) return NULL;
313 BoolNode *bol = in(1)->as_Bool();
314 // Check bool sense
315 switch( bol->_test._test ) {
316 case BoolTest::lt: cmp_zero_idx = 1; phi_x_idx = IfTrue; break;
317 case BoolTest::le: cmp_zero_idx = 2; phi_x_idx = IfFalse; break;
318 case BoolTest::gt: cmp_zero_idx = 2; phi_x_idx = IfTrue; break;
319 case BoolTest::ge: cmp_zero_idx = 1; phi_x_idx = IfFalse; break;
320 default: return NULL; break;
321 }
322
323 // Find zero input of CmpD; the other input is being abs'd
324 Node *cmpd = bol->in(1);
325 if( cmpd->Opcode() != Op_CmpD ) return NULL;
326 Node *X = NULL;
327 bool flip = false;
328 if( phase->type(cmpd->in(cmp_zero_idx)) == TypeD::ZERO ) {
329 X = cmpd->in(3 - cmp_zero_idx);
330 } else if (phase->type(cmpd->in(3 - cmp_zero_idx)) == TypeD::ZERO) {
331 // The test is inverted, we should invert the result...
332 X = cmpd->in(cmp_zero_idx);
333 flip = true;
334 } else {
335 return NULL;
336 }
337
338 // If X is found on the appropriate phi input, find the subtract on the other
339 if( X != in(phi_x_idx) ) return NULL;
340 int phi_sub_idx = phi_x_idx == IfTrue ? IfFalse : IfTrue;
341 Node *sub = in(phi_sub_idx);
342
343 // Allow only SubD(0,X) and fail out for all others; NegD is not OK
344 if( sub->Opcode() != Op_SubD ||
345 sub->in(2) != X ||
346 phase->type(sub->in(1)) != TypeD::ZERO ) return NULL;
347
348 Node *abs = new AbsDNode( X );
349 if( flip )
350 abs = new SubDNode(sub->in(1), phase->transform(abs));
351
352 return abs;
353 }
354
355 //------------------------------Value------------------------------------------
356 const Type *MoveL2DNode::Value( PhaseTransform *phase ) const {
357 const Type *t = phase->type( in(1) );
358 if( t == Type::TOP ) return Type::TOP;
359 const TypeLong *tl = t->is_long();
360 if( !tl->is_con() ) return bottom_type();
361 JavaValue v;
362 v.set_jlong(tl->get_con());
363 return TypeD::make( v.get_jdouble() );
364 }
365
366 //------------------------------Value------------------------------------------
367 const Type *MoveI2FNode::Value( PhaseTransform *phase ) const {
368 const Type *t = phase->type( in(1) );
369 if( t == Type::TOP ) return Type::TOP;
370 const TypeInt *ti = t->is_int();
371 if( !ti->is_con() ) return bottom_type();
372 JavaValue v;
373 v.set_jint(ti->get_con());
374 return TypeF::make( v.get_jfloat() );
375 }
376
377 //------------------------------Value------------------------------------------
378 const Type *MoveF2INode::Value( PhaseTransform *phase ) const {
379 const Type *t = phase->type( in(1) );
380 if( t == Type::TOP ) return Type::TOP;
381 if( t == Type::FLOAT ) return TypeInt::INT;
382 const TypeF *tf = t->is_float_constant();
383 JavaValue v;
384 v.set_jfloat(tf->getf());
385 return TypeInt::make( v.get_jint() );
386 }
387
388 //------------------------------Value------------------------------------------
389 const Type *MoveD2LNode::Value( PhaseTransform *phase ) const {
390 const Type *t = phase->type( in(1) );
391 if( t == Type::TOP ) return Type::TOP;
392 if( t == Type::DOUBLE ) return TypeLong::LONG;
393 const TypeD *td = t->is_double_constant();
394 JavaValue v;
395 v.set_jdouble(td->getd());
396 return TypeLong::make( v.get_jlong() );
397 }
398