1 /*
2 * Copyright (c) 1999, 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 "c1/c1_Canonicalizer.hpp"
26 #include "c1/c1_InstructionPrinter.hpp"
27 #include "c1/c1_ValueStack.hpp"
28 #include "ci/ciArray.hpp"
29 #include "runtime/sharedRuntime.hpp"
30
31
32 class PrintValueVisitor: public ValueVisitor {
33 void visit(Value* vp) {
34 (*vp)->print_line();
35 }
36 };
37
38 void Canonicalizer::set_canonical(Value x) {
39 assert(x != nullptr, "value must exist");
40 // Note: we can not currently substitute root nodes which show up in
41 // the instruction stream (because the instruction list is embedded
42 // in the instructions).
43 if (canonical() != x) {
44 #ifndef PRODUCT
45 if (!x->has_printable_bci()) {
46 x->set_printable_bci(bci());
47 }
48 #endif
49 if (PrintCanonicalization) {
50 PrintValueVisitor do_print_value;
51 canonical()->input_values_do(&do_print_value);
52 canonical()->print_line();
53 tty->print_cr("canonicalized to:");
54 x->input_values_do(&do_print_value);
55 x->print_line();
56 tty->cr();
57 }
58 assert(_canonical->type()->tag() == x->type()->tag(), "types must match");
59 _canonical = x;
60 }
61 }
62
63
64 void Canonicalizer::move_const_to_right(Op2* x) {
65 if (x->x()->type()->is_constant() && x->is_commutative()) x->swap_operands();
66 }
67
68
69 void Canonicalizer::do_Op2(Op2* x) {
70 if (x->x() == x->y()) {
71 switch (x->op()) {
72 case Bytecodes::_isub: set_constant(0); return;
73 case Bytecodes::_lsub: set_constant(jlong_cast(0)); return;
74 case Bytecodes::_iand: // fall through
75 case Bytecodes::_land: // fall through
76 case Bytecodes::_ior : // fall through
77 case Bytecodes::_lor : set_canonical(x->x()); return;
78 case Bytecodes::_ixor: set_constant(0); return;
79 case Bytecodes::_lxor: set_constant(jlong_cast(0)); return;
80 default : break;
81 }
82 }
83
84 if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) {
85 // do constant folding for selected operations
86 switch (x->type()->tag()) {
87 case intTag:
88 { jint a = x->x()->type()->as_IntConstant()->value();
89 jint b = x->y()->type()->as_IntConstant()->value();
90 switch (x->op()) {
91 case Bytecodes::_iadd: set_constant(java_add(a, b)); return;
92 case Bytecodes::_isub: set_constant(java_subtract(a, b)); return;
93 case Bytecodes::_imul: set_constant(java_multiply(a, b)); return;
94 case Bytecodes::_idiv:
95 if (b != 0) {
96 if (a == min_jint && b == -1) {
97 set_constant(min_jint);
98 } else {
99 set_constant(a / b);
100 }
101 return;
102 }
103 break;
104 case Bytecodes::_irem:
105 if (b != 0) {
106 if (a == min_jint && b == -1) {
107 set_constant(0);
108 } else {
109 set_constant(a % b);
110 }
111 return;
112 }
113 break;
114 case Bytecodes::_iand: set_constant(a & b); return;
115 case Bytecodes::_ior : set_constant(a | b); return;
116 case Bytecodes::_ixor: set_constant(a ^ b); return;
117 default : break;
118 }
119 }
120 break;
121 case longTag:
122 { jlong a = x->x()->type()->as_LongConstant()->value();
123 jlong b = x->y()->type()->as_LongConstant()->value();
124 switch (x->op()) {
125 case Bytecodes::_ladd: set_constant(java_add(a, b)); return;
126 case Bytecodes::_lsub: set_constant(java_subtract(a, b)); return;
127 case Bytecodes::_lmul: set_constant(java_multiply(a, b)); return;
128 case Bytecodes::_ldiv:
129 if (b != 0) {
130 set_constant(SharedRuntime::ldiv(b, a));
131 return;
132 }
133 break;
134 case Bytecodes::_lrem:
135 if (b != 0) {
136 set_constant(SharedRuntime::lrem(b, a));
137 return;
138 }
139 break;
140 case Bytecodes::_land: set_constant(a & b); return;
141 case Bytecodes::_lor : set_constant(a | b); return;
142 case Bytecodes::_lxor: set_constant(a ^ b); return;
143 default : break;
144 }
145 }
146 break;
147 default:
148 // other cases not implemented (must be extremely careful with floats & doubles!)
149 break;
150 }
151 }
152 // make sure constant is on the right side, if any
153 move_const_to_right(x);
154
155 if (x->y()->type()->is_constant()) {
156 // do constant folding for selected operations
157 switch (x->type()->tag()) {
158 case intTag:
159 if (x->y()->type()->as_IntConstant()->value() == 0) {
160 switch (x->op()) {
161 case Bytecodes::_iadd: set_canonical(x->x()); return;
162 case Bytecodes::_isub: set_canonical(x->x()); return;
163 case Bytecodes::_imul: set_constant(0); return;
164 // Note: for div and rem, make sure that C semantics
165 // corresponds to Java semantics!
166 case Bytecodes::_iand: set_constant(0); return;
167 case Bytecodes::_ior : set_canonical(x->x()); return;
168 default : break;
169 }
170 }
171 break;
172 case longTag:
173 if (x->y()->type()->as_LongConstant()->value() == (jlong)0) {
174 switch (x->op()) {
175 case Bytecodes::_ladd: set_canonical(x->x()); return;
176 case Bytecodes::_lsub: set_canonical(x->x()); return;
177 case Bytecodes::_lmul: set_constant((jlong)0); return;
178 // Note: for div and rem, make sure that C semantics
179 // corresponds to Java semantics!
180 case Bytecodes::_land: set_constant((jlong)0); return;
181 case Bytecodes::_lor : set_canonical(x->x()); return;
182 default : break;
183 }
184 }
185 break;
186 default:
187 break;
188 }
189 }
190 }
191
192
193 void Canonicalizer::do_Phi (Phi* x) {}
194 void Canonicalizer::do_Constant (Constant* x) {}
195 void Canonicalizer::do_Local (Local* x) {}
196 void Canonicalizer::do_LoadField (LoadField* x) {}
197
198 // checks if v is in the block that is currently processed by
199 // GraphBuilder. This is the only block that has not BlockEnd yet.
200 static bool in_current_block(Value v) {
201 int max_distance = 4;
202 while (max_distance > 0 && v != nullptr && v->as_BlockEnd() == nullptr) {
203 v = v->next();
204 max_distance--;
205 }
206 return v == nullptr;
207 }
208
209 void Canonicalizer::do_StoreField (StoreField* x) {
210 // If a value is going to be stored into a field or array some of
211 // the conversions emitted by javac are unneeded because the fields
212 // are packed to their natural size.
213 Convert* conv = x->value()->as_Convert();
214 if (conv) {
215 Value value = nullptr;
216 BasicType type = x->field()->type()->basic_type();
217 switch (conv->op()) {
218 case Bytecodes::_i2b: if (type == T_BYTE) value = conv->value(); break;
219 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break;
220 case Bytecodes::_i2c: if (type == T_CHAR || type == T_BYTE) value = conv->value(); break;
221 default : break;
222 }
223 // limit this optimization to current block
224 if (value != nullptr && in_current_block(conv)) {
225 set_canonical(new StoreField(x->obj(), x->offset(), x->field(), value, x->is_static(),
226 x->state_before(), x->needs_patching()));
227 return;
228 }
229 }
230
231 }
232
233 void Canonicalizer::do_ArrayLength (ArrayLength* x) {
234 NewArray* na;
235 Constant* ct;
236 LoadField* lf;
237
238 if ((na = x->array()->as_NewArray()) != nullptr) {
239 // New arrays might have the known length.
240 // Do not use the Constant itself, but create a new Constant
241 // with same value Otherwise a Constant is live over multiple
242 // blocks without being registered in a state array.
243 Constant* length;
244 NewMultiArray* nma;
245 if (na->length() != nullptr &&
246 (length = na->length()->as_Constant()) != nullptr) {
247 assert(length->type()->as_IntConstant() != nullptr, "array length must be integer");
248 set_constant(length->type()->as_IntConstant()->value());
249 } else if ((nma = x->array()->as_NewMultiArray()) != nullptr &&
250 (length = nma->dims()->at(0)->as_Constant()) != nullptr) {
251 assert(length->type()->as_IntConstant() != nullptr, "array length must be integer");
252 set_constant(length->type()->as_IntConstant()->value());
253 }
254
255 } else if ((ct = x->array()->as_Constant()) != nullptr) {
256 // Constant arrays have constant lengths.
257 ArrayConstant* cnst = ct->type()->as_ArrayConstant();
258 if (cnst != nullptr) {
259 set_constant(cnst->value()->length());
260 }
261
262 } else if ((lf = x->array()->as_LoadField()) != nullptr) {
263 ciField* field = lf->field();
264 if (field->is_static_constant()) {
265 // Constant field loads are usually folded during parsing.
266 // But it doesn't happen with PatchALot, ScavengeRootsInCode < 2, or when
267 // holder class is being initialized during parsing (for static fields).
268 ciObject* c = field->constant_value().as_object();
269 if (!c->is_null_object()) {
270 set_constant(c->as_array()->length());
271 }
272 }
273 }
274 }
275
276 void Canonicalizer::do_LoadIndexed (LoadIndexed* x) {
277 StableArrayConstant* array = x->array()->type()->as_StableArrayConstant();
278 IntConstant* index = x->index()->type()->as_IntConstant();
279
280 assert(array == nullptr || FoldStableValues, "not enabled");
281
282 // Constant fold loads from stable arrays.
283 if (!x->mismatched() && array != nullptr && index != nullptr) {
284 jint idx = index->value();
285 if (idx < 0 || idx >= array->value()->length()) {
286 // Leave the load as is. The range check will handle it.
287 return;
288 }
289
290 ciConstant field_val = array->value()->element_value(idx);
291 if (!field_val.is_null_or_zero()) {
292 jint dimension = array->dimension();
293 assert(dimension <= array->value()->array_type()->dimension(), "inconsistent info");
294 ValueType* value = nullptr;
295 if (dimension > 1) {
296 // Preserve information about the dimension for the element.
297 assert(field_val.as_object()->is_array(), "not an array");
298 value = new StableArrayConstant(field_val.as_object()->as_array(), dimension - 1);
299 } else {
300 assert(dimension == 1, "sanity");
301 value = as_ValueType(field_val);
302 }
303 set_canonical(new Constant(value));
304 }
305 }
306 }
307
308 void Canonicalizer::do_StoreIndexed (StoreIndexed* x) {
309 // If a value is going to be stored into a field or array some of
310 // the conversions emitted by javac are unneeded because the fields
311 // are packed to their natural size.
312 Convert* conv = x->value()->as_Convert();
313 if (conv) {
314 Value value = nullptr;
315 BasicType type = x->elt_type();
316 switch (conv->op()) {
317 case Bytecodes::_i2b: if (type == T_BYTE) value = conv->value(); break;
318 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break;
319 case Bytecodes::_i2c: if (type == T_CHAR || type == T_BYTE) value = conv->value(); break;
320 default : break;
321 }
322 // limit this optimization to current block
323 if (value != nullptr && in_current_block(conv)) {
324 set_canonical(new StoreIndexed(x->array(), x->index(), x->length(),
325 x->elt_type(), value, x->state_before(),
326 x->check_boolean()));
327 return;
328 }
329 }
330 }
331
332
333 void Canonicalizer::do_NegateOp(NegateOp* x) {
334 ValueType* t = x->x()->type();
335 if (t->is_constant()) {
336 switch (t->tag()) {
337 case intTag : set_constant(java_negate(t->as_IntConstant()->value())); return;
338 case longTag : set_constant(java_negate(t->as_LongConstant()->value())); return;
339 case floatTag : set_constant(-t->as_FloatConstant()->value()); return;
340 case doubleTag: set_constant(-t->as_DoubleConstant()->value()); return;
341 default : ShouldNotReachHere();
342 }
343 }
344 }
345
346
347 void Canonicalizer::do_ArithmeticOp (ArithmeticOp* x) { do_Op2(x); }
348
349
350 void Canonicalizer::do_ShiftOp (ShiftOp* x) {
351 ValueType* t = x->x()->type();
352 ValueType* t2 = x->y()->type();
353 if (t->is_constant()) {
354 switch (t->tag()) {
355 case intTag : if (t->as_IntConstant()->value() == 0) { set_constant(0); return; } break;
356 case longTag : if (t->as_LongConstant()->value() == (jlong)0) { set_constant(jlong_cast(0)); return; } break;
357 default : ShouldNotReachHere();
358 }
359 if (t2->is_constant()) {
360 if (t->tag() == intTag) {
361 jint value = t->as_IntConstant()->value();
362 jint shift = t2->as_IntConstant()->value();
363 switch (x->op()) {
364 case Bytecodes::_ishl: set_constant(java_shift_left(value, shift)); return;
365 case Bytecodes::_ishr: set_constant(java_shift_right(value, shift)); return;
366 case Bytecodes::_iushr: set_constant(java_shift_right_unsigned(value, shift)); return;
367 default: break;
368 }
369 } else if (t->tag() == longTag) {
370 jlong value = t->as_LongConstant()->value();
371 jint shift = t2->as_IntConstant()->value();
372 switch (x->op()) {
373 case Bytecodes::_lshl: set_constant(java_shift_left(value, shift)); return;
374 case Bytecodes::_lshr: set_constant(java_shift_right(value, shift)); return;
375 case Bytecodes::_lushr: set_constant(java_shift_right_unsigned(value, shift)); return;
376 default: break;
377 }
378 }
379 }
380 }
381 if (t2->is_constant()) {
382 switch (t2->tag()) {
383 case intTag : if (t2->as_IntConstant()->value() == 0) set_canonical(x->x()); return;
384 case longTag : if (t2->as_LongConstant()->value() == (jlong)0) set_canonical(x->x()); return;
385 default : ShouldNotReachHere(); return;
386 }
387 }
388 }
389
390
391 void Canonicalizer::do_LogicOp (LogicOp* x) { do_Op2(x); }
392 void Canonicalizer::do_CompareOp (CompareOp* x) {
393 if (x->x() == x->y()) {
394 switch (x->x()->type()->tag()) {
395 case longTag: set_constant(0); break;
396 case floatTag: {
397 FloatConstant* fc = x->x()->type()->as_FloatConstant();
398 if (fc) {
399 if (g_isnan(fc->value())) {
400 set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1);
401 } else {
402 set_constant(0);
403 }
404 }
405 break;
406 }
407 case doubleTag: {
408 DoubleConstant* dc = x->x()->type()->as_DoubleConstant();
409 if (dc) {
410 if (g_isnan(dc->value())) {
411 set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1);
412 } else {
413 set_constant(0);
414 }
415 }
416 break;
417 }
418 default:
419 break;
420 }
421 } else if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) {
422 switch (x->x()->type()->tag()) {
423 case longTag: {
424 jlong vx = x->x()->type()->as_LongConstant()->value();
425 jlong vy = x->y()->type()->as_LongConstant()->value();
426 if (vx == vy)
427 set_constant(0);
428 else if (vx < vy)
429 set_constant(-1);
430 else
431 set_constant(1);
432 break;
433 }
434
435 case floatTag: {
436 float vx = x->x()->type()->as_FloatConstant()->value();
437 float vy = x->y()->type()->as_FloatConstant()->value();
438 if (g_isnan(vx) || g_isnan(vy))
439 set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1);
440 else if (vx == vy)
441 set_constant(0);
442 else if (vx < vy)
443 set_constant(-1);
444 else
445 set_constant(1);
446 break;
447 }
448
449 case doubleTag: {
450 double vx = x->x()->type()->as_DoubleConstant()->value();
451 double vy = x->y()->type()->as_DoubleConstant()->value();
452 if (g_isnan(vx) || g_isnan(vy))
453 set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1);
454 else if (vx == vy)
455 set_constant(0);
456 else if (vx < vy)
457 set_constant(-1);
458 else
459 set_constant(1);
460 break;
461 }
462
463 default:
464 break;
465 }
466 }
467 }
468
469
470 void Canonicalizer::do_IfOp(IfOp* x) {
471 // Currently, Canonicalizer is only used by GraphBuilder,
472 // and IfOp is not created by GraphBuilder but only later
473 // when eliminating conditional expressions with CE_Eliminator,
474 // so this method will not be called.
475 ShouldNotReachHere();
476 }
477
478
479 void Canonicalizer::do_Intrinsic (Intrinsic* x) {
480 switch (x->id()) {
481 case vmIntrinsics::_floatToRawIntBits : {
482 FloatConstant* c = x->argument_at(0)->type()->as_FloatConstant();
483 if (c != nullptr) {
484 JavaValue v;
485 v.set_jfloat(c->value());
486 set_constant(v.get_jint());
487 }
488 break;
489 }
490 case vmIntrinsics::_intBitsToFloat : {
491 IntConstant* c = x->argument_at(0)->type()->as_IntConstant();
492 if (c != nullptr) {
493 JavaValue v;
494 v.set_jint(c->value());
495 set_constant(v.get_jfloat());
496 }
497 break;
498 }
499 case vmIntrinsics::_doubleToRawLongBits : {
500 DoubleConstant* c = x->argument_at(0)->type()->as_DoubleConstant();
501 if (c != nullptr) {
502 JavaValue v;
503 v.set_jdouble(c->value());
504 set_constant(v.get_jlong());
505 }
506 break;
507 }
508 case vmIntrinsics::_longBitsToDouble : {
509 LongConstant* c = x->argument_at(0)->type()->as_LongConstant();
510 if (c != nullptr) {
511 JavaValue v;
512 v.set_jlong(c->value());
513 set_constant(v.get_jdouble());
514 }
515 break;
516 }
517 case vmIntrinsics::_isInstance : {
518 assert(x->number_of_arguments() == 2, "wrong type");
519
520 InstanceConstant* c = x->argument_at(0)->type()->as_InstanceConstant();
521 if (c != nullptr && !c->value()->is_null_object()) {
522 // ciInstance::java_mirror_type() returns non-null only for Java mirrors
523 ciType* t = c->value()->java_mirror_type();
524 if (t->is_klass()) {
525 // substitute cls.isInstance(obj) of a constant Class into
526 // an InstanceOf instruction
527 InstanceOf* i = new InstanceOf(t->as_klass(), x->argument_at(1), x->state_before());
528 set_canonical(i);
529 // and try to canonicalize even further
530 do_InstanceOf(i);
531 } else {
532 assert(t->is_primitive_type(), "should be a primitive type");
533 // cls.isInstance(obj) always returns false for primitive classes
534 set_constant(0);
535 }
536 }
537 break;
538 }
539 default:
540 break;
541 }
542 }
543
544 void Canonicalizer::do_Convert (Convert* x) {
545 if (x->value()->type()->is_constant()) {
546 switch (x->op()) {
547 case Bytecodes::_i2b: set_constant((int)((x->value()->type()->as_IntConstant()->value() << 24) >> 24)); break;
548 case Bytecodes::_i2s: set_constant((int)((x->value()->type()->as_IntConstant()->value() << 16) >> 16)); break;
549 case Bytecodes::_i2c: set_constant((int)(x->value()->type()->as_IntConstant()->value() & ((1<<16)-1))); break;
550 case Bytecodes::_i2l: set_constant((jlong)(x->value()->type()->as_IntConstant()->value())); break;
551 case Bytecodes::_i2f: set_constant((float)(x->value()->type()->as_IntConstant()->value())); break;
552 case Bytecodes::_i2d: set_constant((double)(x->value()->type()->as_IntConstant()->value())); break;
553 case Bytecodes::_l2i: set_constant((int)(x->value()->type()->as_LongConstant()->value())); break;
554 case Bytecodes::_l2f: set_constant(SharedRuntime::l2f(x->value()->type()->as_LongConstant()->value())); break;
555 case Bytecodes::_l2d: set_constant(SharedRuntime::l2d(x->value()->type()->as_LongConstant()->value())); break;
556 case Bytecodes::_f2d: set_constant((double)(x->value()->type()->as_FloatConstant()->value())); break;
557 case Bytecodes::_f2i: set_constant(SharedRuntime::f2i(x->value()->type()->as_FloatConstant()->value())); break;
558 case Bytecodes::_f2l: set_constant(SharedRuntime::f2l(x->value()->type()->as_FloatConstant()->value())); break;
559 case Bytecodes::_d2f: set_constant((float)(x->value()->type()->as_DoubleConstant()->value())); break;
560 case Bytecodes::_d2i: set_constant(SharedRuntime::d2i(x->value()->type()->as_DoubleConstant()->value())); break;
561 case Bytecodes::_d2l: set_constant(SharedRuntime::d2l(x->value()->type()->as_DoubleConstant()->value())); break;
562 default:
563 ShouldNotReachHere();
564 }
565 }
566
567 Value value = x->value();
568 BasicType type = T_ILLEGAL;
569 LoadField* lf = value->as_LoadField();
570 if (lf) {
571 type = lf->field_type();
572 } else {
573 LoadIndexed* li = value->as_LoadIndexed();
574 if (li) {
575 type = li->elt_type();
576 } else {
577 Convert* conv = value->as_Convert();
578 if (conv) {
579 switch (conv->op()) {
580 case Bytecodes::_i2b: type = T_BYTE; break;
581 case Bytecodes::_i2s: type = T_SHORT; break;
582 case Bytecodes::_i2c: type = T_CHAR; break;
583 default : break;
584 }
585 }
586 }
587 }
588 if (type != T_ILLEGAL) {
589 switch (x->op()) {
590 case Bytecodes::_i2b: if (type == T_BYTE) set_canonical(x->value()); break;
591 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) set_canonical(x->value()); break;
592 case Bytecodes::_i2c: if (type == T_CHAR) set_canonical(x->value()); break;
593 default : break;
594 }
595 } else {
596 Op2* op2 = x->value()->as_Op2();
597 if (op2 && op2->op() == Bytecodes::_iand && op2->y()->type()->is_constant()) {
598 jint safebits = 0;
599 jint mask = op2->y()->type()->as_IntConstant()->value();
600 switch (x->op()) {
601 case Bytecodes::_i2b: safebits = 0x7f; break;
602 case Bytecodes::_i2s: safebits = 0x7fff; break;
603 case Bytecodes::_i2c: safebits = 0xffff; break;
604 default : break;
605 }
606 // When casting a masked integer to a smaller signed type, if
607 // the mask doesn't include the sign bit the cast isn't needed.
608 if (safebits && (mask & ~safebits) == 0) {
609 set_canonical(x->value());
610 }
611 }
612 }
613
614 }
615
616 void Canonicalizer::do_NullCheck (NullCheck* x) {
617 if (x->obj()->as_NewArray() != nullptr || x->obj()->as_NewInstance() != nullptr) {
618 set_canonical(x->obj());
619 } else {
620 Constant* con = x->obj()->as_Constant();
621 if (con) {
622 ObjectType* c = con->type()->as_ObjectType();
623 if (c && c->is_loaded()) {
624 ObjectConstant* oc = c->as_ObjectConstant();
625 if (!oc || !oc->value()->is_null_object()) {
626 set_canonical(con);
627 }
628 }
629 }
630 }
631 }
632
633 void Canonicalizer::do_TypeCast (TypeCast* x) {}
634 void Canonicalizer::do_Invoke (Invoke* x) {}
635 void Canonicalizer::do_NewInstance (NewInstance* x) {}
636 void Canonicalizer::do_NewTypeArray (NewTypeArray* x) {}
637 void Canonicalizer::do_NewObjectArray (NewObjectArray* x) {}
638 void Canonicalizer::do_NewMultiArray (NewMultiArray* x) {}
639 void Canonicalizer::do_CheckCast (CheckCast* x) {
640 if (x->klass()->is_loaded()) {
641 Value obj = x->obj();
642 ciType* klass = obj->exact_type();
643 if (klass == nullptr) {
644 klass = obj->declared_type();
645 }
646 if (klass != nullptr && klass->is_loaded()) {
647 bool is_interface = klass->is_instance_klass() &&
648 klass->as_instance_klass()->is_interface();
649 // Interface casts can't be statically optimized away since verifier doesn't
650 // enforce interface types in bytecode.
651 if (!is_interface && klass->is_subtype_of(x->klass())) {
652 set_canonical(obj);
653 return;
654 }
655 }
656 // checkcast of null returns null
657 if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) {
658 set_canonical(obj);
659 }
660 }
661 }
662 void Canonicalizer::do_InstanceOf (InstanceOf* x) {
663 if (x->klass()->is_loaded()) {
664 Value obj = x->obj();
665 ciType* exact = obj->exact_type();
666 if (exact != nullptr && exact->is_loaded() && (obj->as_NewInstance() || obj->as_NewArray())) {
667 set_constant(exact->is_subtype_of(x->klass()) ? 1 : 0);
668 return;
669 }
670 // instanceof null returns false
671 if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) {
672 set_constant(0);
673 }
674 }
675
676 }
677 void Canonicalizer::do_MonitorEnter (MonitorEnter* x) {}
678 void Canonicalizer::do_MonitorExit (MonitorExit* x) {}
679 void Canonicalizer::do_BlockBegin (BlockBegin* x) {}
680 void Canonicalizer::do_Goto (Goto* x) {}
681
682
683 static bool is_true(jlong x, If::Condition cond, jlong y) {
684 switch (cond) {
685 case If::eql: return x == y;
686 case If::neq: return x != y;
687 case If::lss: return x < y;
688 case If::leq: return x <= y;
689 case If::gtr: return x > y;
690 case If::geq: return x >= y;
691 default:
692 ShouldNotReachHere();
693 return false;
694 }
695 }
696
697 static bool is_safepoint(BlockEnd* x, BlockBegin* sux) {
698 // An Instruction with multiple successors, x, is replaced by a Goto
699 // to a single successor, sux. Is a safepoint check needed = was the
700 // instruction being replaced a safepoint and the single remaining
701 // successor a back branch?
702 return x->is_safepoint() && (sux->bci() < x->state_before()->bci());
703 }
704
705 void Canonicalizer::do_If(If* x) {
706 // move const to right
707 if (x->x()->type()->is_constant()) x->swap_operands();
708 // simplify
709 const Value l = x->x(); ValueType* lt = l->type();
710 const Value r = x->y(); ValueType* rt = r->type();
711
712 if (l == r && !lt->is_float_kind()) {
713 // pattern: If (a cond a) => simplify to Goto
714 BlockBegin* sux = nullptr;
715 switch (x->cond()) {
716 case If::eql: sux = x->sux_for(true); break;
717 case If::neq: sux = x->sux_for(false); break;
718 case If::lss: sux = x->sux_for(false); break;
719 case If::leq: sux = x->sux_for(true); break;
720 case If::gtr: sux = x->sux_for(false); break;
721 case If::geq: sux = x->sux_for(true); break;
722 default: ShouldNotReachHere();
723 }
724 // If is a safepoint then the debug information should come from the state_before of the If.
725 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
726 return;
727 }
728
729 if (lt->is_constant() && rt->is_constant()) {
730 if (x->x()->as_Constant() != nullptr) {
731 // pattern: If (lc cond rc) => simplify to: Goto
732 BlockBegin* sux = x->x()->as_Constant()->compare(x->cond(), x->y(),
733 x->sux_for(true),
734 x->sux_for(false));
735 if (sux != nullptr) {
736 // If is a safepoint then the debug information should come from the state_before of the If.
737 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
738 }
739 }
740 } else if (rt->as_IntConstant() != nullptr) {
741 // pattern: If (l cond rc) => investigate further
742 const jint rc = rt->as_IntConstant()->value();
743 if (l->as_CompareOp() != nullptr) {
744 // pattern: If ((a cmp b) cond rc) => simplify to: If (x cond y) or: Goto
745 CompareOp* cmp = l->as_CompareOp();
746 bool unordered_is_less = cmp->op() == Bytecodes::_fcmpl || cmp->op() == Bytecodes::_dcmpl;
747 BlockBegin* lss_sux = x->sux_for(is_true(-1, x->cond(), rc)); // successor for a < b
748 BlockBegin* eql_sux = x->sux_for(is_true( 0, x->cond(), rc)); // successor for a = b
749 BlockBegin* gtr_sux = x->sux_for(is_true(+1, x->cond(), rc)); // successor for a > b
750 BlockBegin* nan_sux = unordered_is_less ? lss_sux : gtr_sux ; // successor for unordered
751 // Note: At this point all successors (lss_sux, eql_sux, gtr_sux, nan_sux) are
752 // equal to x->tsux() or x->fsux(). Furthermore, nan_sux equals either
753 // lss_sux or gtr_sux.
754 if (lss_sux == eql_sux && eql_sux == gtr_sux) {
755 // all successors identical => simplify to: Goto
756 set_canonical(new Goto(lss_sux, x->state_before(), x->is_safepoint()));
757 } else {
758 // two successors differ and two successors are the same => simplify to: If (x cmp y)
759 // determine new condition & successors
760 If::Condition cond = If::eql;
761 BlockBegin* tsux = nullptr;
762 BlockBegin* fsux = nullptr;
763 if (lss_sux == eql_sux) { cond = If::leq; tsux = lss_sux; fsux = gtr_sux; }
764 else if (lss_sux == gtr_sux) { cond = If::neq; tsux = lss_sux; fsux = eql_sux; }
765 else if (eql_sux == gtr_sux) { cond = If::geq; tsux = eql_sux; fsux = lss_sux; }
766 else { ShouldNotReachHere(); }
767 If* canon = new If(cmp->x(), cond, nan_sux == tsux, cmp->y(), tsux, fsux, x->state_before(), x->is_safepoint());
768 if (cmp->x() == cmp->y()) {
769 do_If(canon);
770 } else {
771 if (compilation()->profile_branches() || compilation()->is_profiling()) {
772 // TODO: If profiling, leave floating point comparisons unoptimized.
773 // We currently do not support profiling of the unordered case.
774 switch(cmp->op()) {
775 case Bytecodes::_fcmpl: case Bytecodes::_fcmpg:
776 case Bytecodes::_dcmpl: case Bytecodes::_dcmpg:
777 set_canonical(x);
778 return;
779 default:
780 break;
781 }
782 }
783 set_bci(cmp->state_before()->bci());
784 set_canonical(canon);
785 }
786 }
787 }
788 } else if (rt == objectNull &&
789 (l->as_NewInstance() || l->as_NewArray() ||
790 (l->as_Local() && l->as_Local()->is_receiver()))) {
791 if (x->cond() == Instruction::eql) {
792 BlockBegin* sux = x->fsux();
793 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
794 } else {
795 assert(x->cond() == Instruction::neq, "only other valid case");
796 BlockBegin* sux = x->tsux();
797 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
798 }
799 }
800 }
801
802
803 void Canonicalizer::do_TableSwitch(TableSwitch* x) {
804 if (x->tag()->type()->is_constant()) {
805 int v = x->tag()->type()->as_IntConstant()->value();
806 BlockBegin* sux = x->default_sux();
807 if (v >= x->lo_key() && v <= x->hi_key()) {
808 sux = x->sux_at(v - x->lo_key());
809 }
810 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
811 }
812 }
813
814
815 void Canonicalizer::do_LookupSwitch(LookupSwitch* x) {
816 if (x->tag()->type()->is_constant()) {
817 int v = x->tag()->type()->as_IntConstant()->value();
818 BlockBegin* sux = x->default_sux();
819 int low = 0;
820 int high = x->length() - 1;
821 while (low <= high) {
822 int mid = low + ((high - low) >> 1);
823 int key = x->key_at(mid);
824 if (key == v) {
825 sux = x->sux_at(mid);
826 break;
827 } else if (key > v) {
828 high = mid - 1;
829 } else {
830 low = mid + 1;
831 }
832 }
833 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux)));
834 }
835 }
836
837
838 void Canonicalizer::do_Return (Return* x) {}
839 void Canonicalizer::do_Throw (Throw* x) {}
840 void Canonicalizer::do_Base (Base* x) {}
841 void Canonicalizer::do_OsrEntry (OsrEntry* x) {}
842 void Canonicalizer::do_ExceptionObject(ExceptionObject* x) {}
843 void Canonicalizer::do_UnsafeGet (UnsafeGet* x) {}
844 void Canonicalizer::do_UnsafePut (UnsafePut* x) {}
845 void Canonicalizer::do_UnsafeGetAndSet(UnsafeGetAndSet* x) {}
846 void Canonicalizer::do_ProfileCall (ProfileCall* x) {}
847 void Canonicalizer::do_ProfileReturnType(ProfileReturnType* x) {}
848 void Canonicalizer::do_ProfileInvoke (ProfileInvoke* x) {}
849 void Canonicalizer::do_RuntimeCall (RuntimeCall* x) {}
850 void Canonicalizer::do_RangeCheckPredicate(RangeCheckPredicate* x) {}
851 #ifdef ASSERT
852 void Canonicalizer::do_Assert (Assert* x) {}
853 #endif
854 void Canonicalizer::do_MemBar (MemBar* x) {}