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