Mercurial > hg > truffle
annotate src/share/vm/c1/c1_Canonicalizer.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | a60a1309a03a |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17467
55fb97c4c58d
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12882
diff
changeset
|
2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1295
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1295
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1295
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "c1/c1_Canonicalizer.hpp" | |
| 27 #include "c1/c1_InstructionPrinter.hpp" | |
| 28 #include "c1/c1_ValueStack.hpp" | |
| 29 #include "ci/ciArray.hpp" | |
| 30 #include "runtime/sharedRuntime.hpp" | |
| 0 | 31 |
| 32 | |
| 1584 | 33 class PrintValueVisitor: public ValueVisitor { |
| 34 void visit(Value* vp) { | |
| 35 (*vp)->print_line(); | |
| 36 } | |
| 37 }; | |
| 0 | 38 |
| 39 void Canonicalizer::set_canonical(Value x) { | |
| 40 assert(x != NULL, "value must exist"); | |
| 41 // Note: we can not currently substitute root nodes which show up in | |
| 42 // the instruction stream (because the instruction list is embedded | |
| 43 // in the instructions). | |
| 44 if (canonical() != x) { | |
|
6133
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
45 #ifndef PRODUCT |
|
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
46 if (!x->has_printable_bci()) { |
|
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
47 x->set_printable_bci(bci()); |
|
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
48 } |
|
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
49 #endif |
| 0 | 50 if (PrintCanonicalization) { |
| 1584 | 51 PrintValueVisitor do_print_value; |
| 52 canonical()->input_values_do(&do_print_value); | |
| 0 | 53 canonical()->print_line(); |
| 54 tty->print_cr("canonicalized to:"); | |
| 1584 | 55 x->input_values_do(&do_print_value); |
| 0 | 56 x->print_line(); |
| 57 tty->cr(); | |
| 58 } | |
| 59 assert(_canonical->type()->tag() == x->type()->tag(), "types must match"); | |
| 60 _canonical = x; | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 | |
| 65 void Canonicalizer::move_const_to_right(Op2* x) { | |
| 66 if (x->x()->type()->is_constant() && x->is_commutative()) x->swap_operands(); | |
| 67 } | |
| 68 | |
| 69 | |
| 70 void Canonicalizer::do_Op2(Op2* x) { | |
| 71 if (x->x() == x->y()) { | |
| 72 switch (x->op()) { | |
| 73 case Bytecodes::_isub: set_constant(0); return; | |
| 74 case Bytecodes::_lsub: set_constant(jlong_cast(0)); return; | |
| 75 case Bytecodes::_iand: // fall through | |
| 76 case Bytecodes::_land: // fall through | |
| 77 case Bytecodes::_ior: // fall through | |
| 78 case Bytecodes::_lor : set_canonical(x->x()); return; | |
| 79 case Bytecodes::_ixor: set_constant(0); return; | |
| 80 case Bytecodes::_lxor: set_constant(jlong_cast(0)); return; | |
| 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(a + b); return; | |
| 92 case Bytecodes::_isub: set_constant(a - b); return; | |
| 93 case Bytecodes::_imul: set_constant(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 } | |
| 118 } | |
| 119 break; | |
| 120 case longTag: | |
| 121 { jlong a = x->x()->type()->as_LongConstant()->value(); | |
| 122 jlong b = x->y()->type()->as_LongConstant()->value(); | |
| 123 switch (x->op()) { | |
| 124 case Bytecodes::_ladd: set_constant(a + b); return; | |
| 125 case Bytecodes::_lsub: set_constant(a - b); return; | |
| 126 case Bytecodes::_lmul: set_constant(a * b); return; | |
| 127 case Bytecodes::_ldiv: | |
| 128 if (b != 0) { | |
| 129 set_constant(SharedRuntime::ldiv(b, a)); | |
| 130 return; | |
| 131 } | |
| 132 break; | |
| 133 case Bytecodes::_lrem: | |
| 134 if (b != 0) { | |
| 135 set_constant(SharedRuntime::lrem(b, a)); | |
| 136 return; | |
| 137 } | |
| 138 break; | |
| 139 case Bytecodes::_land: set_constant(a & b); return; | |
| 140 case Bytecodes::_lor : set_constant(a | b); return; | |
| 141 case Bytecodes::_lxor: set_constant(a ^ b); return; | |
| 142 } | |
| 143 } | |
| 144 break; | |
| 145 // other cases not implemented (must be extremely careful with floats & doubles!) | |
| 146 } | |
| 147 } | |
| 148 // make sure constant is on the right side, if any | |
| 149 move_const_to_right(x); | |
| 150 | |
| 151 if (x->y()->type()->is_constant()) { | |
| 152 // do constant folding for selected operations | |
| 153 switch (x->type()->tag()) { | |
| 154 case intTag: | |
| 155 if (x->y()->type()->as_IntConstant()->value() == 0) { | |
| 156 switch (x->op()) { | |
| 157 case Bytecodes::_iadd: set_canonical(x->x()); return; | |
| 158 case Bytecodes::_isub: set_canonical(x->x()); return; | |
| 159 case Bytecodes::_imul: set_constant(0); return; | |
| 160 // Note: for div and rem, make sure that C semantics | |
| 161 // corresponds to Java semantics! | |
| 162 case Bytecodes::_iand: set_constant(0); return; | |
| 163 case Bytecodes::_ior : set_canonical(x->x()); return; | |
| 164 } | |
| 165 } | |
| 166 break; | |
| 167 case longTag: | |
| 168 if (x->y()->type()->as_LongConstant()->value() == (jlong)0) { | |
| 169 switch (x->op()) { | |
| 170 case Bytecodes::_ladd: set_canonical(x->x()); return; | |
| 171 case Bytecodes::_lsub: set_canonical(x->x()); return; | |
| 172 case Bytecodes::_lmul: set_constant((jlong)0); return; | |
| 173 // Note: for div and rem, make sure that C semantics | |
| 174 // corresponds to Java semantics! | |
| 175 case Bytecodes::_land: set_constant((jlong)0); return; | |
| 176 case Bytecodes::_lor : set_canonical(x->x()); return; | |
| 177 } | |
| 178 } | |
| 179 break; | |
| 180 } | |
| 181 } | |
| 182 } | |
| 183 | |
| 184 | |
| 185 void Canonicalizer::do_Phi (Phi* x) {} | |
| 186 void Canonicalizer::do_Constant (Constant* x) {} | |
| 187 void Canonicalizer::do_Local (Local* x) {} | |
| 188 void Canonicalizer::do_LoadField (LoadField* x) {} | |
| 189 | |
| 190 // checks if v is in the block that is currently processed by | |
| 191 // GraphBuilder. This is the only block that has not BlockEnd yet. | |
| 192 static bool in_current_block(Value v) { | |
| 193 int max_distance = 4; | |
| 194 while (max_distance > 0 && v != NULL && v->as_BlockEnd() == NULL) { | |
| 195 v = v->next(); | |
| 196 max_distance--; | |
| 197 } | |
| 198 return v == NULL; | |
| 199 } | |
| 200 | |
| 201 void Canonicalizer::do_StoreField (StoreField* x) { | |
| 202 // If a value is going to be stored into a field or array some of | |
| 203 // the conversions emitted by javac are unneeded because the fields | |
| 204 // are packed to their natural size. | |
| 205 Convert* conv = x->value()->as_Convert(); | |
| 206 if (conv) { | |
| 207 Value value = NULL; | |
| 208 BasicType type = x->field()->type()->basic_type(); | |
| 209 switch (conv->op()) { | |
| 210 case Bytecodes::_i2b: if (type == T_BYTE) value = conv->value(); break; | |
| 211 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break; | |
| 212 case Bytecodes::_i2c: if (type == T_CHAR || type == T_BYTE) value = conv->value(); break; | |
| 213 } | |
| 214 // limit this optimization to current block | |
| 215 if (value != NULL && in_current_block(conv)) { | |
| 216 set_canonical(new StoreField(x->obj(), x->offset(), x->field(), value, x->is_static(), | |
|
2352
425688247f3d
6965570: assert(!needs_patching && x->is_loaded(),"how do we know it's volatile if it's not loaded")
never
parents:
2166
diff
changeset
|
217 x->state_before(), x->needs_patching())); |
| 0 | 218 return; |
| 219 } | |
| 220 } | |
| 221 | |
| 222 } | |
| 223 | |
| 224 void Canonicalizer::do_ArrayLength (ArrayLength* x) { | |
| 225 NewArray* array = x->array()->as_NewArray(); | |
| 226 if (array != NULL && array->length() != NULL) { | |
| 227 Constant* length = array->length()->as_Constant(); | |
| 228 if (length != NULL) { | |
| 229 // do not use the Constant itself, but create a new Constant | |
| 230 // with same value Otherwise a Constant is live over multiple | |
| 231 // blocks without being registered in a state array. | |
| 232 assert(length->type()->as_IntConstant() != NULL, "array length must be integer"); | |
| 233 set_constant(length->type()->as_IntConstant()->value()); | |
| 234 } | |
| 235 } else { | |
| 236 LoadField* lf = x->array()->as_LoadField(); | |
| 1295 | 237 if (lf != NULL) { |
| 238 ciField* field = lf->field(); | |
| 239 if (field->is_constant() && field->is_static()) { | |
| 240 // final static field | |
| 241 ciObject* c = field->constant_value().as_object(); | |
| 242 if (c->is_array()) { | |
| 243 ciArray* array = (ciArray*) c; | |
| 244 set_constant(array->length()); | |
| 245 } | |
| 0 | 246 } |
| 247 } | |
| 248 } | |
| 249 } | |
| 250 | |
| 251 void Canonicalizer::do_LoadIndexed (LoadIndexed* x) {} | |
| 252 void Canonicalizer::do_StoreIndexed (StoreIndexed* x) { | |
| 253 // If a value is going to be stored into a field or array some of | |
| 254 // the conversions emitted by javac are unneeded because the fields | |
| 255 // are packed to their natural size. | |
| 256 Convert* conv = x->value()->as_Convert(); | |
| 257 if (conv) { | |
| 258 Value value = NULL; | |
| 259 BasicType type = x->elt_type(); | |
| 260 switch (conv->op()) { | |
| 261 case Bytecodes::_i2b: if (type == T_BYTE) value = conv->value(); break; | |
| 262 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) value = conv->value(); break; | |
| 263 case Bytecodes::_i2c: if (type == T_CHAR || type == T_BYTE) value = conv->value(); break; | |
| 264 } | |
| 265 // limit this optimization to current block | |
| 266 if (value != NULL && in_current_block(conv)) { | |
| 267 set_canonical(new StoreIndexed(x->array(), x->index(), x->length(), | |
| 1819 | 268 x->elt_type(), value, x->state_before())); |
| 0 | 269 return; |
| 270 } | |
| 271 } | |
| 272 | |
| 273 | |
| 274 } | |
| 275 | |
| 276 | |
| 277 void Canonicalizer::do_NegateOp(NegateOp* x) { | |
| 278 ValueType* t = x->x()->type(); | |
| 279 if (t->is_constant()) { | |
| 280 switch (t->tag()) { | |
| 281 case intTag : set_constant(-t->as_IntConstant ()->value()); return; | |
| 282 case longTag : set_constant(-t->as_LongConstant ()->value()); return; | |
| 283 case floatTag : set_constant(-t->as_FloatConstant ()->value()); return; | |
| 284 case doubleTag: set_constant(-t->as_DoubleConstant()->value()); return; | |
| 285 default : ShouldNotReachHere(); | |
| 286 } | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 | |
| 291 void Canonicalizer::do_ArithmeticOp (ArithmeticOp* x) { do_Op2(x); } | |
| 292 | |
| 293 | |
| 294 void Canonicalizer::do_ShiftOp (ShiftOp* x) { | |
| 295 ValueType* t = x->x()->type(); | |
| 296 ValueType* t2 = x->y()->type(); | |
| 297 if (t->is_constant()) { | |
| 298 switch (t->tag()) { | |
| 299 case intTag : if (t->as_IntConstant()->value() == 0) { set_constant(0); return; } break; | |
| 300 case longTag : if (t->as_LongConstant()->value() == (jlong)0) { set_constant(jlong_cast(0)); return; } break; | |
| 301 default : ShouldNotReachHere(); | |
| 302 } | |
| 303 if (t2->is_constant()) { | |
| 304 if (t->tag() == intTag) { | |
| 305 int value = t->as_IntConstant()->value(); | |
| 306 int shift = t2->as_IntConstant()->value() & 31; | |
| 307 jint mask = ~(~0 << (32 - shift)); | |
| 308 if (shift == 0) mask = ~0; | |
| 309 switch (x->op()) { | |
| 310 case Bytecodes::_ishl: set_constant(value << shift); return; | |
| 311 case Bytecodes::_ishr: set_constant(value >> shift); return; | |
| 312 case Bytecodes::_iushr: set_constant((value >> shift) & mask); return; | |
| 313 } | |
| 314 } else if (t->tag() == longTag) { | |
| 315 jlong value = t->as_LongConstant()->value(); | |
| 316 int shift = t2->as_IntConstant()->value() & 63; | |
| 317 jlong mask = ~(~jlong_cast(0) << (64 - shift)); | |
| 318 if (shift == 0) mask = ~jlong_cast(0); | |
| 319 switch (x->op()) { | |
| 320 case Bytecodes::_lshl: set_constant(value << shift); return; | |
| 321 case Bytecodes::_lshr: set_constant(value >> shift); return; | |
| 322 case Bytecodes::_lushr: set_constant((value >> shift) & mask); return; | |
| 323 } | |
| 324 } | |
| 325 } | |
| 326 } | |
| 327 if (t2->is_constant()) { | |
| 328 switch (t2->tag()) { | |
| 329 case intTag : if (t2->as_IntConstant()->value() == 0) set_canonical(x->x()); return; | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
330 case longTag : if (t2->as_LongConstant()->value() == (jlong)0) set_canonical(x->x()); return; |
| 0 | 331 default : ShouldNotReachHere(); |
| 332 } | |
| 333 } | |
| 334 } | |
| 335 | |
| 336 | |
| 337 void Canonicalizer::do_LogicOp (LogicOp* x) { do_Op2(x); } | |
| 338 void Canonicalizer::do_CompareOp (CompareOp* x) { | |
| 339 if (x->x() == x->y()) { | |
| 340 switch (x->x()->type()->tag()) { | |
| 341 case longTag: set_constant(0); break; | |
| 342 case floatTag: { | |
| 343 FloatConstant* fc = x->x()->type()->as_FloatConstant(); | |
| 344 if (fc) { | |
| 345 if (g_isnan(fc->value())) { | |
| 346 set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1); | |
| 347 } else { | |
| 348 set_constant(0); | |
| 349 } | |
| 350 } | |
| 351 break; | |
| 352 } | |
| 353 case doubleTag: { | |
| 354 DoubleConstant* dc = x->x()->type()->as_DoubleConstant(); | |
| 355 if (dc) { | |
| 356 if (g_isnan(dc->value())) { | |
| 357 set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1); | |
| 358 } else { | |
| 359 set_constant(0); | |
| 360 } | |
| 361 } | |
| 362 break; | |
| 363 } | |
| 364 } | |
| 365 } else if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) { | |
| 366 switch (x->x()->type()->tag()) { | |
| 367 case longTag: { | |
| 368 jlong vx = x->x()->type()->as_LongConstant()->value(); | |
| 369 jlong vy = x->y()->type()->as_LongConstant()->value(); | |
| 370 if (vx == vy) | |
| 371 set_constant(0); | |
| 372 else if (vx < vy) | |
| 373 set_constant(-1); | |
| 374 else | |
| 375 set_constant(1); | |
| 376 break; | |
| 377 } | |
| 378 | |
| 379 case floatTag: { | |
| 380 float vx = x->x()->type()->as_FloatConstant()->value(); | |
| 381 float vy = x->y()->type()->as_FloatConstant()->value(); | |
| 382 if (g_isnan(vx) || g_isnan(vy)) | |
| 383 set_constant(x->op() == Bytecodes::_fcmpl ? -1 : 1); | |
| 384 else if (vx == vy) | |
| 385 set_constant(0); | |
| 386 else if (vx < vy) | |
| 387 set_constant(-1); | |
| 388 else | |
| 389 set_constant(1); | |
| 390 break; | |
| 391 } | |
| 392 | |
| 393 case doubleTag: { | |
| 394 double vx = x->x()->type()->as_DoubleConstant()->value(); | |
| 395 double vy = x->y()->type()->as_DoubleConstant()->value(); | |
| 396 if (g_isnan(vx) || g_isnan(vy)) | |
| 397 set_constant(x->op() == Bytecodes::_dcmpl ? -1 : 1); | |
| 398 else if (vx == vy) | |
| 399 set_constant(0); | |
| 400 else if (vx < vy) | |
| 401 set_constant(-1); | |
| 402 else | |
| 403 set_constant(1); | |
| 404 break; | |
| 405 } | |
| 406 } | |
| 407 | |
| 408 } | |
| 409 } | |
| 410 | |
| 411 | |
| 412 void Canonicalizer::do_IfInstanceOf(IfInstanceOf* x) {} | |
| 413 | |
| 414 void Canonicalizer::do_IfOp(IfOp* x) { | |
| 415 // Caution: do not use do_Op2(x) here for now since | |
| 416 // we map the condition to the op for now! | |
| 417 move_const_to_right(x); | |
| 418 } | |
| 419 | |
| 420 | |
| 421 void Canonicalizer::do_Intrinsic (Intrinsic* x) { | |
| 422 switch (x->id()) { | |
| 423 case vmIntrinsics::_floatToRawIntBits : { | |
| 424 FloatConstant* c = x->argument_at(0)->type()->as_FloatConstant(); | |
| 425 if (c != NULL) { | |
| 426 JavaValue v; | |
| 427 v.set_jfloat(c->value()); | |
| 428 set_constant(v.get_jint()); | |
| 429 } | |
| 430 break; | |
| 431 } | |
| 432 case vmIntrinsics::_intBitsToFloat : { | |
| 433 IntConstant* c = x->argument_at(0)->type()->as_IntConstant(); | |
| 434 if (c != NULL) { | |
| 435 JavaValue v; | |
| 436 v.set_jint(c->value()); | |
| 437 set_constant(v.get_jfloat()); | |
| 438 } | |
| 439 break; | |
| 440 } | |
| 441 case vmIntrinsics::_doubleToRawLongBits : { | |
| 442 DoubleConstant* c = x->argument_at(0)->type()->as_DoubleConstant(); | |
| 443 if (c != NULL) { | |
| 444 JavaValue v; | |
| 445 v.set_jdouble(c->value()); | |
| 446 set_constant(v.get_jlong()); | |
| 447 } | |
| 448 break; | |
| 449 } | |
| 450 case vmIntrinsics::_longBitsToDouble : { | |
| 451 LongConstant* c = x->argument_at(0)->type()->as_LongConstant(); | |
| 452 if (c != NULL) { | |
| 453 JavaValue v; | |
| 454 v.set_jlong(c->value()); | |
| 455 set_constant(v.get_jdouble()); | |
| 456 } | |
| 457 break; | |
| 458 } | |
| 6135 | 459 case vmIntrinsics::_isInstance : { |
| 460 assert(x->number_of_arguments() == 2, "wrong type"); | |
| 461 | |
| 462 InstanceConstant* c = x->argument_at(0)->type()->as_InstanceConstant(); | |
| 463 if (c != NULL && !c->value()->is_null_object()) { | |
| 464 // ciInstance::java_mirror_type() returns non-NULL only for Java mirrors | |
| 465 ciType* t = c->value()->as_instance()->java_mirror_type(); | |
| 466 if (t->is_klass()) { | |
| 467 // substitute cls.isInstance(obj) of a constant Class into | |
| 468 // an InstantOf instruction | |
|
6136
e1635876b206
7174884: C1: failures after 7171890: assert(cur_state != NULL) failed: state_before must be set
twisti
parents:
6135
diff
changeset
|
469 InstanceOf* i = new InstanceOf(t->as_klass(), x->argument_at(1), x->state_before()); |
| 6135 | 470 set_canonical(i); |
| 471 // and try to canonicalize even further | |
| 472 do_InstanceOf(i); | |
| 473 } else { | |
| 474 assert(t->is_primitive_type(), "should be a primitive type"); | |
| 475 // cls.isInstance(obj) always returns false for primitive classes | |
| 476 set_constant(0); | |
| 477 } | |
| 478 } | |
| 479 break; | |
| 480 } | |
| 0 | 481 } |
| 482 } | |
| 483 | |
| 484 void Canonicalizer::do_Convert (Convert* x) { | |
| 485 if (x->value()->type()->is_constant()) { | |
| 486 switch (x->op()) { | |
| 487 case Bytecodes::_i2b: set_constant((int)((x->value()->type()->as_IntConstant()->value() << 24) >> 24)); break; | |
| 488 case Bytecodes::_i2s: set_constant((int)((x->value()->type()->as_IntConstant()->value() << 16) >> 16)); break; | |
| 489 case Bytecodes::_i2c: set_constant((int)(x->value()->type()->as_IntConstant()->value() & ((1<<16)-1))); break; | |
| 490 case Bytecodes::_i2l: set_constant((jlong)(x->value()->type()->as_IntConstant()->value())); break; | |
| 491 case Bytecodes::_i2f: set_constant((float)(x->value()->type()->as_IntConstant()->value())); break; | |
| 492 case Bytecodes::_i2d: set_constant((double)(x->value()->type()->as_IntConstant()->value())); break; | |
| 493 case Bytecodes::_l2i: set_constant((int)(x->value()->type()->as_LongConstant()->value())); break; | |
| 494 case Bytecodes::_l2f: set_constant(SharedRuntime::l2f(x->value()->type()->as_LongConstant()->value())); break; | |
| 495 case Bytecodes::_l2d: set_constant(SharedRuntime::l2d(x->value()->type()->as_LongConstant()->value())); break; | |
| 496 case Bytecodes::_f2d: set_constant((double)(x->value()->type()->as_FloatConstant()->value())); break; | |
| 497 case Bytecodes::_f2i: set_constant(SharedRuntime::f2i(x->value()->type()->as_FloatConstant()->value())); break; | |
| 498 case Bytecodes::_f2l: set_constant(SharedRuntime::f2l(x->value()->type()->as_FloatConstant()->value())); break; | |
| 499 case Bytecodes::_d2f: set_constant((float)(x->value()->type()->as_DoubleConstant()->value())); break; | |
| 500 case Bytecodes::_d2i: set_constant(SharedRuntime::d2i(x->value()->type()->as_DoubleConstant()->value())); break; | |
| 501 case Bytecodes::_d2l: set_constant(SharedRuntime::d2l(x->value()->type()->as_DoubleConstant()->value())); break; | |
| 502 default: | |
| 503 ShouldNotReachHere(); | |
| 504 } | |
| 505 } | |
| 506 | |
| 507 Value value = x->value(); | |
| 508 BasicType type = T_ILLEGAL; | |
| 509 LoadField* lf = value->as_LoadField(); | |
| 510 if (lf) { | |
| 511 type = lf->field_type(); | |
| 512 } else { | |
| 513 LoadIndexed* li = value->as_LoadIndexed(); | |
| 514 if (li) { | |
| 515 type = li->elt_type(); | |
| 516 } else { | |
| 517 Convert* conv = value->as_Convert(); | |
| 518 if (conv) { | |
| 519 switch (conv->op()) { | |
| 520 case Bytecodes::_i2b: type = T_BYTE; break; | |
| 521 case Bytecodes::_i2s: type = T_SHORT; break; | |
| 522 case Bytecodes::_i2c: type = T_CHAR; break; | |
| 523 } | |
| 524 } | |
| 525 } | |
| 526 } | |
| 527 if (type != T_ILLEGAL) { | |
| 528 switch (x->op()) { | |
| 529 case Bytecodes::_i2b: if (type == T_BYTE) set_canonical(x->value()); break; | |
| 530 case Bytecodes::_i2s: if (type == T_SHORT || type == T_BYTE) set_canonical(x->value()); break; | |
| 531 case Bytecodes::_i2c: if (type == T_CHAR) set_canonical(x->value()); break; | |
| 532 } | |
| 533 } else { | |
| 534 Op2* op2 = x->value()->as_Op2(); | |
| 535 if (op2 && op2->op() == Bytecodes::_iand && op2->y()->type()->is_constant()) { | |
| 536 jint safebits = 0; | |
| 537 jint mask = op2->y()->type()->as_IntConstant()->value(); | |
| 538 switch (x->op()) { | |
| 539 case Bytecodes::_i2b: safebits = 0x7f; break; | |
| 540 case Bytecodes::_i2s: safebits = 0x7fff; break; | |
| 541 case Bytecodes::_i2c: safebits = 0xffff; break; | |
| 542 } | |
| 543 // When casting a masked integer to a smaller signed type, if | |
| 544 // the mask doesn't include the sign bit the cast isn't needed. | |
| 545 if (safebits && (mask & ~safebits) == 0) { | |
| 546 set_canonical(x->value()); | |
| 547 } | |
| 548 } | |
| 549 } | |
| 550 | |
| 551 } | |
| 552 | |
| 553 void Canonicalizer::do_NullCheck (NullCheck* x) { | |
| 554 if (x->obj()->as_NewArray() != NULL || x->obj()->as_NewInstance() != NULL) { | |
| 555 set_canonical(x->obj()); | |
| 556 } else { | |
| 557 Constant* con = x->obj()->as_Constant(); | |
| 558 if (con) { | |
| 559 ObjectType* c = con->type()->as_ObjectType(); | |
| 560 if (c && c->is_loaded()) { | |
| 561 ObjectConstant* oc = c->as_ObjectConstant(); | |
| 562 if (!oc || !oc->value()->is_null_object()) { | |
| 563 set_canonical(con); | |
| 564 } | |
| 565 } | |
| 566 } | |
| 567 } | |
| 568 } | |
| 569 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6136
diff
changeset
|
570 void Canonicalizer::do_TypeCast (TypeCast* x) {} |
| 0 | 571 void Canonicalizer::do_Invoke (Invoke* x) {} |
| 572 void Canonicalizer::do_NewInstance (NewInstance* x) {} | |
| 573 void Canonicalizer::do_NewTypeArray (NewTypeArray* x) {} | |
| 574 void Canonicalizer::do_NewObjectArray (NewObjectArray* x) {} | |
| 575 void Canonicalizer::do_NewMultiArray (NewMultiArray* x) {} | |
| 576 void Canonicalizer::do_CheckCast (CheckCast* x) { | |
| 577 if (x->klass()->is_loaded()) { | |
| 578 Value obj = x->obj(); | |
| 579 ciType* klass = obj->exact_type(); | |
| 580 if (klass == NULL) klass = obj->declared_type(); | |
| 581 if (klass != NULL && klass->is_loaded() && klass->is_subtype_of(x->klass())) { | |
| 582 set_canonical(obj); | |
| 583 return; | |
| 584 } | |
| 585 // checkcast of null returns null | |
| 586 if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) { | |
| 587 set_canonical(obj); | |
| 588 } | |
| 589 } | |
| 590 } | |
| 591 void Canonicalizer::do_InstanceOf (InstanceOf* x) { | |
| 592 if (x->klass()->is_loaded()) { | |
| 593 Value obj = x->obj(); | |
| 594 ciType* exact = obj->exact_type(); | |
| 595 if (exact != NULL && exact->is_loaded() && (obj->as_NewInstance() || obj->as_NewArray())) { | |
| 596 set_constant(exact->is_subtype_of(x->klass()) ? 1 : 0); | |
| 597 return; | |
| 598 } | |
| 599 // instanceof null returns false | |
| 600 if (obj->as_Constant() && obj->type()->as_ObjectType()->constant_value()->is_null_object()) { | |
| 601 set_constant(0); | |
| 602 } | |
| 603 } | |
| 604 | |
| 605 } | |
| 606 void Canonicalizer::do_MonitorEnter (MonitorEnter* x) {} | |
| 607 void Canonicalizer::do_MonitorExit (MonitorExit* x) {} | |
| 608 void Canonicalizer::do_BlockBegin (BlockBegin* x) {} | |
| 609 void Canonicalizer::do_Goto (Goto* x) {} | |
| 610 | |
| 611 | |
| 612 static bool is_true(jlong x, If::Condition cond, jlong y) { | |
| 613 switch (cond) { | |
| 614 case If::eql: return x == y; | |
| 615 case If::neq: return x != y; | |
| 616 case If::lss: return x < y; | |
| 617 case If::leq: return x <= y; | |
| 618 case If::gtr: return x > y; | |
| 619 case If::geq: return x >= y; | |
| 620 } | |
| 621 ShouldNotReachHere(); | |
| 622 return false; | |
| 623 } | |
| 624 | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
625 static bool is_safepoint(BlockEnd* x, BlockBegin* sux) { |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
626 // An Instruction with multiple successors, x, is replaced by a Goto |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
627 // to a single successor, sux. Is a safepoint check needed = was the |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
628 // instruction being replaced a safepoint and the single remaining |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
629 // successor a back branch? |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
630 return x->is_safepoint() && (sux->bci() < x->state_before()->bci()); |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
631 } |
| 0 | 632 |
| 633 void Canonicalizer::do_If(If* x) { | |
| 634 // move const to right | |
| 635 if (x->x()->type()->is_constant()) x->swap_operands(); | |
| 636 // simplify | |
| 637 const Value l = x->x(); ValueType* lt = l->type(); | |
| 638 const Value r = x->y(); ValueType* rt = r->type(); | |
| 639 | |
| 640 if (l == r && !lt->is_float_kind()) { | |
| 641 // pattern: If (a cond a) => simplify to Goto | |
| 642 BlockBegin* sux; | |
| 643 switch (x->cond()) { | |
| 644 case If::eql: sux = x->sux_for(true); break; | |
| 645 case If::neq: sux = x->sux_for(false); break; | |
| 646 case If::lss: sux = x->sux_for(false); break; | |
| 647 case If::leq: sux = x->sux_for(true); break; | |
| 648 case If::gtr: sux = x->sux_for(false); break; | |
| 649 case If::geq: sux = x->sux_for(true); break; | |
| 650 } | |
| 651 // If is a safepoint then the debug information should come from the state_before of the If. | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
652 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 653 return; |
| 654 } | |
| 655 | |
| 656 if (lt->is_constant() && rt->is_constant()) { | |
| 657 if (x->x()->as_Constant() != NULL) { | |
| 658 // pattern: If (lc cond rc) => simplify to: Goto | |
| 659 BlockBegin* sux = x->x()->as_Constant()->compare(x->cond(), x->y(), | |
| 660 x->sux_for(true), | |
| 661 x->sux_for(false)); | |
| 662 if (sux != NULL) { | |
| 663 // If is a safepoint then the debug information should come from the state_before of the If. | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
664 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 665 } |
| 666 } | |
| 667 } else if (rt->as_IntConstant() != NULL) { | |
| 668 // pattern: If (l cond rc) => investigate further | |
| 669 const jint rc = rt->as_IntConstant()->value(); | |
| 670 if (l->as_CompareOp() != NULL) { | |
| 671 // pattern: If ((a cmp b) cond rc) => simplify to: If (x cond y) or: Goto | |
| 672 CompareOp* cmp = l->as_CompareOp(); | |
| 673 bool unordered_is_less = cmp->op() == Bytecodes::_fcmpl || cmp->op() == Bytecodes::_dcmpl; | |
| 674 BlockBegin* lss_sux = x->sux_for(is_true(-1, x->cond(), rc)); // successor for a < b | |
| 675 BlockBegin* eql_sux = x->sux_for(is_true( 0, x->cond(), rc)); // successor for a = b | |
| 676 BlockBegin* gtr_sux = x->sux_for(is_true(+1, x->cond(), rc)); // successor for a > b | |
| 677 BlockBegin* nan_sux = unordered_is_less ? lss_sux : gtr_sux ; // successor for unordered | |
| 678 // Note: At this point all successors (lss_sux, eql_sux, gtr_sux, nan_sux) are | |
| 679 // equal to x->tsux() or x->fsux(). Furthermore, nan_sux equals either | |
| 680 // lss_sux or gtr_sux. | |
| 681 if (lss_sux == eql_sux && eql_sux == gtr_sux) { | |
| 682 // all successors identical => simplify to: Goto | |
| 683 set_canonical(new Goto(lss_sux, x->state_before(), x->is_safepoint())); | |
| 684 } else { | |
| 685 // two successors differ and two successors are the same => simplify to: If (x cmp y) | |
| 686 // determine new condition & successors | |
| 687 If::Condition cond; | |
| 688 BlockBegin* tsux = NULL; | |
| 689 BlockBegin* fsux = NULL; | |
| 690 if (lss_sux == eql_sux) { cond = If::leq; tsux = lss_sux; fsux = gtr_sux; } | |
| 691 else if (lss_sux == gtr_sux) { cond = If::neq; tsux = lss_sux; fsux = eql_sux; } | |
| 692 else if (eql_sux == gtr_sux) { cond = If::geq; tsux = eql_sux; fsux = lss_sux; } | |
| 693 else { ShouldNotReachHere(); } | |
| 1783 | 694 If* canon = new If(cmp->x(), cond, nan_sux == tsux, cmp->y(), tsux, fsux, cmp->state_before(), x->is_safepoint()); |
| 0 | 695 if (cmp->x() == cmp->y()) { |
| 696 do_If(canon); | |
| 697 } else { | |
| 1783 | 698 if (compilation()->profile_branches()) { |
| 699 // TODO: If profiling, leave floating point comparisons unoptimized. | |
| 700 // We currently do not support profiling of the unordered case. | |
| 701 switch(cmp->op()) { | |
| 702 case Bytecodes::_fcmpl: case Bytecodes::_fcmpg: | |
| 703 case Bytecodes::_dcmpl: case Bytecodes::_dcmpg: | |
| 704 set_canonical(x); | |
| 705 return; | |
| 706 } | |
| 707 } | |
|
6133
c8289830e172
7172843: C1: fix "assert(has_printable_bci()) failed: _printable_bci should have been set"
twisti
parents:
4966
diff
changeset
|
708 set_bci(cmp->state_before()->bci()); |
| 0 | 709 set_canonical(canon); |
| 710 } | |
| 711 } | |
| 712 } else if (l->as_InstanceOf() != NULL) { | |
| 713 // NOTE: Code permanently disabled for now since it leaves the old InstanceOf | |
| 714 // instruction in the graph (it is pinned). Need to fix this at some point. | |
|
1791
3a294e483abc
6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents:
1783
diff
changeset
|
715 // It should also be left in the graph when generating a profiled method version or Goto |
|
3a294e483abc
6919069: client compiler needs to capture more profile information for tiered work
iveresov
parents:
1783
diff
changeset
|
716 // has to know that it was an InstanceOf. |
| 0 | 717 return; |
| 718 // pattern: If ((obj instanceof klass) cond rc) => simplify to: IfInstanceOf or: Goto | |
| 719 InstanceOf* inst = l->as_InstanceOf(); | |
| 720 BlockBegin* is_inst_sux = x->sux_for(is_true(1, x->cond(), rc)); // successor for instanceof == 1 | |
| 721 BlockBegin* no_inst_sux = x->sux_for(is_true(0, x->cond(), rc)); // successor for instanceof == 0 | |
| 722 if (is_inst_sux == no_inst_sux && inst->is_loaded()) { | |
| 723 // both successors identical and klass is loaded => simplify to: Goto | |
| 724 set_canonical(new Goto(is_inst_sux, x->state_before(), x->is_safepoint())); | |
| 725 } else { | |
| 726 // successors differ => simplify to: IfInstanceOf | |
| 1819 | 727 set_canonical(new IfInstanceOf(inst->klass(), inst->obj(), true, inst->state_before()->bci(), is_inst_sux, no_inst_sux)); |
| 0 | 728 } |
| 729 } | |
| 730 } else if (rt == objectNull && (l->as_NewInstance() || l->as_NewArray())) { | |
| 731 if (x->cond() == Instruction::eql) { | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
732 BlockBegin* sux = x->fsux(); |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
733 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 734 } else { |
| 735 assert(x->cond() == Instruction::neq, "only other valid case"); | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
736 BlockBegin* sux = x->tsux(); |
|
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
737 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 738 } |
| 739 } | |
| 740 } | |
| 741 | |
| 742 | |
| 743 void Canonicalizer::do_TableSwitch(TableSwitch* x) { | |
| 744 if (x->tag()->type()->is_constant()) { | |
| 745 int v = x->tag()->type()->as_IntConstant()->value(); | |
| 746 BlockBegin* sux = x->default_sux(); | |
| 747 if (v >= x->lo_key() && v <= x->hi_key()) { | |
| 748 sux = x->sux_at(v - x->lo_key()); | |
| 749 } | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
750 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 751 } else if (x->number_of_sux() == 1) { |
| 752 // NOTE: Code permanently disabled for now since the switch statement's | |
| 753 // tag expression may produce side-effects in which case it must | |
| 754 // be executed. | |
| 755 return; | |
| 756 // simplify to Goto | |
| 757 set_canonical(new Goto(x->default_sux(), x->state_before(), x->is_safepoint())); | |
| 758 } else if (x->number_of_sux() == 2) { | |
| 759 // NOTE: Code permanently disabled for now since it produces two new nodes | |
| 760 // (Constant & If) and the Canonicalizer cannot return them correctly | |
| 761 // yet. For now we copied the corresponding code directly into the | |
| 762 // GraphBuilder (i.e., we should never reach here). | |
| 763 return; | |
| 764 // simplify to If | |
| 765 assert(x->lo_key() == x->hi_key(), "keys must be the same"); | |
| 766 Constant* key = new Constant(new IntConstant(x->lo_key())); | |
| 767 set_canonical(new If(x->tag(), If::eql, true, key, x->sux_at(0), x->default_sux(), x->state_before(), x->is_safepoint())); | |
| 768 } | |
| 769 } | |
| 770 | |
| 771 | |
| 772 void Canonicalizer::do_LookupSwitch(LookupSwitch* x) { | |
| 773 if (x->tag()->type()->is_constant()) { | |
| 774 int v = x->tag()->type()->as_IntConstant()->value(); | |
| 775 BlockBegin* sux = x->default_sux(); | |
| 776 for (int i = 0; i < x->length(); i++) { | |
| 777 if (v == x->key_at(i)) { | |
| 778 sux = x->sux_at(i); | |
| 779 } | |
| 780 } | |
|
4943
80107dc493db
7126041: jdk7u4 b05 and b06 crash with RubyMine 3.2.4, works well with b04
roland
parents:
2352
diff
changeset
|
781 set_canonical(new Goto(sux, x->state_before(), is_safepoint(x, sux))); |
| 0 | 782 } else if (x->number_of_sux() == 1) { |
| 783 // NOTE: Code permanently disabled for now since the switch statement's | |
| 784 // tag expression may produce side-effects in which case it must | |
| 785 // be executed. | |
| 786 return; | |
| 787 // simplify to Goto | |
| 788 set_canonical(new Goto(x->default_sux(), x->state_before(), x->is_safepoint())); | |
| 789 } else if (x->number_of_sux() == 2) { | |
| 790 // NOTE: Code permanently disabled for now since it produces two new nodes | |
| 791 // (Constant & If) and the Canonicalizer cannot return them correctly | |
| 792 // yet. For now we copied the corresponding code directly into the | |
| 793 // GraphBuilder (i.e., we should never reach here). | |
| 794 return; | |
| 795 // simplify to If | |
| 796 assert(x->length() == 1, "length must be the same"); | |
| 797 Constant* key = new Constant(new IntConstant(x->key_at(0))); | |
| 798 set_canonical(new If(x->tag(), If::eql, true, key, x->sux_at(0), x->default_sux(), x->state_before(), x->is_safepoint())); | |
| 799 } | |
| 800 } | |
| 801 | |
| 802 | |
| 803 void Canonicalizer::do_Return (Return* x) {} | |
| 804 void Canonicalizer::do_Throw (Throw* x) {} | |
| 805 void Canonicalizer::do_Base (Base* x) {} | |
| 806 void Canonicalizer::do_OsrEntry (OsrEntry* x) {} | |
| 807 void Canonicalizer::do_ExceptionObject(ExceptionObject* x) {} | |
| 808 | |
| 809 static bool match_index_and_scale(Instruction* instr, | |
| 810 Instruction** index, | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
811 int* log2_scale) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
812 // Skip conversion ops. This works only on 32bit because of the implicit l2i that the |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
813 // unsafe performs. |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
814 #ifndef _LP64 |
| 0 | 815 Convert* convert = instr->as_Convert(); |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
816 if (convert != NULL && convert->op() == Bytecodes::_i2l) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
817 assert(convert->value()->type() == intType, "invalid input type"); |
| 0 | 818 instr = convert->value(); |
| 819 } | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
820 #endif |
| 0 | 821 |
| 822 ShiftOp* shift = instr->as_ShiftOp(); | |
| 823 if (shift != NULL) { | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
824 if (shift->op() == Bytecodes::_lshl) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
825 assert(shift->x()->type() == longType, "invalid input type"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
826 } else { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
827 #ifndef _LP64 |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
828 if (shift->op() == Bytecodes::_ishl) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
829 assert(shift->x()->type() == intType, "invalid input type"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
830 } else { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
831 return false; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
832 } |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
833 #else |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
834 return false; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
835 #endif |
| 0 | 836 } |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
837 |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
838 |
| 0 | 839 // Constant shift value? |
| 840 Constant* con = shift->y()->as_Constant(); | |
| 841 if (con == NULL) return false; | |
| 842 // Well-known type and value? | |
| 843 IntConstant* val = con->type()->as_IntConstant(); | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
844 assert(val != NULL, "Should be an int constant"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
845 |
| 0 | 846 *index = shift->x(); |
| 847 int tmp_scale = val->value(); | |
| 848 if (tmp_scale >= 0 && tmp_scale < 4) { | |
| 849 *log2_scale = tmp_scale; | |
| 850 return true; | |
| 851 } else { | |
| 852 return false; | |
| 853 } | |
| 854 } | |
| 855 | |
| 856 ArithmeticOp* arith = instr->as_ArithmeticOp(); | |
| 857 if (arith != NULL) { | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
858 // See if either arg is a known constant |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
859 Constant* con = arith->x()->as_Constant(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
860 if (con != NULL) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
861 *index = arith->y(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
862 } else { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
863 con = arith->y()->as_Constant(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
864 if (con == NULL) return false; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
865 *index = arith->x(); |
| 0 | 866 } |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
867 long const_value; |
| 0 | 868 // Check for integer multiply |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
869 if (arith->op() == Bytecodes::_lmul) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
870 assert((*index)->type() == longType, "invalid input type"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
871 LongConstant* val = con->type()->as_LongConstant(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
872 assert(val != NULL, "expecting a long constant"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
873 const_value = val->value(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
874 } else { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
875 #ifndef _LP64 |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
876 if (arith->op() == Bytecodes::_imul) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
877 assert((*index)->type() == intType, "invalid input type"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
878 IntConstant* val = con->type()->as_IntConstant(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
879 assert(val != NULL, "expecting an int constant"); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
880 const_value = val->value(); |
| 0 | 881 } else { |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
882 return false; |
| 0 | 883 } |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
884 #else |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
885 return false; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
886 #endif |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
887 } |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
888 switch (const_value) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
889 case 1: *log2_scale = 0; return true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
890 case 2: *log2_scale = 1; return true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
891 case 4: *log2_scale = 2; return true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
892 case 8: *log2_scale = 3; return true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
893 default: return false; |
| 0 | 894 } |
| 895 } | |
| 896 | |
| 897 // Unknown instruction sequence; don't touch it | |
| 898 return false; | |
| 899 } | |
| 900 | |
| 901 | |
| 902 static bool match(UnsafeRawOp* x, | |
| 903 Instruction** base, | |
| 904 Instruction** index, | |
| 905 int* log2_scale) { | |
| 906 ArithmeticOp* root = x->base()->as_ArithmeticOp(); | |
| 907 if (root == NULL) return false; | |
| 908 // Limit ourselves to addition for now | |
| 909 if (root->op() != Bytecodes::_ladd) return false; | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
910 |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
911 bool match_found = false; |
| 0 | 912 // Try to find shift or scale op |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
913 if (match_index_and_scale(root->y(), index, log2_scale)) { |
| 0 | 914 *base = root->x(); |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
915 match_found = true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
916 } else if (match_index_and_scale(root->x(), index, log2_scale)) { |
| 0 | 917 *base = root->y(); |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
918 match_found = true; |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
919 } else if (NOT_LP64(root->y()->as_Convert() != NULL) LP64_ONLY(false)) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
920 // Skipping i2l works only on 32bit because of the implicit l2i that the unsafe performs. |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
921 // 64bit needs a real sign-extending conversion. |
| 0 | 922 Convert* convert = root->y()->as_Convert(); |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
923 if (convert->op() == Bytecodes::_i2l) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
924 assert(convert->value()->type() == intType, "should be an int"); |
| 0 | 925 // pick base and index, setting scale at 1 |
| 926 *base = root->x(); | |
| 927 *index = convert->value(); | |
| 928 *log2_scale = 0; | |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
929 match_found = true; |
| 0 | 930 } |
|
20491
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
931 } |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
932 // The default solution |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
933 if (!match_found) { |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
934 *base = root->x(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
935 *index = root->y(); |
|
a60a1309a03a
8058744: Crash in C1 OSRed method w/ Unsafe usage
iveresov
parents:
17467
diff
changeset
|
936 *log2_scale = 0; |
| 0 | 937 } |
| 938 | |
| 939 // If the value is pinned then it will be always be computed so | |
| 940 // there's no profit to reshaping the expression. | |
| 941 return !root->is_pinned(); | |
| 942 } | |
| 943 | |
| 944 | |
| 945 void Canonicalizer::do_UnsafeRawOp(UnsafeRawOp* x) { | |
| 946 Instruction* base = NULL; | |
| 947 Instruction* index = NULL; | |
| 948 int log2_scale; | |
| 949 | |
| 950 if (match(x, &base, &index, &log2_scale)) { | |
| 951 x->set_base(base); | |
| 952 x->set_index(index); | |
| 953 x->set_log2_scale(log2_scale); | |
| 954 if (PrintUnsafeOptimization) { | |
| 955 tty->print_cr("Canonicalizer: UnsafeRawOp id %d: base = id %d, index = id %d, log2_scale = %d", | |
| 956 x->id(), x->base()->id(), x->index()->id(), x->log2_scale()); | |
| 957 } | |
| 958 } | |
| 959 } | |
| 960 | |
| 961 void Canonicalizer::do_RoundFP(RoundFP* x) {} | |
| 962 void Canonicalizer::do_UnsafeGetRaw(UnsafeGetRaw* x) { if (OptimizeUnsafes) do_UnsafeRawOp(x); } | |
| 963 void Canonicalizer::do_UnsafePutRaw(UnsafePutRaw* x) { if (OptimizeUnsafes) do_UnsafeRawOp(x); } | |
| 964 void Canonicalizer::do_UnsafeGetObject(UnsafeGetObject* x) {} | |
| 965 void Canonicalizer::do_UnsafePutObject(UnsafePutObject* x) {} | |
|
6795
7eca5de9e0b6
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
6266
diff
changeset
|
966 void Canonicalizer::do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) {} |
| 0 | 967 void Canonicalizer::do_UnsafePrefetchRead (UnsafePrefetchRead* x) {} |
| 968 void Canonicalizer::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {} | |
| 969 void Canonicalizer::do_ProfileCall(ProfileCall* x) {} | |
|
12882
ce0cc25bc5e2
8026054: New type profiling points: type of return values at calls
roland
parents:
9156
diff
changeset
|
970 void Canonicalizer::do_ProfileReturnType(ProfileReturnType* x) {} |
| 1783 | 971 void Canonicalizer::do_ProfileInvoke(ProfileInvoke* x) {} |
|
2166
403dc4c1d7f5
6809483: hotspot:::method_entry are not correctly generated for "method()V"
never
parents:
1972
diff
changeset
|
972 void Canonicalizer::do_RuntimeCall(RuntimeCall* x) {} |
| 8860 | 973 void Canonicalizer::do_RangeCheckPredicate(RangeCheckPredicate* x) {} |
|
9156
acadb114c818
8011648: C1: optimized build is broken after 7153771
roland
parents:
8860
diff
changeset
|
974 #ifdef ASSERT |
| 8860 | 975 void Canonicalizer::do_Assert(Assert* x) {} |
|
9156
acadb114c818
8011648: C1: optimized build is broken after 7153771
roland
parents:
8860
diff
changeset
|
976 #endif |
|
4966
701a83c86f28
7120481: storeStore barrier in constructor with final field
jiangli
parents:
4943
diff
changeset
|
977 void Canonicalizer::do_MemBar(MemBar* x) {} |