1 /*
2 * Copyright (c) 2014, 2025, 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 "opto/addnode.hpp"
26 #include "opto/castnode.hpp"
27 #include "opto/connode.hpp"
28 #include "opto/convertnode.hpp"
29 #include "opto/divnode.hpp"
30 #include "opto/matcher.hpp"
31 #include "opto/movenode.hpp"
32 #include "opto/mulnode.hpp"
33 #include "opto/phaseX.hpp"
34 #include "opto/subnode.hpp"
35 #include "runtime/stubRoutines.hpp"
36 #include "utilities/checkedCast.hpp"
37
38 //=============================================================================
39 //------------------------------Identity---------------------------------------
40 Node* Conv2BNode::Identity(PhaseGVN* phase) {
41 const Type *t = phase->type( in(1) );
42 if( t == Type::TOP ) return in(1);
43 if( t == TypeInt::ZERO ) return in(1);
44 if( t == TypeInt::ONE ) return in(1);
45 if( t == TypeInt::BOOL ) return in(1);
46 return this;
47 }
48
49 //------------------------------Value------------------------------------------
50 const Type* Conv2BNode::Value(PhaseGVN* phase) const {
51 const Type *t = phase->type( in(1) );
52 if( t == Type::TOP ) return Type::TOP;
53 if( t == TypeInt::ZERO ) return TypeInt::ZERO;
54 if( t == TypePtr::NULL_PTR ) return TypeInt::ZERO;
55 const TypePtr *tp = t->isa_ptr();
56 if(tp != nullptr) {
57 if( tp->ptr() == TypePtr::AnyNull ) return Type::TOP;
58 if( tp->ptr() == TypePtr::Constant) return TypeInt::ONE;
59 if (tp->ptr() == TypePtr::NotNull) return TypeInt::ONE;
60 return TypeInt::BOOL;
61 }
62 if (t->base() != Type::Int) return TypeInt::BOOL;
63 const TypeInt *ti = t->is_int();
64 if( ti->_hi < 0 || ti->_lo > 0 ) return TypeInt::ONE;
65 return TypeInt::BOOL;
66 }
67
68 Node* Conv2BNode::Ideal(PhaseGVN* phase, bool can_reshape) {
69 if (!Matcher::match_rule_supported(Op_Conv2B)) {
70 if (phase->C->post_loop_opts_phase()) {
71 // Get type of comparison to make
72 const Type* t = phase->type(in(1));
73 Node* cmp = nullptr;
74 if (t->isa_int()) {
75 cmp = phase->transform(new CmpINode(in(1), phase->intcon(0)));
76 } else if (t->isa_ptr()) {
77 cmp = phase->transform(new CmpPNode(in(1), phase->zerocon(BasicType::T_OBJECT)));
78 } else {
79 assert(false, "Unrecognized comparison for Conv2B: %s", NodeClassNames[in(1)->Opcode()]);
80 }
81
82 // Skip the transformation if input is unexpected.
83 if (cmp == nullptr) {
84 return nullptr;
85 }
86
87 // Replace Conv2B with the cmove
88 Node* bol = phase->transform(new BoolNode(cmp, BoolTest::eq));
89 return new CMoveINode(bol, phase->intcon(1), phase->intcon(0), TypeInt::BOOL);
90 } else {
91 phase->C->record_for_post_loop_opts_igvn(this);
92 }
93 }
94 return nullptr;
95 }
96
97 uint ConvertNode::ideal_reg() const {
98 return _type->ideal_reg();
99 }
100
101 Node* ConvertNode::create_convert(BasicType source, BasicType target, Node* input) {
102 if (source == T_INT) {
103 if (target == T_LONG) {
104 return new ConvI2LNode(input);
105 } else if (target == T_FLOAT) {
106 return new ConvI2FNode(input);
107 } else if (target == T_DOUBLE) {
108 return new ConvI2DNode(input);
109 }
110 } else if (source == T_LONG) {
111 if (target == T_INT) {
112 return new ConvL2INode(input);
113 } else if (target == T_FLOAT) {
114 return new ConvL2FNode(input);
115 } else if (target == T_DOUBLE) {
116 return new ConvL2DNode(input);
117 }
118 } else if (source == T_FLOAT) {
119 if (target == T_INT) {
120 return new ConvF2INode(input);
121 } else if (target == T_LONG) {
122 return new ConvF2LNode(input);
123 } else if (target == T_DOUBLE) {
124 return new ConvF2DNode(input);
125 } else if (target == T_SHORT) {
126 return new ConvF2HFNode(input);
127 }
128 } else if (source == T_DOUBLE) {
129 if (target == T_INT) {
130 return new ConvD2INode(input);
131 } else if (target == T_LONG) {
132 return new ConvD2LNode(input);
133 } else if (target == T_FLOAT) {
134 return new ConvD2FNode(input);
135 }
136 } else if (source == T_SHORT) {
137 if (target == T_FLOAT) {
138 return new ConvHF2FNode(input);
139 }
140 }
141
142 assert(false, "Couldn't create conversion for type %s to %s", type2name(source), type2name(target));
143 return nullptr;
144 }
145
146 // The conversions operations are all Alpha sorted. Please keep it that way!
147 //=============================================================================
148 //------------------------------Value------------------------------------------
149 const Type* ConvD2FNode::Value(PhaseGVN* phase) const {
150 const Type *t = phase->type( in(1) );
151 if( t == Type::TOP ) return Type::TOP;
152 if( t == Type::DOUBLE ) return Type::FLOAT;
153 const TypeD *td = t->is_double_constant();
154 return TypeF::make( (float)td->getd() );
155 }
156
157 //------------------------------Ideal------------------------------------------
158 // If we see pattern ConvF2D SomeDoubleOp ConvD2F, do operation as float.
159 Node *ConvD2FNode::Ideal(PhaseGVN *phase, bool can_reshape) {
160 if ( in(1)->Opcode() == Op_SqrtD ) {
161 Node* sqrtd = in(1);
162 if ( sqrtd->in(1)->Opcode() == Op_ConvF2D ) {
163 if ( Matcher::match_rule_supported(Op_SqrtF) ) {
164 Node* convf2d = sqrtd->in(1);
165 return new SqrtFNode(phase->C, sqrtd->in(0), convf2d->in(1));
166 }
167 }
168 }
169 return nullptr;
170 }
171
172 //------------------------------Identity---------------------------------------
173 // Float's can be converted to doubles with no loss of bits. Hence
174 // converting a float to a double and back to a float is a NOP.
175 Node* ConvD2FNode::Identity(PhaseGVN* phase) {
176 return (in(1)->Opcode() == Op_ConvF2D) ? in(1)->in(1) : this;
177 }
178
179 //=============================================================================
180 //------------------------------Value------------------------------------------
181 const Type* ConvD2INode::Value(PhaseGVN* phase) const {
182 const Type *t = phase->type( in(1) );
183 if( t == Type::TOP ) return Type::TOP;
184 if( t == Type::DOUBLE ) return TypeInt::INT;
185 const TypeD *td = t->is_double_constant();
186 return TypeInt::make( SharedRuntime::d2i( td->getd() ) );
187 }
188
189 //------------------------------Identity---------------------------------------
190 // Int's can be converted to doubles with no loss of bits. Hence
191 // converting an integer to a double and back to an integer is a NOP.
192 Node* ConvD2INode::Identity(PhaseGVN* phase) {
193 return (in(1)->Opcode() == Op_ConvI2D) ? in(1)->in(1) : this;
194 }
195
196 //=============================================================================
197 //------------------------------Value------------------------------------------
198 const Type* ConvD2LNode::Value(PhaseGVN* phase) const {
199 const Type *t = phase->type( in(1) );
200 if( t == Type::TOP ) return Type::TOP;
201 if( t == Type::DOUBLE ) return TypeLong::LONG;
202 const TypeD *td = t->is_double_constant();
203 return TypeLong::make( SharedRuntime::d2l( td->getd() ) );
204 }
205
206 //------------------------------Identity---------------------------------------
207 Node* ConvD2LNode::Identity(PhaseGVN* phase) {
208 // Remove ConvD2L->ConvL2D->ConvD2L sequences.
209 if( in(1) ->Opcode() == Op_ConvL2D &&
210 in(1)->in(1)->Opcode() == Op_ConvD2L )
211 return in(1)->in(1);
212 return this;
213 }
214
215 //=============================================================================
216 //------------------------------Value------------------------------------------
217 const Type* ConvF2DNode::Value(PhaseGVN* phase) const {
218 const Type *t = phase->type( in(1) );
219 if( t == Type::TOP ) return Type::TOP;
220 if( t == Type::FLOAT ) return Type::DOUBLE;
221 const TypeF *tf = t->is_float_constant();
222 return TypeD::make( (double)tf->getf() );
223 }
224
225 //=============================================================================
226 //------------------------------Value------------------------------------------
227 const Type* ConvF2HFNode::Value(PhaseGVN* phase) const {
228 const Type *t = phase->type( in(1) );
229 if (t == Type::TOP) return Type::TOP;
230 if (t == Type::FLOAT || StubRoutines::f2hf_adr() == nullptr) {
231 return TypeInt::SHORT;
232 }
233
234 const TypeF *tf = t->is_float_constant();
235 return TypeInt::make( StubRoutines::f2hf(tf->getf()) );
236 }
237
238 //------------------------------Ideal------------------------------------------
239 Node* ConvF2HFNode::Ideal(PhaseGVN* phase, bool can_reshape) {
240 // Float16 instance encapsulates a short field holding IEEE 754
241 // binary16 value. On unboxing, this short field is loaded into a
242 // GPR register while FP operation operates over floating point
243 // registers. ConvHF2F converts incoming short value to a FP32 value
244 // to perform operation at FP32 granularity. However, if target
245 // support FP16 ISA we can save this redundant up casting and
246 // optimize the graph pallet using following transformation.
247 //
248 // ConvF2HF(FP32BinOp(ConvHF2F(x), ConvHF2F(y))) =>
249 // ReinterpretHF2S(FP16BinOp(ReinterpretS2HF(x), ReinterpretS2HF(y)))
250 //
251 // Please note we need to inject appropriate reinterpretation
252 // IR to move the values b/w GPR and floating point register
253 // before and after FP16 operation.
254
255 if (Float16NodeFactory::is_float32_binary_oper(in(1)->Opcode()) &&
256 in(1)->in(1)->Opcode() == Op_ConvHF2F &&
257 in(1)->in(2)->Opcode() == Op_ConvHF2F) {
258 if (Matcher::match_rule_supported(Float16NodeFactory::get_float16_binary_oper(in(1)->Opcode())) &&
259 Matcher::match_rule_supported(Op_ReinterpretS2HF) &&
260 Matcher::match_rule_supported(Op_ReinterpretHF2S)) {
261 Node* in1 = phase->transform(new ReinterpretS2HFNode(in(1)->in(1)->in(1)));
262 Node* in2 = phase->transform(new ReinterpretS2HFNode(in(1)->in(2)->in(1)));
263 Node* binop = phase->transform(Float16NodeFactory::make(in(1)->Opcode(), in(1)->in(0), in1, in2));
264 return new ReinterpretHF2SNode(binop);
265 }
266 }
267
268 // Detects following ideal graph pattern
269 // ConvF2HF(binopF(conF, ConvHF2F(varS))) =>
270 // ReinterpretHF2SNode(binopHF(conHF, ReinterpretS2HFNode(varS)))
271 if (Float16NodeFactory::is_float32_binary_oper(in(1)->Opcode())) {
272 Node* binopF = in(1);
273 // Check if the incoming binary operation has one floating point constant
274 // input and the other input is a half precision to single precision upcasting node.
275 // We land here because a prior HalfFloat to Float conversion promotes
276 // an integral constant holding Float16 value to a floating point constant.
277 // i.e. ConvHF2F ConI(short) => ConF
278 Node* conF = nullptr;
279 Node* varS = nullptr;
280 if (binopF->in(1)->is_Con() && binopF->in(2)->Opcode() == Op_ConvHF2F) {
281 conF = binopF->in(1);
282 varS = binopF->in(2)->in(1);
283 } else if (binopF->in(2)->is_Con() && binopF->in(1)->Opcode() == Op_ConvHF2F) {
284 conF = binopF->in(2);
285 varS = binopF->in(1)->in(1);
286 }
287
288 if (conF != nullptr &&
289 varS != nullptr &&
290 conF->bottom_type()->isa_float_constant() != nullptr &&
291 Matcher::match_rule_supported(Float16NodeFactory::get_float16_binary_oper(binopF->Opcode())) &&
292 Matcher::match_rule_supported(Op_ReinterpretS2HF) &&
293 Matcher::match_rule_supported(Op_ReinterpretHF2S) &&
294 StubRoutines::hf2f_adr() != nullptr &&
295 StubRoutines::f2hf_adr() != nullptr) {
296 jfloat con = conF->bottom_type()->getf();
297 // Conditions under which floating point constant can be considered for a pattern match.
298 // 1. conF must lie within Float16 value range, otherwise we would have rounding issues:
299 // Doing the operation in float32 and then rounding is not the same as
300 // rounding first and doing the operation in float16.
301 // 2. If a constant value is one of the valid IEEE 754 binary32 NaN bit patterns
302 // then it's safe to consider it for pattern match because of the following reasons:
303 // a. As per section 2.8 of JVMS, Java Virtual Machine does not support
304 // signaling NaN value.
305 // b. Any signaling NaN which takes part in a non-comparison expression
306 // results in a quiet NaN but preserves the significand bits of signaling NaN.
307 // c. The pattern being matched includes a Float to Float16 conversion after binary
308 // expression, this downcast will still preserve the significand bits of binary32 NaN.
309 bool isnan = g_isnan((jdouble)con);
310 if (StubRoutines::hf2f(StubRoutines::f2hf(con)) == con || isnan) {
311 Node* newVarHF = phase->transform(new ReinterpretS2HFNode(varS));
312 Node* conHF = phase->makecon(TypeH::make(con));
313 Node* binopHF = nullptr;
314 // Preserving original input order for semantic correctness
315 // of non-commutative operation.
316 if (binopF->in(1) == conF) {
317 binopHF = phase->transform(Float16NodeFactory::make(binopF->Opcode(), binopF->in(0), conHF, newVarHF));
318 } else {
319 binopHF = phase->transform(Float16NodeFactory::make(binopF->Opcode(), binopF->in(0), newVarHF, conHF));
320 }
321 return new ReinterpretHF2SNode(binopHF);
322 }
323 }
324 }
325
326 return nullptr;
327 }
328
329 //=============================================================================
330 //------------------------------Value------------------------------------------
331 const Type* ConvF2INode::Value(PhaseGVN* phase) const {
332 const Type *t = phase->type( in(1) );
333 if( t == Type::TOP ) return Type::TOP;
334 if( t == Type::FLOAT ) return TypeInt::INT;
335 const TypeF *tf = t->is_float_constant();
336 return TypeInt::make( SharedRuntime::f2i( tf->getf() ) );
337 }
338
339 //------------------------------Identity---------------------------------------
340 Node* ConvF2INode::Identity(PhaseGVN* phase) {
341 // Remove ConvF2I->ConvI2F->ConvF2I sequences.
342 if( in(1) ->Opcode() == Op_ConvI2F &&
343 in(1)->in(1)->Opcode() == Op_ConvF2I )
344 return in(1)->in(1);
345 return this;
346 }
347
348 //=============================================================================
349 //------------------------------Value------------------------------------------
350 const Type* ConvF2LNode::Value(PhaseGVN* phase) const {
351 const Type *t = phase->type( in(1) );
352 if( t == Type::TOP ) return Type::TOP;
353 if( t == Type::FLOAT ) return TypeLong::LONG;
354 const TypeF *tf = t->is_float_constant();
355 return TypeLong::make( SharedRuntime::f2l( tf->getf() ) );
356 }
357
358 //------------------------------Identity---------------------------------------
359 Node* ConvF2LNode::Identity(PhaseGVN* phase) {
360 // Remove ConvF2L->ConvL2F->ConvF2L sequences.
361 if( in(1) ->Opcode() == Op_ConvL2F &&
362 in(1)->in(1)->Opcode() == Op_ConvF2L )
363 return in(1)->in(1);
364 return this;
365 }
366
367 //=============================================================================
368 //------------------------------Value------------------------------------------
369 const Type* ConvHF2FNode::Value(PhaseGVN* phase) const {
370 const Type *t = phase->type( in(1) );
371 if (t == Type::TOP) return Type::TOP;
372 if (t == TypeInt::SHORT || StubRoutines::hf2f_adr() == nullptr) {
373 return Type::FLOAT;
374 }
375
376 const TypeInt *ti = t->is_int();
377 if (ti->is_con()) {
378 return TypeF::make( StubRoutines::hf2f(ti->get_con()) );
379 }
380 return Type::FLOAT;
381 }
382
383 //=============================================================================
384 //------------------------------Value------------------------------------------
385 const Type* ConvI2DNode::Value(PhaseGVN* phase) const {
386 const Type *t = phase->type( in(1) );
387 if( t == Type::TOP ) return Type::TOP;
388 const TypeInt *ti = t->is_int();
389 if( ti->is_con() ) return TypeD::make( (double)ti->get_con() );
390 return Type::DOUBLE;
391 }
392
393 //=============================================================================
394 //------------------------------Value------------------------------------------
395 const Type* ConvI2FNode::Value(PhaseGVN* phase) const {
396 const Type *t = phase->type( in(1) );
397 if( t == Type::TOP ) return Type::TOP;
398 const TypeInt *ti = t->is_int();
399 if( ti->is_con() ) return TypeF::make( (float)ti->get_con() );
400 return Type::FLOAT;
401 }
402
403 //------------------------------Identity---------------------------------------
404 Node* ConvI2FNode::Identity(PhaseGVN* phase) {
405 // Remove ConvI2F->ConvF2I->ConvI2F sequences.
406 if( in(1) ->Opcode() == Op_ConvF2I &&
407 in(1)->in(1)->Opcode() == Op_ConvI2F )
408 return in(1)->in(1);
409 return this;
410 }
411
412 //=============================================================================
413 //------------------------------Value------------------------------------------
414 const Type* ConvI2LNode::Value(PhaseGVN* phase) const {
415 const Type *t = phase->type( in(1) );
416 if (t == Type::TOP) {
417 return Type::TOP;
418 }
419 const TypeInt *ti = t->is_int();
420 const Type* tl = TypeLong::make(ti->_lo, ti->_hi, ti->_widen);
421 // Join my declared type against my incoming type.
422 tl = tl->filter(_type);
423 if (!tl->isa_long()) {
424 return tl;
425 }
426 const TypeLong* this_type = tl->is_long();
427 // Do NOT remove this node's type assertion until no more loop ops can happen.
428 if (phase->C->post_loop_opts_phase()) {
429 const TypeInt* in_type = phase->type(in(1))->isa_int();
430 if (in_type != nullptr &&
431 (in_type->_lo != this_type->_lo ||
432 in_type->_hi != this_type->_hi)) {
433 // Although this WORSENS the type, it increases GVN opportunities,
434 // because I2L nodes with the same input will common up, regardless
435 // of slightly differing type assertions. Such slight differences
436 // arise routinely as a result of loop unrolling, so this is a
437 // post-unrolling graph cleanup. Choose a type which depends only
438 // on my input. (Exception: Keep a range assertion of >=0 or <0.)
439 jlong lo1 = this_type->_lo;
440 jlong hi1 = this_type->_hi;
441 int w1 = this_type->_widen;
442 if (lo1 >= 0) {
443 // Keep a range assertion of >=0.
444 lo1 = 0; hi1 = max_jint;
445 } else if (hi1 < 0) {
446 // Keep a range assertion of <0.
447 lo1 = min_jint; hi1 = -1;
448 } else {
449 lo1 = min_jint; hi1 = max_jint;
450 }
451 return TypeLong::make(MAX2((jlong)in_type->_lo, lo1),
452 MIN2((jlong)in_type->_hi, hi1),
453 MAX2((int)in_type->_widen, w1));
454 }
455 }
456 return this_type;
457 }
458
459 Node* ConvI2LNode::Identity(PhaseGVN* phase) {
460 // If type is in "int" sub-range, we can
461 // convert I2L(L2I(x)) => x
462 // since the conversions have no effect.
463 if (in(1)->Opcode() == Op_ConvL2I) {
464 Node* x = in(1)->in(1);
465 const TypeLong* t = phase->type(x)->isa_long();
466 if (t != nullptr && t->_lo >= min_jint && t->_hi <= max_jint) {
467 return x;
468 }
469 }
470 return this;
471 }
472
473 #ifdef ASSERT
474 static inline bool long_ranges_overlap(jlong lo1, jlong hi1,
475 jlong lo2, jlong hi2) {
476 // Two ranges overlap iff one range's low point falls in the other range.
477 return (lo2 <= lo1 && lo1 <= hi2) || (lo1 <= lo2 && lo2 <= hi1);
478 }
479 #endif
480
481 template<class T> static bool subtract_overflows(T x, T y) {
482 T s = java_subtract(x, y);
483 return (x >= 0) && (y < 0) && (s < 0);
484 }
485
486 template<class T> static bool subtract_underflows(T x, T y) {
487 T s = java_subtract(x, y);
488 return (x < 0) && (y > 0) && (s > 0);
489 }
490
491 template<class T> static bool add_overflows(T x, T y) {
492 T s = java_add(x, y);
493 return (x > 0) && (y > 0) && (s < 0);
494 }
495
496 template<class T> static bool add_underflows(T x, T y) {
497 T s = java_add(x, y);
498 return (x < 0) && (y < 0) && (s >= 0);
499 }
500
501 template<class T> static bool ranges_overlap(T xlo, T ylo, T xhi, T yhi, T zlo, T zhi,
502 const Node* n, bool pos) {
503 assert(xlo <= xhi && ylo <= yhi && zlo <= zhi, "should not be empty types");
504 T x_y_lo;
505 T x_y_hi;
506 bool x_y_lo_overflow;
507 bool x_y_hi_overflow;
508
509 if (n->is_Sub()) {
510 x_y_lo = java_subtract(xlo, yhi);
511 x_y_hi = java_subtract(xhi, ylo);
512 x_y_lo_overflow = pos ? subtract_overflows(xlo, yhi) : subtract_underflows(xlo, yhi);
513 x_y_hi_overflow = pos ? subtract_overflows(xhi, ylo) : subtract_underflows(xhi, ylo);
514 } else {
515 assert(n->is_Add(), "Add or Sub only");
516 x_y_lo = java_add(xlo, ylo);
517 x_y_hi = java_add(xhi, yhi);
518 x_y_lo_overflow = pos ? add_overflows(xlo, ylo) : add_underflows(xlo, ylo);
519 x_y_hi_overflow = pos ? add_overflows(xhi, yhi) : add_underflows(xhi, yhi);
520 }
521 assert(!pos || !x_y_lo_overflow || x_y_hi_overflow, "x_y_lo_overflow => x_y_hi_overflow");
522 assert(pos || !x_y_hi_overflow || x_y_lo_overflow, "x_y_hi_overflow => x_y_lo_overflow");
523
524 // Two ranges overlap iff one range's low point falls in the other range.
525 // nbits = 32 or 64
526 if (pos) {
527 // (zlo + 2**nbits <= x_y_lo && x_y_lo <= zhi ** nbits)
528 if (x_y_lo_overflow) {
529 if (zlo <= x_y_lo && x_y_lo <= zhi) {
530 return true;
531 }
532 }
533
534 // (x_y_lo <= zlo + 2**nbits && zlo + 2**nbits <= x_y_hi)
535 if (x_y_hi_overflow) {
536 if ((!x_y_lo_overflow || x_y_lo <= zlo) && zlo <= x_y_hi) {
537 return true;
538 }
539 }
540 } else {
541 // (zlo - 2**nbits <= x_y_hi && x_y_hi <= zhi - 2**nbits)
542 if (x_y_hi_overflow) {
543 if (zlo <= x_y_hi && x_y_hi <= zhi) {
544 return true;
545 }
546 }
547
548 // (x_y_lo <= zhi - 2**nbits && zhi - 2**nbits <= x_y_hi)
549 if (x_y_lo_overflow) {
550 if (x_y_lo <= zhi && (!x_y_hi_overflow || zhi <= x_y_hi)) {
551 return true;
552 }
553 }
554 }
555
556 return false;
557 }
558
559 static bool ranges_overlap(const TypeInteger* tx, const TypeInteger* ty, const TypeInteger* tz,
560 const Node* n, bool pos, BasicType bt) {
561 jlong xlo = tx->lo_as_long();
562 jlong xhi = tx->hi_as_long();
563 jlong ylo = ty->lo_as_long();
564 jlong yhi = ty->hi_as_long();
565 jlong zlo = tz->lo_as_long();
566 jlong zhi = tz->hi_as_long();
567
568 if (bt == T_INT) {
569 // See if x+y can cause positive overflow into z+2**32
570 // See if x+y can cause negative overflow into z-2**32
571 bool res = ranges_overlap(checked_cast<jint>(xlo), checked_cast<jint>(ylo),
572 checked_cast<jint>(xhi), checked_cast<jint>(yhi),
573 checked_cast<jint>(zlo), checked_cast<jint>(zhi), n, pos);
574 #ifdef ASSERT
575 jlong vbit = CONST64(1) << BitsPerInt;
576 if (n->Opcode() == Op_SubI) {
577 jlong ylo0 = ylo;
578 ylo = -yhi;
579 yhi = -ylo0;
580 }
581 assert(res == long_ranges_overlap(xlo+ylo, xhi+yhi, pos ? zlo+vbit : zlo-vbit, pos ? zhi+vbit : zhi-vbit), "inconsistent result");
582 #endif
583 return res;
584 }
585 assert(bt == T_LONG, "only int or long");
586 // See if x+y can cause positive overflow into z+2**64
587 // See if x+y can cause negative overflow into z-2**64
588 return ranges_overlap(xlo, ylo, xhi, yhi, zlo, zhi, n, pos);
589 }
590
591 #ifdef ASSERT
592 static bool compute_updates_ranges_verif(const TypeInteger* tx, const TypeInteger* ty, const TypeInteger* tz,
593 jlong& rxlo, jlong& rxhi, jlong& rylo, jlong& ryhi,
594 const Node* n) {
595 jlong xlo = tx->lo_as_long();
596 jlong xhi = tx->hi_as_long();
597 jlong ylo = ty->lo_as_long();
598 jlong yhi = ty->hi_as_long();
599 jlong zlo = tz->lo_as_long();
600 jlong zhi = tz->hi_as_long();
601 if (n->is_Sub()) {
602 swap(ylo, yhi);
603 ylo = -ylo;
604 yhi = -yhi;
605 }
606
607 rxlo = MAX2(xlo, zlo - yhi);
608 rxhi = MIN2(xhi, zhi - ylo);
609 rylo = MAX2(ylo, zlo - xhi);
610 ryhi = MIN2(yhi, zhi - xlo);
611 if (rxlo > rxhi || rylo > ryhi) {
612 return false;
613 }
614 if (n->is_Sub()) {
615 swap(rylo, ryhi);
616 rylo = -rylo;
617 ryhi = -ryhi;
618 }
619 assert(rxlo == (int) rxlo && rxhi == (int) rxhi, "x should not overflow");
620 assert(rylo == (int) rylo && ryhi == (int) ryhi, "y should not overflow");
621 return true;
622 }
623 #endif
624
625 template<class T> static bool compute_updates_ranges(T xlo, T ylo, T xhi, T yhi, T zlo, T zhi,
626 jlong& rxlo, jlong& rxhi, jlong& rylo, jlong& ryhi,
627 const Node* n) {
628 assert(xlo <= xhi && ylo <= yhi && zlo <= zhi, "should not be empty types");
629
630 // Now it's always safe to assume x+y does not overflow.
631 // This is true even if some pairs x,y might cause overflow, as long
632 // as that overflow value cannot fall into [zlo,zhi].
633
634 // Confident that the arithmetic is "as if infinite precision",
635 // we can now use n's range to put constraints on those of x and y.
636 // The "natural" range of x [xlo,xhi] can perhaps be narrowed to a
637 // more "restricted" range by intersecting [xlo,xhi] with the
638 // range obtained by subtracting y's range from the asserted range
639 // of the I2L conversion. Here's the interval arithmetic algebra:
640 // x == n-y == [zlo,zhi]-[ylo,yhi] == [zlo,zhi]+[-yhi,-ylo]
641 // => x in [zlo-yhi, zhi-ylo]
642 // => x in [zlo-yhi, zhi-ylo] INTERSECT [xlo,xhi]
643 // => x in [xlo MAX zlo-yhi, xhi MIN zhi-ylo]
644 // And similarly, x changing place with y.
645 if (n->is_Sub()) {
646 if (add_overflows(zlo, ylo) || add_underflows(zhi, yhi) || subtract_underflows(xhi, zlo) ||
647 subtract_overflows(xlo, zhi)) {
648 return false;
649 }
650 rxlo = add_underflows(zlo, ylo) ? xlo : MAX2(xlo, java_add(zlo, ylo));
651 rxhi = add_overflows(zhi, yhi) ? xhi : MIN2(xhi, java_add(zhi, yhi));
652 ryhi = subtract_overflows(xhi, zlo) ? yhi : MIN2(yhi, java_subtract(xhi, zlo));
653 rylo = subtract_underflows(xlo, zhi) ? ylo : MAX2(ylo, java_subtract(xlo, zhi));
654 } else {
655 assert(n->is_Add(), "Add or Sub only");
656 if (subtract_overflows(zlo, yhi) || subtract_underflows(zhi, ylo) ||
657 subtract_overflows(zlo, xhi) || subtract_underflows(zhi, xlo)) {
658 return false;
659 }
660 rxlo = subtract_underflows(zlo, yhi) ? xlo : MAX2(xlo, java_subtract(zlo, yhi));
661 rxhi = subtract_overflows(zhi, ylo) ? xhi : MIN2(xhi, java_subtract(zhi, ylo));
662 rylo = subtract_underflows(zlo, xhi) ? ylo : MAX2(ylo, java_subtract(zlo, xhi));
663 ryhi = subtract_overflows(zhi, xlo) ? yhi : MIN2(yhi, java_subtract(zhi, xlo));
664 }
665
666 if (rxlo > rxhi || rylo > ryhi) {
667 return false; // x or y is dying; don't mess w/ it
668 }
669
670 return true;
671 }
672
673 static bool compute_updates_ranges(const TypeInteger* tx, const TypeInteger* ty, const TypeInteger* tz,
674 const TypeInteger*& rx, const TypeInteger*& ry,
675 const Node* n, const BasicType in_bt, BasicType out_bt) {
676
677 jlong xlo = tx->lo_as_long();
678 jlong xhi = tx->hi_as_long();
679 jlong ylo = ty->lo_as_long();
680 jlong yhi = ty->hi_as_long();
681 jlong zlo = tz->lo_as_long();
682 jlong zhi = tz->hi_as_long();
683 jlong rxlo, rxhi, rylo, ryhi;
684
685 if (in_bt == T_INT) {
686 #ifdef ASSERT
687 jlong expected_rxlo, expected_rxhi, expected_rylo, expected_ryhi;
688 bool expected = compute_updates_ranges_verif(tx, ty, tz,
689 expected_rxlo, expected_rxhi,
690 expected_rylo, expected_ryhi, n);
691 #endif
692 if (!compute_updates_ranges(checked_cast<jint>(xlo), checked_cast<jint>(ylo),
693 checked_cast<jint>(xhi), checked_cast<jint>(yhi),
694 checked_cast<jint>(zlo), checked_cast<jint>(zhi),
695 rxlo, rxhi, rylo, ryhi, n)) {
696 assert(!expected, "inconsistent");
697 return false;
698 }
699 assert(expected && rxlo == expected_rxlo && rxhi == expected_rxhi && rylo == expected_rylo && ryhi == expected_ryhi, "inconsistent");
700 } else {
701 if (!compute_updates_ranges(xlo, ylo, xhi, yhi, zlo, zhi,
702 rxlo, rxhi, rylo, ryhi, n)) {
703 return false;
704 }
705 }
706
707 int widen = MAX2(tx->widen_limit(), ty->widen_limit());
708 rx = TypeInteger::make(rxlo, rxhi, widen, out_bt);
709 ry = TypeInteger::make(rylo, ryhi, widen, out_bt);
710 return true;
711 }
712
713 #ifdef _LP64
714 // If there is an existing ConvI2L node with the given parent and type, return
715 // it. Otherwise, create and return a new one. Both reusing existing ConvI2L
716 // nodes and postponing the idealization of new ones are needed to avoid an
717 // explosion of recursive Ideal() calls when compiling long AddI chains.
718 static Node* find_or_make_convI2L(PhaseIterGVN* igvn, Node* parent,
719 const TypeLong* type) {
720 Node* n = new ConvI2LNode(parent, type);
721 Node* existing = igvn->hash_find_insert(n);
722 if (existing != nullptr) {
723 n->destruct(igvn);
724 return existing;
725 }
726 return igvn->register_new_node_with_optimizer(n);
727 }
728 #endif
729
730 bool Compile::push_thru_add(PhaseGVN* phase, Node* z, const TypeInteger* tz, const TypeInteger*& rx, const TypeInteger*& ry,
731 BasicType in_bt, BasicType out_bt) {
732 int op = z->Opcode();
733 if (op == Op_Add(in_bt) || op == Op_Sub(in_bt)) {
734 Node* x = z->in(1);
735 Node* y = z->in(2);
736 assert (x != z && y != z, "dead loop in ConvI2LNode::Ideal");
737 if (phase->type(x) == Type::TOP) {
738 return false;
739 }
740 if (phase->type(y) == Type::TOP) {
741 return false;
742 }
743 const TypeInteger* tx = phase->type(x)->is_integer(in_bt);
744 const TypeInteger* ty = phase->type(y)->is_integer(in_bt);
745
746 if (ranges_overlap(tx, ty, tz, z, true, in_bt) ||
747 ranges_overlap(tx, ty, tz, z, false, in_bt)) {
748 return false;
749 }
750 return compute_updates_ranges(tx, ty, tz, rx, ry, z, in_bt, out_bt);
751 }
752 return false;
753 }
754
755
756 //------------------------------Ideal------------------------------------------
757 Node* ConvI2LNode::Ideal(PhaseGVN* phase, bool can_reshape) {
758 if (in(1) != nullptr && phase->type(in(1)) != Type::TOP) {
759 Node* progress = TypeNode::Ideal(phase, can_reshape);
760 if (progress != nullptr) {
761 return progress;
762 }
763 }
764
765 const TypeLong* this_type = this->type()->is_long();
766 if (can_reshape && !phase->C->post_loop_opts_phase()) {
767 // makes sure we run ::Value to potentially remove type assertion after loop opts
768 phase->C->record_for_post_loop_opts_igvn(this);
769 }
770 #ifdef _LP64
771 // Convert ConvI2L(AddI(x, y)) to AddL(ConvI2L(x), ConvI2L(y))
772 // but only if x and y have subranges that cannot cause 32-bit overflow,
773 // under the assumption that x+y is in my own subrange this->type().
774
775 // This assumption is based on a constraint (i.e., type assertion)
776 // established in Parse::array_addressing or perhaps elsewhere.
777 // This constraint has been adjoined to the "natural" type of
778 // the incoming argument in(0). We know (because of runtime
779 // checks) - that the result value I2L(x+y) is in the joined range.
780 // Hence we can restrict the incoming terms (x, y) to values such
781 // that their sum also lands in that range.
782
783 // This optimization is useful only on 64-bit systems, where we hope
784 // the addition will end up subsumed in an addressing mode.
785 // It is necessary to do this when optimizing an unrolled array
786 // copy loop such as x[i++] = y[i++].
787
788 // On 32-bit systems, it's better to perform as much 32-bit math as
789 // possible before the I2L conversion, because 32-bit math is cheaper.
790 // There's no common reason to "leak" a constant offset through the I2L.
791 // Addressing arithmetic will not absorb it as part of a 64-bit AddL.
792 PhaseIterGVN* igvn = phase->is_IterGVN();
793 Node* z = in(1);
794 const TypeInteger* rx = nullptr;
795 const TypeInteger* ry = nullptr;
796 if (Compile::push_thru_add(phase, z, this_type, rx, ry, T_INT, T_LONG)) {
797 if (igvn == nullptr) {
798 // Postpone this optimization to iterative GVN, where we can handle deep
799 // AddI chains without an exponential number of recursive Ideal() calls.
800 phase->record_for_igvn(this);
801 return nullptr;
802 }
803 int op = z->Opcode();
804 Node* x = z->in(1);
805 Node* y = z->in(2);
806
807 Node* cx = find_or_make_convI2L(igvn, x, rx->is_long());
808 Node* cy = find_or_make_convI2L(igvn, y, ry->is_long());
809 switch (op) {
810 case Op_AddI: return new AddLNode(cx, cy);
811 case Op_SubI: return new SubLNode(cx, cy);
812 default: ShouldNotReachHere();
813 }
814 }
815 #endif //_LP64
816
817 return nullptr;
818 }
819
820 //=============================================================================
821 //------------------------------Value------------------------------------------
822 const Type* ConvL2DNode::Value(PhaseGVN* phase) const {
823 const Type *t = phase->type( in(1) );
824 if( t == Type::TOP ) return Type::TOP;
825 const TypeLong *tl = t->is_long();
826 if( tl->is_con() ) return TypeD::make( (double)tl->get_con() );
827 return Type::DOUBLE;
828 }
829
830 //=============================================================================
831 //------------------------------Value------------------------------------------
832 const Type* ConvL2FNode::Value(PhaseGVN* phase) const {
833 const Type *t = phase->type( in(1) );
834 if( t == Type::TOP ) return Type::TOP;
835 const TypeLong *tl = t->is_long();
836 if( tl->is_con() ) return TypeF::make( (float)tl->get_con() );
837 return Type::FLOAT;
838 }
839
840 //=============================================================================
841 //----------------------------Identity-----------------------------------------
842 Node* ConvL2INode::Identity(PhaseGVN* phase) {
843 // Convert L2I(I2L(x)) => x
844 if (in(1)->Opcode() == Op_ConvI2L) return in(1)->in(1);
845 return this;
846 }
847
848 //------------------------------Value------------------------------------------
849 const Type* ConvL2INode::Value(PhaseGVN* phase) const {
850 const Type *t = phase->type( in(1) );
851 if( t == Type::TOP ) return Type::TOP;
852 const TypeLong *tl = t->is_long();
853 const TypeInt* ti = TypeInt::INT;
854 if (tl->is_con()) {
855 // Easy case.
856 ti = TypeInt::make((jint)tl->get_con());
857 } else if (tl->_lo >= min_jint && tl->_hi <= max_jint) {
858 ti = TypeInt::make((jint)tl->_lo, (jint)tl->_hi, tl->_widen);
859 }
860 return ti->filter(_type);
861 }
862
863 //------------------------------Ideal------------------------------------------
864 // Return a node which is more "ideal" than the current node.
865 // Blow off prior masking to int
866 Node* ConvL2INode::Ideal(PhaseGVN* phase, bool can_reshape) {
867 if (in(1) != nullptr && phase->type(in(1)) != Type::TOP) {
868 Node* progress = TypeNode::Ideal(phase, can_reshape);
869 if (progress != nullptr) {
870 return progress;
871 }
872 }
873
874 Node *andl = in(1);
875 uint andl_op = andl->Opcode();
876 if( andl_op == Op_AndL ) {
877 // Blow off prior masking to int
878 if( phase->type(andl->in(2)) == TypeLong::make( 0xFFFFFFFF ) ) {
879 set_req_X(1,andl->in(1), phase);
880 return this;
881 }
882 }
883
884 // Swap with a prior add: convL2I(addL(x,y)) ==> addI(convL2I(x),convL2I(y))
885 // This replaces an 'AddL' with an 'AddI'.
886 if( andl_op == Op_AddL ) {
887 // Don't do this for nodes which have more than one user since
888 // we'll end up computing the long add anyway.
889 if (andl->outcnt() > 1) return nullptr;
890
891 Node* x = andl->in(1);
892 Node* y = andl->in(2);
893 assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
894 if (phase->type(x) == Type::TOP) return nullptr;
895 if (phase->type(y) == Type::TOP) return nullptr;
896 Node *add1 = phase->transform(new ConvL2INode(x));
897 Node *add2 = phase->transform(new ConvL2INode(y));
898 return new AddINode(add1,add2);
899 }
900
901 // Disable optimization: LoadL->ConvL2I ==> LoadI.
902 // It causes problems (sizes of Load and Store nodes do not match)
903 // in objects initialization code and Escape Analysis.
904 return nullptr;
905 }
906
907 //=============================================================================
908 RoundDoubleModeNode* RoundDoubleModeNode::make(PhaseGVN& gvn, Node* arg, RoundDoubleModeNode::RoundingMode rmode) {
909 ConINode* rm = gvn.intcon(rmode);
910 return new RoundDoubleModeNode(arg, (Node *)rm);
911 }
912
913 //------------------------------Identity---------------------------------------
914 // Remove redundant roundings.
915 Node* RoundDoubleModeNode::Identity(PhaseGVN* phase) {
916 int op = in(1)->Opcode();
917 // Redundant rounding e.g. floor(ceil(n)) -> ceil(n)
918 if(op == Op_RoundDoubleMode) return in(1);
919 return this;
920 }
921 const Type* RoundDoubleModeNode::Value(PhaseGVN* phase) const {
922 return Type::DOUBLE;
923 }
924 //=============================================================================
925
926 const Type* ReinterpretS2HFNode::Value(PhaseGVN* phase) const {
927 const Type* type = phase->type(in(1));
928 // Convert short constant value to a Half Float constant value
929 if ((type->isa_int() && type->is_int()->is_con())) {
930 jshort hfval = type->is_int()->get_con();
931 return TypeH::make(hfval);
932 }
933 return Type::HALF_FLOAT;
934 }
935
936 Node* ReinterpretS2HFNode::Identity(PhaseGVN* phase) {
937 if (in(1)->Opcode() == Op_ReinterpretHF2S) {
938 assert(in(1)->in(1)->bottom_type()->isa_half_float(), "");
939 return in(1)->in(1);
940 }
941 return this;
942 }
943
944 const Type* ReinterpretHF2SNode::Value(PhaseGVN* phase) const {
945 const Type* type = phase->type(in(1));
946 // Convert Half float constant value to short constant value.
947 if (type->isa_half_float_constant()) {
948 jshort hfval = type->is_half_float_constant()->_f;
949 return TypeInt::make(hfval);
950 }
951 return TypeInt::SHORT;
952 }
953
954 bool Float16NodeFactory::is_float32_binary_oper(int opc) {
955 switch(opc) {
956 case Op_AddF:
957 case Op_SubF:
958 case Op_MulF:
959 case Op_DivF:
960 case Op_MaxF:
961 case Op_MinF:
962 return true;
963 default:
964 return false;
965 }
966 }
967
968 int Float16NodeFactory::get_float16_binary_oper(int opc) {
969 switch(opc) {
970 case Op_AddF:
971 return Op_AddHF;
972 case Op_SubF:
973 return Op_SubHF;
974 case Op_MulF:
975 return Op_MulHF;
976 case Op_DivF:
977 return Op_DivHF;
978 case Op_MaxF:
979 return Op_MaxHF;
980 case Op_MinF:
981 return Op_MinHF;
982 default: ShouldNotReachHere();
983 }
984 }
985
986 Node* Float16NodeFactory::make(int opc, Node* c, Node* in1, Node* in2) {
987 switch(opc) {
988 case Op_AddF: return new AddHFNode(in1, in2);
989 case Op_SubF: return new SubHFNode(in1, in2);
990 case Op_MulF: return new MulHFNode(in1, in2);
991 case Op_DivF: return new DivHFNode(c, in1, in2);
992 case Op_MaxF: return new MaxHFNode(in1, in2);
993 case Op_MinF: return new MinHFNode(in1, in2);
994 default: ShouldNotReachHere();
995 }
996 }