277 }
278 }
279 }
280
281 //-----------------------transfer_exceptions_into_jvms-------------------------
282 JVMState* GraphKit::transfer_exceptions_into_jvms() {
283 if (map() == NULL) {
284 // We need a JVMS to carry the exceptions, but the map has gone away.
285 // Create a scratch JVMS, cloned from any of the exception states...
286 if (has_exceptions()) {
287 _map = _exceptions;
288 _map = clone_map();
289 _map->set_next_exception(NULL);
290 clear_saved_ex_oop(_map);
291 debug_only(verify_map());
292 } else {
293 // ...or created from scratch
294 JVMState* jvms = new (C) JVMState(_method, NULL);
295 jvms->set_bci(_bci);
296 jvms->set_sp(_sp);
297 jvms->set_map(new (C) SafePointNode(TypeFunc::Parms, jvms));
298 set_jvms(jvms);
299 for (uint i = 0; i < map()->req(); i++) map()->init_req(i, top());
300 set_all_memory(top());
301 while (map()->req() < jvms->endoff()) map()->add_req(top());
302 }
303 // (This is a kludge, in case you didn't notice.)
304 set_control(top());
305 }
306 JVMState* jvms = sync_jvms();
307 assert(!jvms->map()->has_exceptions(), "no exceptions on this map yet");
308 jvms->map()->set_next_exception(_exceptions);
309 _exceptions = NULL; // done with this set of exceptions
310 return jvms;
311 }
312
313 static inline void add_n_reqs(Node* dstphi, Node* srcphi) {
314 assert(is_hidden_merge(dstphi), "must be a special merge node");
315 assert(is_hidden_merge(srcphi), "must be a special merge node");
316 uint limit = srcphi->req();
317 for (uint i = PhiNode::Input; i < limit; i++) {
330 // untransformed, and can build up gradually. The region is marked by
331 // having a control input of its exception map, rather than NULL. Such
332 // regions do not appear except in this function, and in use_exception_state.
333 void GraphKit::combine_exception_states(SafePointNode* ex_map, SafePointNode* phi_map) {
334 if (failing()) return; // dying anyway...
335 JVMState* ex_jvms = ex_map->_jvms;
336 assert(ex_jvms->same_calls_as(phi_map->_jvms), "consistent call chains");
337 assert(ex_jvms->stkoff() == phi_map->_jvms->stkoff(), "matching locals");
338 assert(ex_jvms->sp() == phi_map->_jvms->sp(), "matching stack sizes");
339 assert(ex_jvms->monoff() == phi_map->_jvms->monoff(), "matching JVMS");
340 assert(ex_jvms->scloff() == phi_map->_jvms->scloff(), "matching scalar replaced objects");
341 assert(ex_map->req() == phi_map->req(), "matching maps");
342 uint tos = ex_jvms->stkoff() + ex_jvms->sp();
343 Node* hidden_merge_mark = root();
344 Node* region = phi_map->control();
345 MergeMemNode* phi_mem = phi_map->merged_memory();
346 MergeMemNode* ex_mem = ex_map->merged_memory();
347 if (region->in(0) != hidden_merge_mark) {
348 // The control input is not (yet) a specially-marked region in phi_map.
349 // Make it so, and build some phis.
350 region = new (C) RegionNode(2);
351 _gvn.set_type(region, Type::CONTROL);
352 region->set_req(0, hidden_merge_mark); // marks an internal ex-state
353 region->init_req(1, phi_map->control());
354 phi_map->set_control(region);
355 Node* io_phi = PhiNode::make(region, phi_map->i_o(), Type::ABIO);
356 record_for_igvn(io_phi);
357 _gvn.set_type(io_phi, Type::ABIO);
358 phi_map->set_i_o(io_phi);
359 for (MergeMemStream mms(phi_mem); mms.next_non_empty(); ) {
360 Node* m = mms.memory();
361 Node* m_phi = PhiNode::make(region, m, Type::MEMORY, mms.adr_type(C));
362 record_for_igvn(m_phi);
363 _gvn.set_type(m_phi, Type::MEMORY);
364 mms.set_memory(m_phi);
365 }
366 }
367
368 // Either or both of phi_map and ex_map might already be converted into phis.
369 Node* ex_control = ex_map->control();
370 // if there is special marking on ex_map also, we add multiple edges from src
479 Bytecodes::Code GraphKit::java_bc() const {
480 ciMethod* method = this->method();
481 int bci = this->bci();
482 if (method != NULL && bci != InvocationEntryBci)
483 return method->java_code_at_bci(bci);
484 else
485 return Bytecodes::_illegal;
486 }
487
488 void GraphKit::uncommon_trap_if_should_post_on_exceptions(Deoptimization::DeoptReason reason,
489 bool must_throw) {
490 // if the exception capability is set, then we will generate code
491 // to check the JavaThread.should_post_on_exceptions flag to see
492 // if we actually need to report exception events (for this
493 // thread). If we don't need to report exception events, we will
494 // take the normal fast path provided by add_exception_events. If
495 // exception event reporting is enabled for this thread, we will
496 // take the uncommon_trap in the BuildCutout below.
497
498 // first must access the should_post_on_exceptions_flag in this thread's JavaThread
499 Node* jthread = _gvn.transform(new (C) ThreadLocalNode());
500 Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
501 Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
502
503 // Test the should_post_on_exceptions_flag vs. 0
504 Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) );
505 Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
506
507 // Branch to slow_path if should_post_on_exceptions_flag was true
508 { BuildCutout unless(this, tst, PROB_MAX);
509 // Do not try anything fancy if we're notifying the VM on every throw.
510 // Cf. case Bytecodes::_athrow in parse2.cpp.
511 uncommon_trap(reason, Deoptimization::Action_none,
512 (ciKlass*)NULL, (char*)NULL, must_throw);
513 }
514
515 }
516
517 //------------------------------builtin_throw----------------------------------
518 void GraphKit::builtin_throw(Deoptimization::DeoptReason reason, Node* arg) {
519 bool must_throw = true;
520
521 if (env()->jvmti_can_post_on_exceptions()) {
522 // check if we must post exception events, take uncommon trap if so
523 uncommon_trap_if_should_post_on_exceptions(reason, must_throw);
524 // here if should_post_on_exceptions is false
525 // continue on with the normal codegen
658 #ifdef ASSERT
659 assert(kit->bci() == _bci, "bci must not shift");
660 Parse* parser = kit->is_Parse();
661 int block = (parser == NULL || parser->block() == NULL) ? -1 : parser->block()->rpo();
662 assert(block == _block, "block must not shift");
663 #endif
664 kit->set_map(_map);
665 kit->set_sp(_sp);
666 Compile::current()->dec_preserve_jvm_state();
667 }
668
669
670 //-----------------------------BuildCutout-------------------------------------
671 BuildCutout::BuildCutout(GraphKit* kit, Node* p, float prob, float cnt)
672 : PreserveJVMState(kit)
673 {
674 assert(p->is_Con() || p->is_Bool(), "test must be a bool");
675 SafePointNode* outer_map = _map; // preserved map is caller's
676 SafePointNode* inner_map = kit->map();
677 IfNode* iff = kit->create_and_map_if(outer_map->control(), p, prob, cnt);
678 outer_map->set_control(kit->gvn().transform( new (kit->C) IfTrueNode(iff) ));
679 inner_map->set_control(kit->gvn().transform( new (kit->C) IfFalseNode(iff) ));
680 }
681 BuildCutout::~BuildCutout() {
682 GraphKit* kit = _kit;
683 assert(kit->stopped(), "cutout code must stop, throw, return, etc.");
684 }
685
686 //---------------------------PreserveReexecuteState----------------------------
687 PreserveReexecuteState::PreserveReexecuteState(GraphKit* kit) {
688 assert(!kit->stopped(), "must call stopped() before");
689 _kit = kit;
690 _sp = kit->sp();
691 _reexecute = kit->jvms()->_reexecute;
692 }
693 PreserveReexecuteState::~PreserveReexecuteState() {
694 if (_kit->stopped()) return;
695 _kit->jvms()->_reexecute = _reexecute;
696 _kit->set_sp(_sp);
697 }
698
699 //------------------------------clone_map--------------------------------------
1101 int outputs = depth + inputs;
1102 assert(outputs >= 0, "sanity");
1103 switch (code) {
1104 case Bytecodes::_checkcast: assert(inputs == 1 && outputs == 1, ""); break;
1105 case Bytecodes::_athrow: assert(inputs == 1 && outputs == 0, ""); break;
1106 case Bytecodes::_aload_0: assert(inputs == 0 && outputs == 1, ""); break;
1107 case Bytecodes::_return: assert(inputs == 0 && outputs == 0, ""); break;
1108 case Bytecodes::_drem: assert(inputs == 4 && outputs == 2, ""); break;
1109 }
1110 #endif //ASSERT
1111
1112 return true;
1113 }
1114
1115
1116
1117 //------------------------------basic_plus_adr---------------------------------
1118 Node* GraphKit::basic_plus_adr(Node* base, Node* ptr, Node* offset) {
1119 // short-circuit a common case
1120 if (offset == intcon(0)) return ptr;
1121 return _gvn.transform( new (C) AddPNode(base, ptr, offset) );
1122 }
1123
1124 Node* GraphKit::ConvI2L(Node* offset) {
1125 // short-circuit a common case
1126 jint offset_con = find_int_con(offset, Type::OffsetBot);
1127 if (offset_con != Type::OffsetBot) {
1128 return longcon((jlong) offset_con);
1129 }
1130 return _gvn.transform( new (C) ConvI2LNode(offset));
1131 }
1132
1133 Node* GraphKit::ConvI2UL(Node* offset) {
1134 juint offset_con = (juint) find_int_con(offset, Type::OffsetBot);
1135 if (offset_con != (juint) Type::OffsetBot) {
1136 return longcon((julong) offset_con);
1137 }
1138 Node* conv = _gvn.transform( new (C) ConvI2LNode(offset));
1139 Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
1140 return _gvn.transform( new (C) AndLNode(conv, mask) );
1141 }
1142
1143 Node* GraphKit::ConvL2I(Node* offset) {
1144 // short-circuit a common case
1145 jlong offset_con = find_long_con(offset, (jlong)Type::OffsetBot);
1146 if (offset_con != (jlong)Type::OffsetBot) {
1147 return intcon((int) offset_con);
1148 }
1149 return _gvn.transform( new (C) ConvL2INode(offset));
1150 }
1151
1152 //-------------------------load_object_klass-----------------------------------
1153 Node* GraphKit::load_object_klass(Node* obj) {
1154 // Special-case a fresh allocation to avoid building nodes:
1155 Node* akls = AllocateNode::Ideal_klass(obj, &_gvn);
1156 if (akls != NULL) return akls;
1157 Node* k_adr = basic_plus_adr(obj, oopDesc::klass_offset_in_bytes());
1158 return _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), k_adr, TypeInstPtr::KLASS) );
1159 }
1160
1161 //-------------------------load_array_length-----------------------------------
1162 Node* GraphKit::load_array_length(Node* array) {
1163 // Special-case a fresh allocation to avoid building nodes:
1164 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(array, &_gvn);
1165 Node *alen;
1166 if (alloc == NULL) {
1167 Node *r_adr = basic_plus_adr(array, arrayOopDesc::length_offset_in_bytes());
1168 alen = _gvn.transform( new (C) LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
1169 } else {
1170 alen = alloc->Ideal_length();
1171 Node* ccast = alloc->make_ideal_length(_gvn.type(array)->is_oopptr(), &_gvn);
1172 if (ccast != alen) {
1173 alen = _gvn.transform(ccast);
1174 }
1175 }
1176 return alen;
1177 }
1178
1179 //------------------------------do_null_check----------------------------------
1180 // Helper function to do a NULL pointer check. Returned value is
1181 // the incoming address with NULL casted away. You are allowed to use the
1182 // not-null value only if you are control dependent on the test.
1183 extern int explicit_null_checks_inserted,
1184 explicit_null_checks_elided;
1185 Node* GraphKit::null_check_common(Node* value, BasicType type,
1186 // optional arguments for variations:
1187 bool assert_null,
1188 Node* *null_control,
1189 bool speculative) {
1190 assert(!assert_null || null_control == NULL, "not both at once");
1191 if (stopped()) return top();
1192 if (!GenerateCompilerNullChecks && !assert_null && null_control == NULL) {
1193 // For some performance testing, we may wish to suppress null checking.
1194 value = cast_not_null(value); // Make it appear to be non-null (4962416).
1195 return value;
1196 }
1197 explicit_null_checks_inserted++;
1198
1199 // Construct NULL check
1200 Node *chk = NULL;
1201 switch(type) {
1202 case T_LONG : chk = new (C) CmpLNode(value, _gvn.zerocon(T_LONG)); break;
1203 case T_INT : chk = new (C) CmpINode(value, _gvn.intcon(0)); break;
1204 case T_ARRAY : // fall through
1205 type = T_OBJECT; // simplify further tests
1206 case T_OBJECT : {
1207 const Type *t = _gvn.type( value );
1208
1209 const TypeOopPtr* tp = t->isa_oopptr();
1210 if (tp != NULL && tp->klass() != NULL && !tp->klass()->is_loaded()
1211 // Only for do_null_check, not any of its siblings:
1212 && !assert_null && null_control == NULL) {
1213 // Usually, any field access or invocation on an unloaded oop type
1214 // will simply fail to link, since the statically linked class is
1215 // likely also to be unloaded. However, in -Xcomp mode, sometimes
1216 // the static class is loaded but the sharper oop type is not.
1217 // Rather than checking for this obscure case in lots of places,
1218 // we simply observe that a null check on an unloaded class
1219 // will always be followed by a nonsense operation, so we
1220 // can just issue the uncommon trap here.
1221 // Our access to the unloaded class will only be correct
1222 // after it has been loaded and initialized, which requires
1223 // a trip through the interpreter.
1230 return top();
1231 }
1232
1233 if (assert_null) {
1234 // See if the type is contained in NULL_PTR.
1235 // If so, then the value is already null.
1236 if (t->higher_equal(TypePtr::NULL_PTR)) {
1237 explicit_null_checks_elided++;
1238 return value; // Elided null assert quickly!
1239 }
1240 } else {
1241 // See if mixing in the NULL pointer changes type.
1242 // If so, then the NULL pointer was not allowed in the original
1243 // type. In other words, "value" was not-null.
1244 if (t->meet(TypePtr::NULL_PTR) != t->remove_speculative()) {
1245 // same as: if (!TypePtr::NULL_PTR->higher_equal(t)) ...
1246 explicit_null_checks_elided++;
1247 return value; // Elided null check quickly!
1248 }
1249 }
1250 chk = new (C) CmpPNode( value, null() );
1251 break;
1252 }
1253
1254 default:
1255 fatal(err_msg_res("unexpected type: %s", type2name(type)));
1256 }
1257 assert(chk != NULL, "sanity check");
1258 chk = _gvn.transform(chk);
1259
1260 BoolTest::mask btest = assert_null ? BoolTest::eq : BoolTest::ne;
1261 BoolNode *btst = new (C) BoolNode( chk, btest);
1262 Node *tst = _gvn.transform( btst );
1263
1264 //-----------
1265 // if peephole optimizations occurred, a prior test existed.
1266 // If a prior test existed, maybe it dominates as we can avoid this test.
1267 if (tst != btst && type == T_OBJECT) {
1268 // At this point we want to scan up the CFG to see if we can
1269 // find an identical test (and so avoid this test altogether).
1270 Node *cfg = control();
1271 int depth = 0;
1272 while( depth < 16 ) { // Limit search depth for speed
1273 if( cfg->Opcode() == Op_IfTrue &&
1274 cfg->in(0)->in(1) == tst ) {
1275 // Found prior test. Use "cast_not_null" to construct an identical
1276 // CastPP (and hence hash to) as already exists for the prior test.
1277 // Return that casted value.
1278 if (assert_null) {
1279 replace_in_map(value, null());
1280 return null(); // do not issue the redundant test
1281 }
1308 // must-be-null assertion has failed. This could cause performance
1309 // problems for a method after its first do_null_assert failure.
1310 // Consider using 'Reason_class_check' instead?
1311
1312 // To cause an implicit null check, we set the not-null probability
1313 // to the maximum (PROB_MAX). For an explicit check the probability
1314 // is set to a smaller value.
1315 if (null_control != NULL || too_many_traps(reason)) {
1316 // probability is less likely
1317 ok_prob = PROB_LIKELY_MAG(3);
1318 } else if (!assert_null &&
1319 (ImplicitNullCheckThreshold > 0) &&
1320 method() != NULL &&
1321 (method()->method_data()->trap_count(reason)
1322 >= (uint)ImplicitNullCheckThreshold)) {
1323 ok_prob = PROB_LIKELY_MAG(3);
1324 }
1325
1326 if (null_control != NULL) {
1327 IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
1328 Node* null_true = _gvn.transform( new (C) IfFalseNode(iff));
1329 set_control( _gvn.transform( new (C) IfTrueNode(iff)));
1330 if (null_true == top())
1331 explicit_null_checks_elided++;
1332 (*null_control) = null_true;
1333 } else {
1334 BuildCutout unless(this, tst, ok_prob);
1335 // Check for optimizer eliding test at parse time
1336 if (stopped()) {
1337 // Failure not possible; do not bother making uncommon trap.
1338 explicit_null_checks_elided++;
1339 } else if (assert_null) {
1340 uncommon_trap(reason,
1341 Deoptimization::Action_make_not_entrant,
1342 NULL, "assert_null");
1343 } else {
1344 replace_in_map(value, zerocon(type));
1345 builtin_throw(reason);
1346 }
1347 }
1348
1349 // Must throw exception, fall-thru not possible?
1361 // (If there is a null_control, a non-null value may come back to haunt us.)
1362 if (type == T_OBJECT) {
1363 Node* cast = cast_not_null(value, false);
1364 if (null_control == NULL || (*null_control) == top())
1365 replace_in_map(value, cast);
1366 value = cast;
1367 }
1368
1369 return value;
1370 }
1371
1372
1373 //------------------------------cast_not_null----------------------------------
1374 // Cast obj to not-null on this path
1375 Node* GraphKit::cast_not_null(Node* obj, bool do_replace_in_map) {
1376 const Type *t = _gvn.type(obj);
1377 const Type *t_not_null = t->join_speculative(TypePtr::NOTNULL);
1378 // Object is already not-null?
1379 if( t == t_not_null ) return obj;
1380
1381 Node *cast = new (C) CastPPNode(obj,t_not_null);
1382 cast->init_req(0, control());
1383 cast = _gvn.transform( cast );
1384
1385 // Scan for instances of 'obj' in the current JVM mapping.
1386 // These instances are known to be not-null after the test.
1387 if (do_replace_in_map)
1388 replace_in_map(obj, cast);
1389
1390 return cast; // Return casted value
1391 }
1392
1393
1394 //--------------------------replace_in_map-------------------------------------
1395 void GraphKit::replace_in_map(Node* old, Node* neww) {
1396 if (old == neww) {
1397 return;
1398 }
1399
1400 map()->replace_edge(old, neww);
1401
1469 return p;
1470 }
1471
1472 //-----------------------------reset_memory------------------------------------
1473 Node* GraphKit::reset_memory() {
1474 Node* mem = map()->memory();
1475 // do not use this node for any more parsing!
1476 debug_only( map()->set_memory((Node*)NULL) );
1477 return _gvn.transform( mem );
1478 }
1479
1480 //------------------------------set_all_memory---------------------------------
1481 void GraphKit::set_all_memory(Node* newmem) {
1482 Node* mergemem = MergeMemNode::make(C, newmem);
1483 gvn().set_type_bottom(mergemem);
1484 map()->set_memory(mergemem);
1485 }
1486
1487 //------------------------------set_all_memory_call----------------------------
1488 void GraphKit::set_all_memory_call(Node* call, bool separate_io_proj) {
1489 Node* newmem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory, separate_io_proj) );
1490 set_all_memory(newmem);
1491 }
1492
1493 //=============================================================================
1494 //
1495 // parser factory methods for MemNodes
1496 //
1497 // These are layered on top of the factory methods in LoadNode and StoreNode,
1498 // and integrate with the parser's memory state and _gvn engine.
1499 //
1500
1501 // factory methods in "int adr_idx"
1502 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
1503 int adr_idx,
1504 MemNode::MemOrd mo, bool require_atomic_access) {
1505 assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" );
1506 const TypePtr* adr_type = NULL; // debug-mode-only argument
1507 debug_only(adr_type = C->get_adr_type(adr_idx));
1508 Node* mem = memory(adr_idx);
1509 Node* ld;
1704 intptr_t offset = header + ((intptr_t)idx_con << shift);
1705 return basic_plus_adr(ary, offset);
1706 }
1707
1708 // must be correct type for alignment purposes
1709 Node* base = basic_plus_adr(ary, header);
1710 #ifdef _LP64
1711 // The scaled index operand to AddP must be a clean 64-bit value.
1712 // Java allows a 32-bit int to be incremented to a negative
1713 // value, which appears in a 64-bit register as a large
1714 // positive number. Using that large positive number as an
1715 // operand in pointer arithmetic has bad consequences.
1716 // On the other hand, 32-bit overflow is rare, and the possibility
1717 // can often be excluded, if we annotate the ConvI2L node with
1718 // a type assertion that its value is known to be a small positive
1719 // number. (The prior range check has ensured this.)
1720 // This assertion is used by ConvI2LNode::Ideal.
1721 int index_max = max_jint - 1; // array size is max_jint, index is one less
1722 if (sizetype != NULL) index_max = sizetype->_hi - 1;
1723 const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
1724 idx = _gvn.transform( new (C) ConvI2LNode(idx, lidxtype) );
1725 #endif
1726 Node* scale = _gvn.transform( new (C) LShiftXNode(idx, intcon(shift)) );
1727 return basic_plus_adr(ary, base, scale);
1728 }
1729
1730 //-------------------------load_array_element-------------------------
1731 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) {
1732 const Type* elemtype = arytype->elem();
1733 BasicType elembt = elemtype->array_element_basic_type();
1734 Node* adr = array_element_address(ary, idx, elembt, arytype->size());
1735 Node* ld = make_load(ctl, adr, elemtype, elembt, arytype, MemNode::unordered);
1736 return ld;
1737 }
1738
1739 //-------------------------set_arguments_for_java_call-------------------------
1740 // Arguments (pre-popped from the stack) are taken from the JVMS.
1741 void GraphKit::set_arguments_for_java_call(CallJavaNode* call) {
1742 // Add the call arguments:
1743 uint nargs = call->method()->arg_size();
1744 for (uint i = 0; i < nargs; i++) {
1745 Node* arg = argument(i);
1746 call->init_req(i + TypeFunc::Parms, arg);
1754
1755 // Add the predefined inputs:
1756 call->init_req( TypeFunc::Control, control() );
1757 call->init_req( TypeFunc::I_O , i_o() );
1758 call->init_req( TypeFunc::Memory , reset_memory() );
1759 call->init_req( TypeFunc::FramePtr, frameptr() );
1760 call->init_req( TypeFunc::ReturnAdr, top() );
1761
1762 add_safepoint_edges(call, must_throw);
1763
1764 Node* xcall = _gvn.transform(call);
1765
1766 if (xcall == top()) {
1767 set_control(top());
1768 return;
1769 }
1770 assert(xcall == call, "call identity is stable");
1771
1772 // Re-use the current map to produce the result.
1773
1774 set_control(_gvn.transform(new (C) ProjNode(call, TypeFunc::Control)));
1775 set_i_o( _gvn.transform(new (C) ProjNode(call, TypeFunc::I_O , separate_io_proj)));
1776 set_all_memory_call(xcall, separate_io_proj);
1777
1778 //return xcall; // no need, caller already has it
1779 }
1780
1781 Node* GraphKit::set_results_for_java_call(CallJavaNode* call, bool separate_io_proj) {
1782 if (stopped()) return top(); // maybe the call folded up?
1783
1784 // Capture the return value, if any.
1785 Node* ret;
1786 if (call->method() == NULL ||
1787 call->method()->return_type()->basic_type() == T_VOID)
1788 ret = top();
1789 else ret = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
1790
1791 // Note: Since any out-of-line call can produce an exception,
1792 // we always insert an I_O projection from the call into the result.
1793
1794 make_slow_call_ex(call, env()->Throwable_klass(), separate_io_proj);
1795
1796 if (separate_io_proj) {
1797 // The caller requested separate projections be used by the fall
1798 // through and exceptional paths, so replace the projections for
1799 // the fall through path.
1800 set_i_o(_gvn.transform( new (C) ProjNode(call, TypeFunc::I_O) ));
1801 set_all_memory(_gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) ));
1802 }
1803 return ret;
1804 }
1805
1806 //--------------------set_predefined_input_for_runtime_call--------------------
1807 // Reading and setting the memory state is way conservative here.
1808 // The real problem is that I am not doing real Type analysis on memory,
1809 // so I cannot distinguish card mark stores from other stores. Across a GC
1810 // point the Store Barrier and the card mark memory has to agree. I cannot
1811 // have a card mark store and its barrier split across the GC point from
1812 // either above or below. Here I get that to happen by reading ALL of memory.
1813 // A better answer would be to separate out card marks from other memory.
1814 // For now, return the input memory state, so that it can be reused
1815 // after the call, if this call has restricted memory effects.
1816 Node* GraphKit::set_predefined_input_for_runtime_call(SafePointNode* call) {
1817 // Set fixed predefined input arguments
1818 Node* memory = reset_memory();
1819 call->init_req( TypeFunc::Control, control() );
1820 call->init_req( TypeFunc::I_O, top() ); // does no i/o
1821 call->init_req( TypeFunc::Memory, memory ); // may gc ptrs
1822 call->init_req( TypeFunc::FramePtr, frameptr() );
1823 call->init_req( TypeFunc::ReturnAdr, top() );
1824 return memory;
1825 }
1826
1827 //-------------------set_predefined_output_for_runtime_call--------------------
1828 // Set control and memory (not i_o) from the call.
1829 // If keep_mem is not NULL, use it for the output state,
1830 // except for the RawPtr output of the call, if hook_mem is TypeRawPtr::BOTTOM.
1831 // If hook_mem is NULL, this call produces no memory effects at all.
1832 // If hook_mem is a Java-visible memory slice (such as arraycopy operands),
1833 // then only that memory slice is taken from the call.
1834 // In the last case, we must put an appropriate memory barrier before
1835 // the call, so as to create the correct anti-dependencies on loads
1836 // preceding the call.
1837 void GraphKit::set_predefined_output_for_runtime_call(Node* call,
1838 Node* keep_mem,
1839 const TypePtr* hook_mem) {
1840 // no i/o
1841 set_control(_gvn.transform( new (C) ProjNode(call,TypeFunc::Control) ));
1842 if (keep_mem) {
1843 // First clone the existing memory state
1844 set_all_memory(keep_mem);
1845 if (hook_mem != NULL) {
1846 // Make memory for the call
1847 Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
1848 // Set the RawPtr memory state only. This covers all the heap top/GC stuff
1849 // We also use hook_mem to extract specific effects from arraycopy stubs.
1850 set_memory(mem, hook_mem);
1851 }
1852 // ...else the call has NO memory effects.
1853
1854 // Make sure the call advertises its memory effects precisely.
1855 // This lets us build accurate anti-dependences in gcm.cpp.
1856 assert(C->alias_type(call->adr_type()) == C->alias_type(hook_mem),
1857 "call node must be constructed correctly");
1858 } else {
1859 assert(hook_mem == NULL, "");
1860 // This is not a "slow path" call; all memory comes from the call.
1861 set_all_memory_call(call);
1862 }
1863 }
1864
1865
1866 // Replace the call with the current state of the kit.
1867 void GraphKit::replace_call(CallNode* call, Node* result) {
1951 }
1952 while (wl.size() > 0) {
1953 _gvn.transform(wl.pop());
1954 }
1955 }
1956 }
1957
1958
1959 //------------------------------increment_counter------------------------------
1960 // for statistics: increment a VM counter by 1
1961
1962 void GraphKit::increment_counter(address counter_addr) {
1963 Node* adr1 = makecon(TypeRawPtr::make(counter_addr));
1964 increment_counter(adr1);
1965 }
1966
1967 void GraphKit::increment_counter(Node* counter_addr) {
1968 int adr_type = Compile::AliasIdxRaw;
1969 Node* ctrl = control();
1970 Node* cnt = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
1971 Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1)));
1972 store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
1973 }
1974
1975
1976 //------------------------------uncommon_trap----------------------------------
1977 // Bail out to the interpreter in mid-method. Implemented by calling the
1978 // uncommon_trap blob. This helper function inserts a runtime call with the
1979 // right debug info.
1980 void GraphKit::uncommon_trap(int trap_request,
1981 ciKlass* klass, const char* comment,
1982 bool must_throw,
1983 bool keep_exact_action) {
1984 if (failing()) stop();
1985 if (stopped()) return; // trap reachable?
1986
1987 // Note: If ProfileTraps is true, and if a deopt. actually
1988 // occurs here, the runtime will make sure an MDO exists. There is
1989 // no need to call method()->ensure_method_data() at this point.
1990
1991 // Set the stack pointer to the right value for reexecution:
2070 // Clear out dead values from the debug info.
2071 kill_dead_locals();
2072
2073 // Now insert the uncommon trap subroutine call
2074 address call_addr = SharedRuntime::uncommon_trap_blob()->entry_point();
2075 const TypePtr* no_memory_effects = NULL;
2076 // Pass the index of the class to be loaded
2077 Node* call = make_runtime_call(RC_NO_LEAF | RC_UNCOMMON |
2078 (must_throw ? RC_MUST_THROW : 0),
2079 OptoRuntime::uncommon_trap_Type(),
2080 call_addr, "uncommon_trap", no_memory_effects,
2081 intcon(trap_request));
2082 assert(call->as_CallStaticJava()->uncommon_trap_request() == trap_request,
2083 "must extract request correctly from the graph");
2084 assert(trap_request != 0, "zero value reserved by uncommon_trap_request");
2085
2086 call->set_req(TypeFunc::ReturnAdr, returnadr());
2087 // The debug info is the only real input to this call.
2088
2089 // Halt-and-catch fire here. The above call should never return!
2090 HaltNode* halt = new(C) HaltNode(control(), frameptr());
2091 _gvn.set_type_bottom(halt);
2092 root()->add_req(halt);
2093
2094 stop_and_kill_map();
2095 }
2096
2097
2098 //--------------------------just_allocated_object------------------------------
2099 // Report the object that was just allocated.
2100 // It must be the case that there are no intervening safepoints.
2101 // We use this to determine if an object is so "fresh" that
2102 // it does not require card marks.
2103 Node* GraphKit::just_allocated_object(Node* current_control) {
2104 if (C->recent_alloc_ctl() == current_control)
2105 return C->recent_alloc_obj();
2106 return NULL;
2107 }
2108
2109
2110 void GraphKit::round_double_arguments(ciMethod* dest_method) {
2152 } else if (current_type->would_improve_ptr(maybe_null)) {
2153 // Profiling report that null was never seen so we can change the
2154 // speculative type to non null ptr.
2155 assert(!maybe_null, "nothing to improve");
2156 if (speculative == NULL) {
2157 speculative = TypePtr::NOTNULL;
2158 } else {
2159 const TypePtr* ptr = TypePtr::NOTNULL;
2160 speculative = speculative->cast_to_ptr_type(ptr->ptr())->is_ptr();
2161 }
2162 }
2163
2164 if (speculative != current_type->speculative()) {
2165 // Build a type with a speculative type (what we think we know
2166 // about the type but will need a guard when we use it)
2167 const TypeOopPtr* spec_type = TypeOopPtr::make(TypePtr::BotPTR, Type::OffsetBot, TypeOopPtr::InstanceBot, speculative);
2168 // We're changing the type, we need a new CheckCast node to carry
2169 // the new type. The new type depends on the control: what
2170 // profiling tells us is only valid from here as far as we can
2171 // tell.
2172 Node* cast = new(C) CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
2173 cast = _gvn.transform(cast);
2174 replace_in_map(n, cast);
2175 n = cast;
2176 }
2177
2178 return n;
2179 }
2180
2181 /**
2182 * Record profiling data from receiver profiling at an invoke with the
2183 * type system so that it can propagate it (speculation)
2184 *
2185 * @param n receiver node
2186 *
2187 * @return node with improved type
2188 */
2189 Node* GraphKit::record_profiled_receiver_for_speculation(Node* n) {
2190 if (!UseTypeSpeculation) {
2191 return n;
2192 }
2270 void GraphKit::round_double_result(ciMethod* dest_method) {
2271 // A non-strict method may return a double value which has an extended
2272 // exponent, but this must not be visible in a caller which is 'strict'
2273 // If a strict caller invokes a non-strict callee, round a double result
2274
2275 BasicType result_type = dest_method->return_type()->basic_type();
2276 assert( method() != NULL, "must have caller context");
2277 if( result_type == T_DOUBLE && method()->is_strict() && !dest_method->is_strict() ) {
2278 // Destination method's return value is on top of stack
2279 // dstore_rounding() does gvn.transform
2280 Node *result = pop_pair();
2281 result = dstore_rounding(result);
2282 push_pair(result);
2283 }
2284 }
2285
2286 // rounding for strict float precision conformance
2287 Node* GraphKit::precision_rounding(Node* n) {
2288 return UseStrictFP && _method->flags().is_strict()
2289 && UseSSE == 0 && Matcher::strict_fp_requires_explicit_rounding
2290 ? _gvn.transform( new (C) RoundFloatNode(0, n) )
2291 : n;
2292 }
2293
2294 // rounding for strict double precision conformance
2295 Node* GraphKit::dprecision_rounding(Node *n) {
2296 return UseStrictFP && _method->flags().is_strict()
2297 && UseSSE <= 1 && Matcher::strict_fp_requires_explicit_rounding
2298 ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
2299 : n;
2300 }
2301
2302 // rounding for non-strict double stores
2303 Node* GraphKit::dstore_rounding(Node* n) {
2304 return Matcher::strict_fp_requires_explicit_rounding
2305 && UseSSE <= 1
2306 ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
2307 : n;
2308 }
2309
2310 //=============================================================================
2311 // Generate a fast path/slow path idiom. Graph looks like:
2312 // [foo] indicates that 'foo' is a parameter
2313 //
2314 // [in] NULL
2315 // \ /
2316 // CmpP
2317 // Bool ne
2318 // If
2319 // / \
2320 // True False-<2>
2321 // / |
2322 // / cast_not_null
2323 // Load | | ^
2324 // [fast_test] | |
2325 // gvn to opt_test | |
2326 // / \ | <1>
2365 Deoptimization::DeoptReason reason = Deoptimization::reason_null_check(speculative);
2366 uncommon_trap(reason,
2367 Deoptimization::Action_make_not_entrant);
2368 (*null_control) = top(); // NULL path is dead
2369 }
2370 if ((*null_control) == top() && safe_for_replace) {
2371 replace_in_map(value, cast);
2372 }
2373
2374 // Cast away null-ness on the result
2375 return cast;
2376 }
2377
2378 //------------------------------opt_iff----------------------------------------
2379 // Optimize the fast-check IfNode. Set the fast-path region slot 2.
2380 // Return slow-path control.
2381 Node* GraphKit::opt_iff(Node* region, Node* iff) {
2382 IfNode *opt_iff = _gvn.transform(iff)->as_If();
2383
2384 // Fast path taken; set region slot 2
2385 Node *fast_taken = _gvn.transform( new (C) IfFalseNode(opt_iff) );
2386 region->init_req(2,fast_taken); // Capture fast-control
2387
2388 // Fast path not-taken, i.e. slow path
2389 Node *slow_taken = _gvn.transform( new (C) IfTrueNode(opt_iff) );
2390 return slow_taken;
2391 }
2392
2393 //-----------------------------make_runtime_call-------------------------------
2394 Node* GraphKit::make_runtime_call(int flags,
2395 const TypeFunc* call_type, address call_addr,
2396 const char* call_name,
2397 const TypePtr* adr_type,
2398 // The following parms are all optional.
2399 // The first NULL ends the list.
2400 Node* parm0, Node* parm1,
2401 Node* parm2, Node* parm3,
2402 Node* parm4, Node* parm5,
2403 Node* parm6, Node* parm7) {
2404 // Slow-path call
2405 bool is_leaf = !(flags & RC_NO_LEAF);
2406 bool has_io = (!is_leaf && !(flags & RC_NO_IO));
2407 if (call_name == NULL) {
2408 assert(!is_leaf, "must supply name for leaf");
2409 call_name = OptoRuntime::stub_name(call_addr);
2410 }
2411 CallNode* call;
2412 if (!is_leaf) {
2413 call = new(C) CallStaticJavaNode(call_type, call_addr, call_name,
2414 bci(), adr_type);
2415 } else if (flags & RC_NO_FP) {
2416 call = new(C) CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
2417 } else {
2418 call = new(C) CallLeafNode(call_type, call_addr, call_name, adr_type);
2419 }
2420
2421 // The following is similar to set_edges_for_java_call,
2422 // except that the memory effects of the call are restricted to AliasIdxRaw.
2423
2424 // Slow path call has no side-effects, uses few values
2425 bool wide_in = !(flags & RC_NARROW_MEM);
2426 bool wide_out = (C->get_alias_index(adr_type) == Compile::AliasIdxBot);
2427
2428 Node* prev_mem = NULL;
2429 if (wide_in) {
2430 prev_mem = set_predefined_input_for_runtime_call(call);
2431 } else {
2432 assert(!wide_out, "narrow in => narrow out");
2433 Node* narrow_mem = memory(adr_type);
2434 prev_mem = reset_memory();
2435 map()->set_memory(narrow_mem);
2436 set_predefined_input_for_runtime_call(call);
2437 }
2438
2459
2460 if (flags & RC_UNCOMMON) {
2461 // Set the count to a tiny probability. Cf. Estimate_Block_Frequency.
2462 // (An "if" probability corresponds roughly to an unconditional count.
2463 // Sort of.)
2464 call->set_cnt(PROB_UNLIKELY_MAG(4));
2465 }
2466
2467 Node* c = _gvn.transform(call);
2468 assert(c == call, "cannot disappear");
2469
2470 if (wide_out) {
2471 // Slow path call has full side-effects.
2472 set_predefined_output_for_runtime_call(call);
2473 } else {
2474 // Slow path call has few side-effects, and/or sets few values.
2475 set_predefined_output_for_runtime_call(call, prev_mem, adr_type);
2476 }
2477
2478 if (has_io) {
2479 set_i_o(_gvn.transform(new (C) ProjNode(call, TypeFunc::I_O)));
2480 }
2481 return call;
2482
2483 }
2484
2485 //------------------------------merge_memory-----------------------------------
2486 // Merge memory from one path into the current memory state.
2487 void GraphKit::merge_memory(Node* new_mem, Node* region, int new_path) {
2488 for (MergeMemStream mms(merged_memory(), new_mem->as_MergeMem()); mms.next_non_empty2(); ) {
2489 Node* old_slice = mms.force_memory();
2490 Node* new_slice = mms.memory2();
2491 if (old_slice != new_slice) {
2492 PhiNode* phi;
2493 if (new_slice->is_Phi() && new_slice->as_Phi()->region() == region) {
2494 phi = new_slice->as_Phi();
2495 #ifdef ASSERT
2496 if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region)
2497 old_slice = old_slice->in(new_path);
2498 // Caller is responsible for ensuring that any pre-existing
2499 // phis are already aware of old memory.
2500 int old_path = (new_path > 1) ? 1 : 2; // choose old_path != new_path
2501 assert(phi->in(old_path) == old_slice, "pre-existing phis OK");
2502 #endif
2503 mms.set_memory(phi);
2504 } else {
2505 phi = PhiNode::make(region, old_slice, Type::MEMORY, mms.adr_type(C));
2506 _gvn.set_type(phi, Type::MEMORY);
2507 phi->set_req(new_path, new_slice);
2508 mms.set_memory(_gvn.transform(phi)); // assume it is complete
2509 }
2510 }
2511 }
2512 }
2513
2514 //------------------------------make_slow_call_ex------------------------------
2515 // Make the exception handler hookups for the slow call
2516 void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj) {
2517 if (stopped()) return;
2518
2519 // Make a catch node with just two handlers: fall-through and catch-all
2520 Node* i_o = _gvn.transform( new (C) ProjNode(call, TypeFunc::I_O, separate_io_proj) );
2521 Node* catc = _gvn.transform( new (C) CatchNode(control(), i_o, 2) );
2522 Node* norm = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
2523 Node* excp = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) );
2524
2525 { PreserveJVMState pjvms(this);
2526 set_control(excp);
2527 set_i_o(i_o);
2528
2529 if (excp != top()) {
2530 // Create an exception state also.
2531 // Use an exact type if the caller has specified a specific exception.
2532 const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
2533 Node* ex_oop = new (C) CreateExNode(ex_type, control(), i_o);
2534 add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
2535 }
2536 }
2537
2538 // Get the no-exception control from the CatchNode.
2539 set_control(norm);
2540 }
2541
2542
2543 //-------------------------------gen_subtype_check-----------------------------
2544 // Generate a subtyping check. Takes as input the subtype and supertype.
2545 // Returns 2 values: sets the default control() to the true path and returns
2546 // the false path. Only reads invariant memory; sets no (visible) memory.
2547 // The PartialSubtypeCheckNode sets the hidden 1-word cache in the encoding
2548 // but that's not exposed to the optimizer. This call also doesn't take in an
2549 // Object; if you wish to check an Object you need to load the Object's class
2550 // prior to coming here.
2551 Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
2552 // Fast check for identical types, perhaps identical constants.
2553 // The types can even be identical non-constants, in cases
2563 // test before generating code. You may ask, why not just generate
2564 // the code and then let it fold up? The answer is that the generated
2565 // code will necessarily include null checks, which do not always
2566 // completely fold away. If they are also needless, then they turn
2567 // into a performance loss. Example:
2568 // Foo[] fa = blah(); Foo x = fa[0]; fa[1] = x;
2569 // Here, the type of 'fa' is often exact, so the store check
2570 // of fa[1]=x will fold up, without testing the nullness of x.
2571 switch (static_subtype_check(superk, subk)) {
2572 case SSC_always_false:
2573 {
2574 Node* always_fail = control();
2575 set_control(top());
2576 return always_fail;
2577 }
2578 case SSC_always_true:
2579 return top();
2580 case SSC_easy_test:
2581 {
2582 // Just do a direct pointer compare and be done.
2583 Node* cmp = _gvn.transform( new(C) CmpPNode(subklass, superklass) );
2584 Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
2585 IfNode* iff = create_and_xform_if(control(), bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
2586 set_control( _gvn.transform( new(C) IfTrueNode (iff) ) );
2587 return _gvn.transform( new(C) IfFalseNode(iff) );
2588 }
2589 case SSC_full_test:
2590 break;
2591 default:
2592 ShouldNotReachHere();
2593 }
2594 }
2595
2596 // %%% Possible further optimization: Even if the superklass is not exact,
2597 // if the subklass is the unique subtype of the superklass, the check
2598 // will always succeed. We could leave a dependency behind to ensure this.
2599
2600 // First load the super-klass's check-offset
2601 Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
2602 Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
2603 TypeInt::INT, MemNode::unordered));
2604 int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
2605 bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
2606
2607 // Load from the sub-klass's super-class display list, or a 1-word cache of
2608 // the secondary superclass list, or a failing value with a sentinel offset
2609 // if the super-klass is an interface or exceptionally deep in the Java
2610 // hierarchy and we have to scan the secondary superclass list the hard way.
2611 // Worst-case type is a little odd: NULL is allowed as a result (usually
2612 // klass loads can never produce a NULL).
2613 Node *chk_off_X = ConvI2X(chk_off);
2614 Node *p2 = _gvn.transform( new (C) AddPNode(subklass,subklass,chk_off_X) );
2615 // For some types like interfaces the following loadKlass is from a 1-word
2616 // cache which is mutable so can't use immutable memory. Other
2617 // types load from the super-class display table which is immutable.
2618 Node *kmem = might_be_cache ? memory(p2) : immutable_memory();
2619 Node *nkls = _gvn.transform( LoadKlassNode::make( _gvn, kmem, p2, _gvn.type(p2)->is_ptr(), TypeKlassPtr::OBJECT_OR_NULL ) );
2620
2621 // Compile speed common case: ARE a subtype and we canNOT fail
2622 if( superklass == nkls )
2623 return top(); // false path is dead; no test needed.
2624
2625 // See if we get an immediate positive hit. Happens roughly 83% of the
2626 // time. Test to see if the value loaded just previously from the subklass
2627 // is exactly the superklass.
2628 Node *cmp1 = _gvn.transform( new (C) CmpPNode( superklass, nkls ) );
2629 Node *bol1 = _gvn.transform( new (C) BoolNode( cmp1, BoolTest::eq ) );
2630 IfNode *iff1 = create_and_xform_if( control(), bol1, PROB_LIKELY(0.83f), COUNT_UNKNOWN );
2631 Node *iftrue1 = _gvn.transform( new (C) IfTrueNode ( iff1 ) );
2632 set_control( _gvn.transform( new (C) IfFalseNode( iff1 ) ) );
2633
2634 // Compile speed common case: Check for being deterministic right now. If
2635 // chk_off is a constant and not equal to cacheoff then we are NOT a
2636 // subklass. In this case we need exactly the 1 test above and we can
2637 // return those results immediately.
2638 if (!might_be_cache) {
2639 Node* not_subtype_ctrl = control();
2640 set_control(iftrue1); // We need exactly the 1 test above
2641 return not_subtype_ctrl;
2642 }
2643
2644 // Gather the various success & failures here
2645 RegionNode *r_ok_subtype = new (C) RegionNode(4);
2646 record_for_igvn(r_ok_subtype);
2647 RegionNode *r_not_subtype = new (C) RegionNode(3);
2648 record_for_igvn(r_not_subtype);
2649
2650 r_ok_subtype->init_req(1, iftrue1);
2651
2652 // Check for immediate negative hit. Happens roughly 11% of the time (which
2653 // is roughly 63% of the remaining cases). Test to see if the loaded
2654 // check-offset points into the subklass display list or the 1-element
2655 // cache. If it points to the display (and NOT the cache) and the display
2656 // missed then it's not a subtype.
2657 Node *cacheoff = _gvn.intcon(cacheoff_con);
2658 Node *cmp2 = _gvn.transform( new (C) CmpINode( chk_off, cacheoff ) );
2659 Node *bol2 = _gvn.transform( new (C) BoolNode( cmp2, BoolTest::ne ) );
2660 IfNode *iff2 = create_and_xform_if( control(), bol2, PROB_LIKELY(0.63f), COUNT_UNKNOWN );
2661 r_not_subtype->init_req(1, _gvn.transform( new (C) IfTrueNode (iff2) ) );
2662 set_control( _gvn.transform( new (C) IfFalseNode(iff2) ) );
2663
2664 // Check for self. Very rare to get here, but it is taken 1/3 the time.
2665 // No performance impact (too rare) but allows sharing of secondary arrays
2666 // which has some footprint reduction.
2667 Node *cmp3 = _gvn.transform( new (C) CmpPNode( subklass, superklass ) );
2668 Node *bol3 = _gvn.transform( new (C) BoolNode( cmp3, BoolTest::eq ) );
2669 IfNode *iff3 = create_and_xform_if( control(), bol3, PROB_LIKELY(0.36f), COUNT_UNKNOWN );
2670 r_ok_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode ( iff3 ) ) );
2671 set_control( _gvn.transform( new (C) IfFalseNode( iff3 ) ) );
2672
2673 // -- Roads not taken here: --
2674 // We could also have chosen to perform the self-check at the beginning
2675 // of this code sequence, as the assembler does. This would not pay off
2676 // the same way, since the optimizer, unlike the assembler, can perform
2677 // static type analysis to fold away many successful self-checks.
2678 // Non-foldable self checks work better here in second position, because
2679 // the initial primary superclass check subsumes a self-check for most
2680 // types. An exception would be a secondary type like array-of-interface,
2681 // which does not appear in its own primary supertype display.
2682 // Finally, we could have chosen to move the self-check into the
2683 // PartialSubtypeCheckNode, and from there out-of-line in a platform
2684 // dependent manner. But it is worthwhile to have the check here,
2685 // where it can be perhaps be optimized. The cost in code space is
2686 // small (register compare, branch).
2687
2688 // Now do a linear scan of the secondary super-klass array. Again, no real
2689 // performance impact (too rare) but it's gotta be done.
2690 // Since the code is rarely used, there is no penalty for moving it
2691 // out of line, and it can only improve I-cache density.
2692 // The decision to inline or out-of-line this final check is platform
2693 // dependent, and is found in the AD file definition of PartialSubtypeCheck.
2694 Node* psc = _gvn.transform(
2695 new (C) PartialSubtypeCheckNode(control(), subklass, superklass) );
2696
2697 Node *cmp4 = _gvn.transform( new (C) CmpPNode( psc, null() ) );
2698 Node *bol4 = _gvn.transform( new (C) BoolNode( cmp4, BoolTest::ne ) );
2699 IfNode *iff4 = create_and_xform_if( control(), bol4, PROB_FAIR, COUNT_UNKNOWN );
2700 r_not_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode (iff4) ) );
2701 r_ok_subtype ->init_req(3, _gvn.transform( new (C) IfFalseNode(iff4) ) );
2702
2703 // Return false path; set default control to true path.
2704 set_control( _gvn.transform(r_ok_subtype) );
2705 return _gvn.transform(r_not_subtype);
2706 }
2707
2708 //----------------------------static_subtype_check-----------------------------
2709 // Shortcut important common cases when superklass is exact:
2710 // (0) superklass is java.lang.Object (can occur in reflective code)
2711 // (1) subklass is already limited to a subtype of superklass => always ok
2712 // (2) subklass does not overlap with superklass => always fail
2713 // (3) superklass has NO subtypes and we can check with a simple compare.
2714 int GraphKit::static_subtype_check(ciKlass* superk, ciKlass* subk) {
2715 if (StressReflectiveCode) {
2716 return SSC_full_test; // Let caller generate the general case.
2717 }
2718
2719 if (superk == env()->Object_klass()) {
2720 return SSC_always_true; // (0) this test cannot fail
2721 }
2745 // Add a dependency if there is a chance of a later subclass.
2746 C->dependencies()->assert_leaf_type(ik);
2747 }
2748 return SSC_easy_test; // (3) caller can do a simple ptr comparison
2749 }
2750 } else {
2751 // A primitive array type has no subtypes.
2752 return SSC_easy_test; // (3) caller can do a simple ptr comparison
2753 }
2754
2755 return SSC_full_test;
2756 }
2757
2758 // Profile-driven exact type check:
2759 Node* GraphKit::type_check_receiver(Node* receiver, ciKlass* klass,
2760 float prob,
2761 Node* *casted_receiver) {
2762 const TypeKlassPtr* tklass = TypeKlassPtr::make(klass);
2763 Node* recv_klass = load_object_klass(receiver);
2764 Node* want_klass = makecon(tklass);
2765 Node* cmp = _gvn.transform( new(C) CmpPNode(recv_klass, want_klass) );
2766 Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
2767 IfNode* iff = create_and_xform_if(control(), bol, prob, COUNT_UNKNOWN);
2768 set_control( _gvn.transform( new(C) IfTrueNode (iff) ));
2769 Node* fail = _gvn.transform( new(C) IfFalseNode(iff) );
2770
2771 const TypeOopPtr* recv_xtype = tklass->as_instance_type();
2772 assert(recv_xtype->klass_is_exact(), "");
2773
2774 // Subsume downstream occurrences of receiver with a cast to
2775 // recv_xtype, since now we know what the type will be.
2776 Node* cast = new(C) CheckCastPPNode(control(), receiver, recv_xtype);
2777 (*casted_receiver) = _gvn.transform(cast);
2778 // (User must make the replace_in_map call.)
2779
2780 return fail;
2781 }
2782
2783
2784 //------------------------------seems_never_null-------------------------------
2785 // Use null_seen information if it is available from the profile.
2786 // If we see an unexpected null at a type check we record it and force a
2787 // recompile; the offending check will be recompiled to handle NULLs.
2788 // If we see several offending BCIs, then all checks in the
2789 // method will be recompiled.
2790 bool GraphKit::seems_never_null(Node* obj, ciProfileData* data, bool& speculating) {
2791 speculating = !_gvn.type(obj)->speculative_maybe_null();
2792 Deoptimization::DeoptReason reason = Deoptimization::reason_null_check(speculating);
2793 if (UncommonNullCast // Cutout for this technique
2794 && obj != null() // And not the -Xcomp stupid case?
2795 && !too_many_traps(reason)
2796 ) {
2903 if (!too_many_traps(Deoptimization::Reason_null_assert)) {
2904 Node* exact_obj = null_assert(obj);
2905 replace_in_map(obj, exact_obj);
2906 obj = exact_obj;
2907 }
2908 }
2909 return obj;
2910 }
2911
2912 //-------------------------------gen_instanceof--------------------------------
2913 // Generate an instance-of idiom. Used by both the instance-of bytecode
2914 // and the reflective instance-of call.
2915 Node* GraphKit::gen_instanceof(Node* obj, Node* superklass, bool safe_for_replace) {
2916 kill_dead_locals(); // Benefit all the uncommon traps
2917 assert( !stopped(), "dead parse path should be checked in callers" );
2918 assert(!TypePtr::NULL_PTR->higher_equal(_gvn.type(superklass)->is_klassptr()),
2919 "must check for not-null not-dead klass in callers");
2920
2921 // Make the merge point
2922 enum { _obj_path = 1, _fail_path, _null_path, PATH_LIMIT };
2923 RegionNode* region = new(C) RegionNode(PATH_LIMIT);
2924 Node* phi = new(C) PhiNode(region, TypeInt::BOOL);
2925 C->set_has_split_ifs(true); // Has chance for split-if optimization
2926
2927 ciProfileData* data = NULL;
2928 if (java_bc() == Bytecodes::_instanceof) { // Only for the bytecode
2929 data = method()->method_data()->bci_to_data(bci());
2930 }
2931 bool speculative_not_null = false;
2932 bool never_see_null = (ProfileDynamicTypes // aggressive use of profile
2933 && seems_never_null(obj, data, speculative_not_null));
2934
2935 // Null check; get casted pointer; set region slot 3
2936 Node* null_ctl = top();
2937 Node* not_null_obj = null_check_oop(obj, &null_ctl, never_see_null, safe_for_replace, speculative_not_null);
2938
2939 // If not_null_obj is dead, only null-path is taken
2940 if (stopped()) { // Doing instance-of on a NULL?
2941 set_control(null_ctl);
2942 return intcon(0);
2943 }
2944 region->init_req(_null_path, null_ctl);
3035 case SSC_always_false:
3036 // It needs a null check because a null will *pass* the cast check.
3037 // A non-null value will always produce an exception.
3038 return null_assert(obj);
3039 }
3040 }
3041 }
3042
3043 ciProfileData* data = NULL;
3044 bool safe_for_replace = false;
3045 if (failure_control == NULL) { // use MDO in regular case only
3046 assert(java_bc() == Bytecodes::_aastore ||
3047 java_bc() == Bytecodes::_checkcast,
3048 "interpreter profiles type checks only for these BCs");
3049 data = method()->method_data()->bci_to_data(bci());
3050 safe_for_replace = true;
3051 }
3052
3053 // Make the merge point
3054 enum { _obj_path = 1, _null_path, PATH_LIMIT };
3055 RegionNode* region = new (C) RegionNode(PATH_LIMIT);
3056 Node* phi = new (C) PhiNode(region, toop);
3057 C->set_has_split_ifs(true); // Has chance for split-if optimization
3058
3059 // Use null-cast information if it is available
3060 bool speculative_not_null = false;
3061 bool never_see_null = ((failure_control == NULL) // regular case only
3062 && seems_never_null(obj, data, speculative_not_null));
3063
3064 // Null check; get casted pointer; set region slot 3
3065 Node* null_ctl = top();
3066 Node* not_null_obj = null_check_oop(obj, &null_ctl, never_see_null, safe_for_replace, speculative_not_null);
3067
3068 // If not_null_obj is dead, only null-path is taken
3069 if (stopped()) { // Doing instance-of on a NULL?
3070 set_control(null_ctl);
3071 return null();
3072 }
3073 region->init_req(_null_path, null_ctl);
3074 phi ->init_req(_null_path, null()); // Set null path value
3075 if (null_ctl == top()) {
3076 // Do this eagerly, so that pattern matches like is_diamond_phi
3097 // all casts inserted by javac to implement generic types.
3098 data->as_CounterData()->count() >= 0)) {
3099 cast_obj = maybe_cast_profiled_receiver(not_null_obj, tk->klass(), spec_obj_type, safe_for_replace);
3100 if (cast_obj != NULL) {
3101 if (failure_control != NULL) // failure is now impossible
3102 (*failure_control) = top();
3103 // adjust the type of the phi to the exact klass:
3104 phi->raise_bottom_type(_gvn.type(cast_obj)->meet_speculative(TypePtr::NULL_PTR));
3105 }
3106 }
3107 }
3108
3109 if (cast_obj == NULL) {
3110 // Load the object's klass
3111 Node* obj_klass = load_object_klass(not_null_obj);
3112
3113 // Generate the subtype check
3114 Node* not_subtype_ctrl = gen_subtype_check( obj_klass, superklass );
3115
3116 // Plug in success path into the merge
3117 cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(),
3118 not_null_obj, toop));
3119 // Failure path ends in uncommon trap (or may be dead - failure impossible)
3120 if (failure_control == NULL) {
3121 if (not_subtype_ctrl != top()) { // If failure is possible
3122 PreserveJVMState pjvms(this);
3123 set_control(not_subtype_ctrl);
3124 builtin_throw(Deoptimization::Reason_class_check, obj_klass);
3125 }
3126 } else {
3127 (*failure_control) = not_subtype_ctrl;
3128 }
3129 }
3130
3131 region->init_req(_obj_path, control());
3132 phi ->init_req(_obj_path, cast_obj);
3133
3134 // A merge of NULL or Casted-NotNull obj
3135 Node* res = _gvn.transform(phi);
3136
3137 // Note I do NOT always 'replace_in_map(obj,result)' here.
3138 // if( tk->klass()->can_be_primary_super() )
3151 }
3152
3153 //------------------------------next_monitor-----------------------------------
3154 // What number should be given to the next monitor?
3155 int GraphKit::next_monitor() {
3156 int current = jvms()->monitor_depth()* C->sync_stack_slots();
3157 int next = current + C->sync_stack_slots();
3158 // Keep the toplevel high water mark current:
3159 if (C->fixed_slots() < next) C->set_fixed_slots(next);
3160 return current;
3161 }
3162
3163 //------------------------------insert_mem_bar---------------------------------
3164 // Memory barrier to avoid floating things around
3165 // The membar serves as a pinch point between both control and all memory slices.
3166 Node* GraphKit::insert_mem_bar(int opcode, Node* precedent) {
3167 MemBarNode* mb = MemBarNode::make(C, opcode, Compile::AliasIdxBot, precedent);
3168 mb->init_req(TypeFunc::Control, control());
3169 mb->init_req(TypeFunc::Memory, reset_memory());
3170 Node* membar = _gvn.transform(mb);
3171 set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
3172 set_all_memory_call(membar);
3173 return membar;
3174 }
3175
3176 //-------------------------insert_mem_bar_volatile----------------------------
3177 // Memory barrier to avoid floating things around
3178 // The membar serves as a pinch point between both control and memory(alias_idx).
3179 // If you want to make a pinch point on all memory slices, do not use this
3180 // function (even with AliasIdxBot); use insert_mem_bar() instead.
3181 Node* GraphKit::insert_mem_bar_volatile(int opcode, int alias_idx, Node* precedent) {
3182 // When Parse::do_put_xxx updates a volatile field, it appends a series
3183 // of MemBarVolatile nodes, one for *each* volatile field alias category.
3184 // The first membar is on the same memory slice as the field store opcode.
3185 // This forces the membar to follow the store. (Bug 6500685 broke this.)
3186 // All the other membars (for other volatile slices, including AliasIdxBot,
3187 // which stands for all unknown volatile slices) are control-dependent
3188 // on the first membar. This prevents later volatile loads or stores
3189 // from sliding up past the just-emitted store.
3190
3191 MemBarNode* mb = MemBarNode::make(C, opcode, alias_idx, precedent);
3192 mb->set_req(TypeFunc::Control,control());
3193 if (alias_idx == Compile::AliasIdxBot) {
3194 mb->set_req(TypeFunc::Memory, merged_memory()->base_memory());
3195 } else {
3196 assert(!(opcode == Op_Initialize && alias_idx != Compile::AliasIdxRaw), "fix caller");
3197 mb->set_req(TypeFunc::Memory, memory(alias_idx));
3198 }
3199 Node* membar = _gvn.transform(mb);
3200 set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
3201 if (alias_idx == Compile::AliasIdxBot) {
3202 merged_memory()->set_base_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)));
3203 } else {
3204 set_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)),alias_idx);
3205 }
3206 return membar;
3207 }
3208
3209 //------------------------------shared_lock------------------------------------
3210 // Emit locking code.
3211 FastLockNode* GraphKit::shared_lock(Node* obj) {
3212 // bci is either a monitorenter bc or InvocationEntryBci
3213 // %%% SynchronizationEntryBCI is redundant; use InvocationEntryBci in interfaces
3214 assert(SynchronizationEntryBCI == InvocationEntryBci, "");
3215
3216 if( !GenerateSynchronizationCode )
3217 return NULL; // Not locking things?
3218 if (stopped()) // Dead monitor?
3219 return NULL;
3220
3221 assert(dead_locals_are_killed(), "should kill locals before sync. point");
3222
3223 // Box the stack location
3224 Node* box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
3225 Node* mem = reset_memory();
3226
3227 FastLockNode * flock = _gvn.transform(new (C) FastLockNode(0, obj, box) )->as_FastLock();
3228 if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
3229 // Create the counters for this fast lock.
3230 flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
3231 }
3232
3233 // Create the rtm counters for this fast lock if needed.
3234 flock->create_rtm_lock_counter(sync_jvms()); // sync_jvms used to get current bci
3235
3236 // Add monitor to debug info for the slow path. If we block inside the
3237 // slow path and de-opt, we need the monitor hanging around
3238 map()->push_monitor( flock );
3239
3240 const TypeFunc *tf = LockNode::lock_type();
3241 LockNode *lock = new (C) LockNode(C, tf);
3242
3243 lock->init_req( TypeFunc::Control, control() );
3244 lock->init_req( TypeFunc::Memory , mem );
3245 lock->init_req( TypeFunc::I_O , top() ) ; // does no i/o
3246 lock->init_req( TypeFunc::FramePtr, frameptr() );
3247 lock->init_req( TypeFunc::ReturnAdr, top() );
3248
3249 lock->init_req(TypeFunc::Parms + 0, obj);
3250 lock->init_req(TypeFunc::Parms + 1, box);
3251 lock->init_req(TypeFunc::Parms + 2, flock);
3252 add_safepoint_edges(lock);
3253
3254 lock = _gvn.transform( lock )->as_Lock();
3255
3256 // lock has no side-effects, sets few values
3257 set_predefined_output_for_runtime_call(lock, mem, TypeRawPtr::BOTTOM);
3258
3259 insert_mem_bar(Op_MemBarAcquireLock);
3260
3261 // Add this to the worklist so that the lock can be eliminated
3275
3276
3277 //------------------------------shared_unlock----------------------------------
3278 // Emit unlocking code.
3279 void GraphKit::shared_unlock(Node* box, Node* obj) {
3280 // bci is either a monitorenter bc or InvocationEntryBci
3281 // %%% SynchronizationEntryBCI is redundant; use InvocationEntryBci in interfaces
3282 assert(SynchronizationEntryBCI == InvocationEntryBci, "");
3283
3284 if( !GenerateSynchronizationCode )
3285 return;
3286 if (stopped()) { // Dead monitor?
3287 map()->pop_monitor(); // Kill monitor from debug info
3288 return;
3289 }
3290
3291 // Memory barrier to avoid floating things down past the locked region
3292 insert_mem_bar(Op_MemBarReleaseLock);
3293
3294 const TypeFunc *tf = OptoRuntime::complete_monitor_exit_Type();
3295 UnlockNode *unlock = new (C) UnlockNode(C, tf);
3296 uint raw_idx = Compile::AliasIdxRaw;
3297 unlock->init_req( TypeFunc::Control, control() );
3298 unlock->init_req( TypeFunc::Memory , memory(raw_idx) );
3299 unlock->init_req( TypeFunc::I_O , top() ) ; // does no i/o
3300 unlock->init_req( TypeFunc::FramePtr, frameptr() );
3301 unlock->init_req( TypeFunc::ReturnAdr, top() );
3302
3303 unlock->init_req(TypeFunc::Parms + 0, obj);
3304 unlock->init_req(TypeFunc::Parms + 1, box);
3305 unlock = _gvn.transform(unlock)->as_Unlock();
3306
3307 Node* mem = reset_memory();
3308
3309 // unlock has no side-effects, sets few values
3310 set_predefined_output_for_runtime_call(unlock, mem, TypeRawPtr::BOTTOM);
3311
3312 // Kill monitor from debug info
3313 map()->pop_monitor( );
3314 }
3315
3341 // We just put in an allocate/initialize with a big raw-memory effect.
3342 // Hook selected additional alias categories on the initialization.
3343 static void hook_memory_on_init(GraphKit& kit, int alias_idx,
3344 MergeMemNode* init_in_merge,
3345 Node* init_out_raw) {
3346 DEBUG_ONLY(Node* init_in_raw = init_in_merge->base_memory());
3347 assert(init_in_merge->memory_at(alias_idx) == init_in_raw, "");
3348
3349 Node* prevmem = kit.memory(alias_idx);
3350 init_in_merge->set_memory_at(alias_idx, prevmem);
3351 kit.set_memory(init_out_raw, alias_idx);
3352 }
3353
3354 //---------------------------set_output_for_allocation-------------------------
3355 Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
3356 const TypeOopPtr* oop_type) {
3357 int rawidx = Compile::AliasIdxRaw;
3358 alloc->set_req( TypeFunc::FramePtr, frameptr() );
3359 add_safepoint_edges(alloc);
3360 Node* allocx = _gvn.transform(alloc);
3361 set_control( _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Control) ) );
3362 // create memory projection for i_o
3363 set_memory ( _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
3364 make_slow_call_ex(allocx, env()->Throwable_klass(), true);
3365
3366 // create a memory projection as for the normal control path
3367 Node* malloc = _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Memory));
3368 set_memory(malloc, rawidx);
3369
3370 // a normal slow-call doesn't change i_o, but an allocation does
3371 // we create a separate i_o projection for the normal control path
3372 set_i_o(_gvn.transform( new (C) ProjNode(allocx, TypeFunc::I_O, false) ) );
3373 Node* rawoop = _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Parms) );
3374
3375 // put in an initialization barrier
3376 InitializeNode* init = insert_mem_bar_volatile(Op_Initialize, rawidx,
3377 rawoop)->as_Initialize();
3378 assert(alloc->initialization() == init, "2-way macro link must work");
3379 assert(init ->allocation() == alloc, "2-way macro link must work");
3380 {
3381 // Extract memory strands which may participate in the new object's
3382 // initialization, and source them from the new InitializeNode.
3383 // This will allow us to observe initializations when they occur,
3384 // and link them properly (as a group) to the InitializeNode.
3385 assert(init->in(InitializeNode::Memory) == malloc, "");
3386 MergeMemNode* minit_in = MergeMemNode::make(C, malloc);
3387 init->set_req(InitializeNode::Memory, minit_in);
3388 record_for_igvn(minit_in); // fold it up later, if possible
3389 Node* minit_out = memory(rawidx);
3390 assert(minit_out->is_Proj() && minit_out->in(0) == init, "");
3391 if (oop_type->isa_aryptr()) {
3392 const TypePtr* telemref = oop_type->add_offset(Type::OffsetBot);
3393 int elemidx = C->get_alias_index(telemref);
3394 hook_memory_on_init(*this, elemidx, minit_in, minit_out);
3395 } else if (oop_type->isa_instptr()) {
3396 ciInstanceKlass* ik = oop_type->klass()->as_instance_klass();
3397 for (int i = 0, len = ik->nof_nonstatic_fields(); i < len; i++) {
3398 ciField* field = ik->nonstatic_field_at(i);
3399 if (field->offset() >= TrackedInitializationLimit * HeapWordSize)
3400 continue; // do not bother to track really large numbers of fields
3401 // Find (or create) the alias category for this field:
3402 int fieldidx = C->alias_type(field)->index();
3403 hook_memory_on_init(*this, fieldidx, minit_in, minit_out);
3404 }
3405 }
3406 }
3407
3408 // Cast raw oop to the real thing...
3409 Node* javaoop = new (C) CheckCastPPNode(control(), rawoop, oop_type);
3410 javaoop = _gvn.transform(javaoop);
3411 C->set_recent_alloc(control(), javaoop);
3412 assert(just_allocated_object(control()) == javaoop, "just allocated");
3413
3414 #ifdef ASSERT
3415 { // Verify that the AllocateNode::Ideal_allocation recognizers work:
3416 assert(AllocateNode::Ideal_allocation(rawoop, &_gvn) == alloc,
3417 "Ideal_allocation works");
3418 assert(AllocateNode::Ideal_allocation(javaoop, &_gvn) == alloc,
3419 "Ideal_allocation works");
3420 if (alloc->is_AllocateArray()) {
3421 assert(AllocateArrayNode::Ideal_array_allocation(rawoop, &_gvn) == alloc->as_AllocateArray(),
3422 "Ideal_allocation works");
3423 assert(AllocateArrayNode::Ideal_array_allocation(javaoop, &_gvn) == alloc->as_AllocateArray(),
3424 "Ideal_allocation works");
3425 } else {
3426 assert(alloc->in(AllocateNode::ALength)->is_top(), "no length, please");
3427 }
3428 }
3429 #endif //ASSERT
3448 // The layout_helper also encodes (in a low bit) the need for a slow path.
3449 jint layout_con = Klass::_lh_neutral_value;
3450 Node* layout_val = get_layout_helper(klass_node, layout_con);
3451 int layout_is_con = (layout_val == NULL);
3452
3453 if (extra_slow_test == NULL) extra_slow_test = intcon(0);
3454 // Generate the initial go-slow test. It's either ALWAYS (return a
3455 // Node for 1) or NEVER (return a NULL) or perhaps (in the reflective
3456 // case) a computed value derived from the layout_helper.
3457 Node* initial_slow_test = NULL;
3458 if (layout_is_con) {
3459 assert(!StressReflectiveCode, "stress mode does not use these paths");
3460 bool must_go_slow = Klass::layout_helper_needs_slow_path(layout_con);
3461 initial_slow_test = must_go_slow? intcon(1): extra_slow_test;
3462
3463 } else { // reflective case
3464 // This reflective path is used by Unsafe.allocateInstance.
3465 // (It may be stress-tested by specifying StressReflectiveCode.)
3466 // Basically, we want to get into the VM is there's an illegal argument.
3467 Node* bit = intcon(Klass::_lh_instance_slow_path_bit);
3468 initial_slow_test = _gvn.transform( new (C) AndINode(layout_val, bit) );
3469 if (extra_slow_test != intcon(0)) {
3470 initial_slow_test = _gvn.transform( new (C) OrINode(initial_slow_test, extra_slow_test) );
3471 }
3472 // (Macro-expander will further convert this to a Bool, if necessary.)
3473 }
3474
3475 // Find the size in bytes. This is easy; it's the layout_helper.
3476 // The size value must be valid even if the slow path is taken.
3477 Node* size = NULL;
3478 if (layout_is_con) {
3479 size = MakeConX(Klass::layout_helper_size_in_bytes(layout_con));
3480 } else { // reflective case
3481 // This reflective path is used by clone and Unsafe.allocateInstance.
3482 size = ConvI2X(layout_val);
3483
3484 // Clear the low bits to extract layout_helper_size_in_bytes:
3485 assert((int)Klass::_lh_instance_slow_path_bit < BytesPerLong, "clear bit");
3486 Node* mask = MakeConX(~ (intptr_t)right_n_bits(LogBytesPerLong));
3487 size = _gvn.transform( new (C) AndXNode(size, mask) );
3488 }
3489 if (return_size_val != NULL) {
3490 (*return_size_val) = size;
3491 }
3492
3493 // This is a precise notnull oop of the klass.
3494 // (Actually, it need not be precise if this is a reflective allocation.)
3495 // It's what we cast the result to.
3496 const TypeKlassPtr* tklass = _gvn.type(klass_node)->isa_klassptr();
3497 if (!tklass) tklass = TypeKlassPtr::OBJECT;
3498 const TypeOopPtr* oop_type = tklass->as_instance_type();
3499
3500 // Now generate allocation code
3501
3502 // The entire memory state is needed for slow path of the allocation
3503 // since GC and deoptimization can happened.
3504 Node *mem = reset_memory();
3505 set_all_memory(mem); // Create new memory state
3506
3507 AllocateNode* alloc
3508 = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
3509 control(), mem, i_o(),
3510 size, klass_node,
3511 initial_slow_test);
3512
3513 return set_output_for_allocation(alloc, oop_type);
3514 }
3515
3516 //-------------------------------new_array-------------------------------------
3517 // helper for both newarray and anewarray
3518 // The 'length' parameter is (obviously) the length of the array.
3519 // See comments on new_instance for the meaning of the other arguments.
3520 Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
3521 Node* length, // number of array elements
3522 int nargs, // number of arguments to push back for uncommon trap
3523 Node* *return_size_val) {
3524 jint layout_con = Klass::_lh_neutral_value;
3525 Node* layout_val = get_layout_helper(klass_node, layout_con);
3526 int layout_is_con = (layout_val == NULL);
3527
3528 if (!layout_is_con && !StressReflectiveCode &&
3529 !too_many_traps(Deoptimization::Reason_class_check)) {
3530 // This is a reflective array creation site.
3531 // Optimistically assume that it is a subtype of Object[],
3532 // so that we can fold up all the address arithmetic.
3533 layout_con = Klass::array_layout_helper(T_OBJECT);
3534 Node* cmp_lh = _gvn.transform( new(C) CmpINode(layout_val, intcon(layout_con)) );
3535 Node* bol_lh = _gvn.transform( new(C) BoolNode(cmp_lh, BoolTest::eq) );
3536 { BuildCutout unless(this, bol_lh, PROB_MAX);
3537 inc_sp(nargs);
3538 uncommon_trap(Deoptimization::Reason_class_check,
3539 Deoptimization::Action_maybe_recompile);
3540 }
3541 layout_val = NULL;
3542 layout_is_con = true;
3543 }
3544
3545 // Generate the initial go-slow test. Make sure we do not overflow
3546 // if length is huge (near 2Gig) or negative! We do not need
3547 // exact double-words here, just a close approximation of needed
3548 // double-words. We can't add any offset or rounding bits, lest we
3549 // take a size -1 of bytes and make it positive. Use an unsigned
3550 // compare, so negative sizes look hugely positive.
3551 int fast_size_limit = FastAllocateSizeLimit;
3552 if (layout_is_con) {
3553 assert(!StressReflectiveCode, "stress mode does not use these paths");
3554 // Increase the size limit if we have exact knowledge of array type.
3555 int log2_esize = Klass::layout_helper_log2_element_size(layout_con);
3556 fast_size_limit <<= (LogBytesPerLong - log2_esize);
3557 }
3558
3559 Node* initial_slow_cmp = _gvn.transform( new (C) CmpUNode( length, intcon( fast_size_limit ) ) );
3560 Node* initial_slow_test = _gvn.transform( new (C) BoolNode( initial_slow_cmp, BoolTest::gt ) );
3561 if (initial_slow_test->is_Bool()) {
3562 // Hide it behind a CMoveI, or else PhaseIdealLoop::split_up will get sick.
3563 initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);
3564 }
3565
3566 // --- Size Computation ---
3567 // array_size = round_to_heap(array_header + (length << elem_shift));
3568 // where round_to_heap(x) == round_to(x, MinObjAlignmentInBytes)
3569 // and round_to(x, y) == ((x + y-1) & ~(y-1))
3570 // The rounding mask is strength-reduced, if possible.
3571 int round_mask = MinObjAlignmentInBytes - 1;
3572 Node* header_size = NULL;
3573 int header_size_min = arrayOopDesc::base_offset_in_bytes(T_BYTE);
3574 // (T_BYTE has the weakest alignment and size restrictions...)
3575 if (layout_is_con) {
3576 int hsize = Klass::layout_helper_header_size(layout_con);
3577 int eshift = Klass::layout_helper_log2_element_size(layout_con);
3578 BasicType etype = Klass::layout_helper_element_type(layout_con);
3579 if ((round_mask & ~right_n_bits(eshift)) == 0)
3580 round_mask = 0; // strength-reduce it if it goes away completely
3581 assert((hsize & right_n_bits(eshift)) == 0, "hsize is pre-rounded");
3582 assert(header_size_min <= hsize, "generic minimum is smallest");
3583 header_size_min = hsize;
3584 header_size = intcon(hsize + round_mask);
3585 } else {
3586 Node* hss = intcon(Klass::_lh_header_size_shift);
3587 Node* hsm = intcon(Klass::_lh_header_size_mask);
3588 Node* hsize = _gvn.transform( new(C) URShiftINode(layout_val, hss) );
3589 hsize = _gvn.transform( new(C) AndINode(hsize, hsm) );
3590 Node* mask = intcon(round_mask);
3591 header_size = _gvn.transform( new(C) AddINode(hsize, mask) );
3592 }
3593
3594 Node* elem_shift = NULL;
3595 if (layout_is_con) {
3596 int eshift = Klass::layout_helper_log2_element_size(layout_con);
3597 if (eshift != 0)
3598 elem_shift = intcon(eshift);
3599 } else {
3600 // There is no need to mask or shift this value.
3601 // The semantics of LShiftINode include an implicit mask to 0x1F.
3602 assert(Klass::_lh_log2_element_size_shift == 0, "use shift in place");
3603 elem_shift = layout_val;
3604 }
3605
3606 // Transition to native address size for all offset calculations:
3607 Node* lengthx = ConvI2X(length);
3608 Node* headerx = ConvI2X(header_size);
3609 #ifdef _LP64
3610 { const TypeLong* tllen = _gvn.find_long_type(lengthx);
3611 if (tllen != NULL && tllen->_lo < 0) {
3612 // Add a manual constraint to a positive range. Cf. array_element_address.
3613 jlong size_max = arrayOopDesc::max_array_length(T_BYTE);
3614 if (size_max > tllen->_hi) size_max = tllen->_hi;
3615 const TypeLong* tlcon = TypeLong::make(CONST64(0), size_max, Type::WidenMin);
3616 lengthx = _gvn.transform( new (C) ConvI2LNode(length, tlcon));
3617 }
3618 }
3619 #endif
3620
3621 // Combine header size (plus rounding) and body size. Then round down.
3622 // This computation cannot overflow, because it is used only in two
3623 // places, one where the length is sharply limited, and the other
3624 // after a successful allocation.
3625 Node* abody = lengthx;
3626 if (elem_shift != NULL)
3627 abody = _gvn.transform( new(C) LShiftXNode(lengthx, elem_shift) );
3628 Node* size = _gvn.transform( new(C) AddXNode(headerx, abody) );
3629 if (round_mask != 0) {
3630 Node* mask = MakeConX(~round_mask);
3631 size = _gvn.transform( new(C) AndXNode(size, mask) );
3632 }
3633 // else if round_mask == 0, the size computation is self-rounding
3634
3635 if (return_size_val != NULL) {
3636 // This is the size
3637 (*return_size_val) = size;
3638 }
3639
3640 // Now generate allocation code
3641
3642 // The entire memory state is needed for slow path of the allocation
3643 // since GC and deoptimization can happened.
3644 Node *mem = reset_memory();
3645 set_all_memory(mem); // Create new memory state
3646
3647 // Create the AllocateArrayNode and its result projections
3648 AllocateArrayNode* alloc
3649 = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
3650 control(), mem, i_o(),
3651 size, klass_node,
3652 initial_slow_test,
3653 length);
3654
3655 // Cast to correct type. Note that the klass_node may be constant or not,
3656 // and in the latter case the actual array type will be inexact also.
3657 // (This happens via a non-constant argument to inline_native_newArray.)
3658 // In any case, the value of klass_node provides the desired array type.
3659 const TypeInt* length_type = _gvn.find_int_type(length);
3660 const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type();
3661 if (ary_type->isa_aryptr() && length_type != NULL) {
3662 // Try to get a better type than POS for the size
3663 ary_type = ary_type->is_aryptr()->cast_to_size(length_type);
3664 }
3665
3666 Node* javaoop = set_output_for_allocation(alloc, ary_type);
3667
3668 // Cast length on remaining path to be as narrow as possible
3669 if (map()->find_edge(length) >= 0) {
3743
3744 //------------------------------add_predicate_impl----------------------------
3745 void GraphKit::add_predicate_impl(Deoptimization::DeoptReason reason, int nargs) {
3746 // Too many traps seen?
3747 if (too_many_traps(reason)) {
3748 #ifdef ASSERT
3749 if (TraceLoopPredicate) {
3750 int tc = C->trap_count(reason);
3751 tty->print("too many traps=%s tcount=%d in ",
3752 Deoptimization::trap_reason_name(reason), tc);
3753 method()->print(); // which method has too many predicate traps
3754 tty->cr();
3755 }
3756 #endif
3757 // We cannot afford to take more traps here,
3758 // do not generate predicate.
3759 return;
3760 }
3761
3762 Node *cont = _gvn.intcon(1);
3763 Node* opq = _gvn.transform(new (C) Opaque1Node(C, cont));
3764 Node *bol = _gvn.transform(new (C) Conv2BNode(opq));
3765 IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
3766 Node* iffalse = _gvn.transform(new (C) IfFalseNode(iff));
3767 C->add_predicate_opaq(opq);
3768 {
3769 PreserveJVMState pjvms(this);
3770 set_control(iffalse);
3771 inc_sp(nargs);
3772 uncommon_trap(reason, Deoptimization::Action_maybe_recompile);
3773 }
3774 Node* iftrue = _gvn.transform(new (C) IfTrueNode(iff));
3775 set_control(iftrue);
3776 }
3777
3778 //------------------------------add_predicate---------------------------------
3779 void GraphKit::add_predicate(int nargs) {
3780 if (UseLoopPredicate) {
3781 add_predicate_impl(Deoptimization::Reason_predicate, nargs);
3782 }
3783 // loop's limit check predicate should be near the loop.
3784 if (LoopLimitCheck) {
3785 add_predicate_impl(Deoptimization::Reason_loop_limit_check, nargs);
3786 }
3787 }
3788
3789 //----------------------------- store barriers ----------------------------
3790 #define __ ideal.
3791
3792 void GraphKit::sync_kit(IdealKit& ideal) {
3793 set_all_memory(__ merged_memory());
3794 set_i_o(__ i_o());
3946 // if (!marking)
3947 __ if_then(marking, BoolTest::ne, zero, unlikely); {
3948 BasicType index_bt = TypeX_X->basic_type();
3949 assert(sizeof(size_t) == type2aelembytes(index_bt), "Loading G1 PtrQueue::_index with wrong size.");
3950 Node* index = __ load(__ ctrl(), index_adr, TypeX_X, index_bt, Compile::AliasIdxRaw);
3951
3952 if (do_load) {
3953 // load original value
3954 // alias_idx correct??
3955 pre_val = __ load(__ ctrl(), adr, val_type, bt, alias_idx);
3956 }
3957
3958 // if (pre_val != NULL)
3959 __ if_then(pre_val, BoolTest::ne, null()); {
3960 Node* buffer = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw);
3961
3962 // is the queue for this thread full?
3963 __ if_then(index, BoolTest::ne, zeroX, likely); {
3964
3965 // decrement the index
3966 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
3967
3968 // Now get the buffer location we will log the previous value into and store it
3969 Node *log_addr = __ AddP(no_base, buffer, next_index);
3970 __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw, MemNode::unordered);
3971 // update the index
3972 __ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw, MemNode::unordered);
3973
3974 } __ else_(); {
3975
3976 // logging buffer is full, call the runtime
3977 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type();
3978 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), "g1_wb_pre", pre_val, tls);
3979 } __ end_if(); // (!index)
3980 } __ end_if(); // (pre_val != NULL)
3981 } __ end_if(); // (!marking)
3982
3983 // Final sync IdealKit and GraphKit.
3984 final_sync(ideal);
3985 }
3986
3989 //
3990 void GraphKit::g1_mark_card(IdealKit& ideal,
3991 Node* card_adr,
3992 Node* oop_store,
3993 uint oop_alias_idx,
3994 Node* index,
3995 Node* index_adr,
3996 Node* buffer,
3997 const TypeFunc* tf) {
3998
3999 Node* zero = __ ConI(0);
4000 Node* zeroX = __ ConX(0);
4001 Node* no_base = __ top();
4002 BasicType card_bt = T_BYTE;
4003 // Smash zero into card. MUST BE ORDERED WRT TO STORE
4004 __ storeCM(__ ctrl(), card_adr, zero, oop_store, oop_alias_idx, card_bt, Compile::AliasIdxRaw);
4005
4006 // Now do the queue work
4007 __ if_then(index, BoolTest::ne, zeroX); {
4008
4009 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
4010 Node* log_addr = __ AddP(no_base, buffer, next_index);
4011
4012 // Order, see storeCM.
4013 __ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered);
4014 __ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw, MemNode::unordered);
4015
4016 } __ else_(); {
4017 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), "g1_wb_post", card_adr, __ thread());
4018 } __ end_if();
4019
4020 }
4021
4022 void GraphKit::g1_write_barrier_post(Node* oop_store,
4023 Node* obj,
4024 Node* adr,
4025 uint alias_idx,
4026 Node* val,
4027 BasicType bt,
4028 bool use_precise) {
4029 // If we are writing a NULL then we need no post barrier
4196 false, NULL, 0);
4197 const TypePtr* value_field_type = string_type->add_offset(value_offset);
4198
4199 store_oop_to_object(ctrl, str, basic_plus_adr(str, value_offset), value_field_type,
4200 value, TypeAryPtr::CHARS, T_OBJECT, MemNode::unordered);
4201 }
4202
4203 void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) {
4204 int count_offset = java_lang_String::count_offset_in_bytes();
4205 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
4206 false, NULL, 0);
4207 const TypePtr* count_field_type = string_type->add_offset(count_offset);
4208 int count_field_idx = C->get_alias_index(count_field_type);
4209 store_to_memory(ctrl, basic_plus_adr(str, count_offset),
4210 value, T_INT, count_field_idx, MemNode::unordered);
4211 }
4212
4213 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
4214 // Reify the property as a CastPP node in Ideal graph to comply with monotonicity
4215 // assumption of CCP analysis.
4216 return _gvn.transform(new(C) CastPPNode(ary, ary_type->cast_to_stable(true)));
4217 }
|
277 }
278 }
279 }
280
281 //-----------------------transfer_exceptions_into_jvms-------------------------
282 JVMState* GraphKit::transfer_exceptions_into_jvms() {
283 if (map() == NULL) {
284 // We need a JVMS to carry the exceptions, but the map has gone away.
285 // Create a scratch JVMS, cloned from any of the exception states...
286 if (has_exceptions()) {
287 _map = _exceptions;
288 _map = clone_map();
289 _map->set_next_exception(NULL);
290 clear_saved_ex_oop(_map);
291 debug_only(verify_map());
292 } else {
293 // ...or created from scratch
294 JVMState* jvms = new (C) JVMState(_method, NULL);
295 jvms->set_bci(_bci);
296 jvms->set_sp(_sp);
297 jvms->set_map(new SafePointNode(TypeFunc::Parms, jvms));
298 set_jvms(jvms);
299 for (uint i = 0; i < map()->req(); i++) map()->init_req(i, top());
300 set_all_memory(top());
301 while (map()->req() < jvms->endoff()) map()->add_req(top());
302 }
303 // (This is a kludge, in case you didn't notice.)
304 set_control(top());
305 }
306 JVMState* jvms = sync_jvms();
307 assert(!jvms->map()->has_exceptions(), "no exceptions on this map yet");
308 jvms->map()->set_next_exception(_exceptions);
309 _exceptions = NULL; // done with this set of exceptions
310 return jvms;
311 }
312
313 static inline void add_n_reqs(Node* dstphi, Node* srcphi) {
314 assert(is_hidden_merge(dstphi), "must be a special merge node");
315 assert(is_hidden_merge(srcphi), "must be a special merge node");
316 uint limit = srcphi->req();
317 for (uint i = PhiNode::Input; i < limit; i++) {
330 // untransformed, and can build up gradually. The region is marked by
331 // having a control input of its exception map, rather than NULL. Such
332 // regions do not appear except in this function, and in use_exception_state.
333 void GraphKit::combine_exception_states(SafePointNode* ex_map, SafePointNode* phi_map) {
334 if (failing()) return; // dying anyway...
335 JVMState* ex_jvms = ex_map->_jvms;
336 assert(ex_jvms->same_calls_as(phi_map->_jvms), "consistent call chains");
337 assert(ex_jvms->stkoff() == phi_map->_jvms->stkoff(), "matching locals");
338 assert(ex_jvms->sp() == phi_map->_jvms->sp(), "matching stack sizes");
339 assert(ex_jvms->monoff() == phi_map->_jvms->monoff(), "matching JVMS");
340 assert(ex_jvms->scloff() == phi_map->_jvms->scloff(), "matching scalar replaced objects");
341 assert(ex_map->req() == phi_map->req(), "matching maps");
342 uint tos = ex_jvms->stkoff() + ex_jvms->sp();
343 Node* hidden_merge_mark = root();
344 Node* region = phi_map->control();
345 MergeMemNode* phi_mem = phi_map->merged_memory();
346 MergeMemNode* ex_mem = ex_map->merged_memory();
347 if (region->in(0) != hidden_merge_mark) {
348 // The control input is not (yet) a specially-marked region in phi_map.
349 // Make it so, and build some phis.
350 region = new RegionNode(2);
351 _gvn.set_type(region, Type::CONTROL);
352 region->set_req(0, hidden_merge_mark); // marks an internal ex-state
353 region->init_req(1, phi_map->control());
354 phi_map->set_control(region);
355 Node* io_phi = PhiNode::make(region, phi_map->i_o(), Type::ABIO);
356 record_for_igvn(io_phi);
357 _gvn.set_type(io_phi, Type::ABIO);
358 phi_map->set_i_o(io_phi);
359 for (MergeMemStream mms(phi_mem); mms.next_non_empty(); ) {
360 Node* m = mms.memory();
361 Node* m_phi = PhiNode::make(region, m, Type::MEMORY, mms.adr_type(C));
362 record_for_igvn(m_phi);
363 _gvn.set_type(m_phi, Type::MEMORY);
364 mms.set_memory(m_phi);
365 }
366 }
367
368 // Either or both of phi_map and ex_map might already be converted into phis.
369 Node* ex_control = ex_map->control();
370 // if there is special marking on ex_map also, we add multiple edges from src
479 Bytecodes::Code GraphKit::java_bc() const {
480 ciMethod* method = this->method();
481 int bci = this->bci();
482 if (method != NULL && bci != InvocationEntryBci)
483 return method->java_code_at_bci(bci);
484 else
485 return Bytecodes::_illegal;
486 }
487
488 void GraphKit::uncommon_trap_if_should_post_on_exceptions(Deoptimization::DeoptReason reason,
489 bool must_throw) {
490 // if the exception capability is set, then we will generate code
491 // to check the JavaThread.should_post_on_exceptions flag to see
492 // if we actually need to report exception events (for this
493 // thread). If we don't need to report exception events, we will
494 // take the normal fast path provided by add_exception_events. If
495 // exception event reporting is enabled for this thread, we will
496 // take the uncommon_trap in the BuildCutout below.
497
498 // first must access the should_post_on_exceptions_flag in this thread's JavaThread
499 Node* jthread = _gvn.transform(new ThreadLocalNode());
500 Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
501 Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
502
503 // Test the should_post_on_exceptions_flag vs. 0
504 Node* chk = _gvn.transform( new CmpINode(should_post_flag, intcon(0)) );
505 Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
506
507 // Branch to slow_path if should_post_on_exceptions_flag was true
508 { BuildCutout unless(this, tst, PROB_MAX);
509 // Do not try anything fancy if we're notifying the VM on every throw.
510 // Cf. case Bytecodes::_athrow in parse2.cpp.
511 uncommon_trap(reason, Deoptimization::Action_none,
512 (ciKlass*)NULL, (char*)NULL, must_throw);
513 }
514
515 }
516
517 //------------------------------builtin_throw----------------------------------
518 void GraphKit::builtin_throw(Deoptimization::DeoptReason reason, Node* arg) {
519 bool must_throw = true;
520
521 if (env()->jvmti_can_post_on_exceptions()) {
522 // check if we must post exception events, take uncommon trap if so
523 uncommon_trap_if_should_post_on_exceptions(reason, must_throw);
524 // here if should_post_on_exceptions is false
525 // continue on with the normal codegen
658 #ifdef ASSERT
659 assert(kit->bci() == _bci, "bci must not shift");
660 Parse* parser = kit->is_Parse();
661 int block = (parser == NULL || parser->block() == NULL) ? -1 : parser->block()->rpo();
662 assert(block == _block, "block must not shift");
663 #endif
664 kit->set_map(_map);
665 kit->set_sp(_sp);
666 Compile::current()->dec_preserve_jvm_state();
667 }
668
669
670 //-----------------------------BuildCutout-------------------------------------
671 BuildCutout::BuildCutout(GraphKit* kit, Node* p, float prob, float cnt)
672 : PreserveJVMState(kit)
673 {
674 assert(p->is_Con() || p->is_Bool(), "test must be a bool");
675 SafePointNode* outer_map = _map; // preserved map is caller's
676 SafePointNode* inner_map = kit->map();
677 IfNode* iff = kit->create_and_map_if(outer_map->control(), p, prob, cnt);
678 outer_map->set_control(kit->gvn().transform( new IfTrueNode(iff) ));
679 inner_map->set_control(kit->gvn().transform( new IfFalseNode(iff) ));
680 }
681 BuildCutout::~BuildCutout() {
682 GraphKit* kit = _kit;
683 assert(kit->stopped(), "cutout code must stop, throw, return, etc.");
684 }
685
686 //---------------------------PreserveReexecuteState----------------------------
687 PreserveReexecuteState::PreserveReexecuteState(GraphKit* kit) {
688 assert(!kit->stopped(), "must call stopped() before");
689 _kit = kit;
690 _sp = kit->sp();
691 _reexecute = kit->jvms()->_reexecute;
692 }
693 PreserveReexecuteState::~PreserveReexecuteState() {
694 if (_kit->stopped()) return;
695 _kit->jvms()->_reexecute = _reexecute;
696 _kit->set_sp(_sp);
697 }
698
699 //------------------------------clone_map--------------------------------------
1101 int outputs = depth + inputs;
1102 assert(outputs >= 0, "sanity");
1103 switch (code) {
1104 case Bytecodes::_checkcast: assert(inputs == 1 && outputs == 1, ""); break;
1105 case Bytecodes::_athrow: assert(inputs == 1 && outputs == 0, ""); break;
1106 case Bytecodes::_aload_0: assert(inputs == 0 && outputs == 1, ""); break;
1107 case Bytecodes::_return: assert(inputs == 0 && outputs == 0, ""); break;
1108 case Bytecodes::_drem: assert(inputs == 4 && outputs == 2, ""); break;
1109 }
1110 #endif //ASSERT
1111
1112 return true;
1113 }
1114
1115
1116
1117 //------------------------------basic_plus_adr---------------------------------
1118 Node* GraphKit::basic_plus_adr(Node* base, Node* ptr, Node* offset) {
1119 // short-circuit a common case
1120 if (offset == intcon(0)) return ptr;
1121 return _gvn.transform( new AddPNode(base, ptr, offset) );
1122 }
1123
1124 Node* GraphKit::ConvI2L(Node* offset) {
1125 // short-circuit a common case
1126 jint offset_con = find_int_con(offset, Type::OffsetBot);
1127 if (offset_con != Type::OffsetBot) {
1128 return longcon((jlong) offset_con);
1129 }
1130 return _gvn.transform( new ConvI2LNode(offset));
1131 }
1132
1133 Node* GraphKit::ConvI2UL(Node* offset) {
1134 juint offset_con = (juint) find_int_con(offset, Type::OffsetBot);
1135 if (offset_con != (juint) Type::OffsetBot) {
1136 return longcon((julong) offset_con);
1137 }
1138 Node* conv = _gvn.transform( new ConvI2LNode(offset));
1139 Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
1140 return _gvn.transform( new AndLNode(conv, mask) );
1141 }
1142
1143 Node* GraphKit::ConvL2I(Node* offset) {
1144 // short-circuit a common case
1145 jlong offset_con = find_long_con(offset, (jlong)Type::OffsetBot);
1146 if (offset_con != (jlong)Type::OffsetBot) {
1147 return intcon((int) offset_con);
1148 }
1149 return _gvn.transform( new ConvL2INode(offset));
1150 }
1151
1152 //-------------------------load_object_klass-----------------------------------
1153 Node* GraphKit::load_object_klass(Node* obj) {
1154 // Special-case a fresh allocation to avoid building nodes:
1155 Node* akls = AllocateNode::Ideal_klass(obj, &_gvn);
1156 if (akls != NULL) return akls;
1157 Node* k_adr = basic_plus_adr(obj, oopDesc::klass_offset_in_bytes());
1158 return _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), k_adr, TypeInstPtr::KLASS) );
1159 }
1160
1161 //-------------------------load_array_length-----------------------------------
1162 Node* GraphKit::load_array_length(Node* array) {
1163 // Special-case a fresh allocation to avoid building nodes:
1164 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(array, &_gvn);
1165 Node *alen;
1166 if (alloc == NULL) {
1167 Node *r_adr = basic_plus_adr(array, arrayOopDesc::length_offset_in_bytes());
1168 alen = _gvn.transform( new LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
1169 } else {
1170 alen = alloc->Ideal_length();
1171 Node* ccast = alloc->make_ideal_length(_gvn.type(array)->is_oopptr(), &_gvn);
1172 if (ccast != alen) {
1173 alen = _gvn.transform(ccast);
1174 }
1175 }
1176 return alen;
1177 }
1178
1179 //------------------------------do_null_check----------------------------------
1180 // Helper function to do a NULL pointer check. Returned value is
1181 // the incoming address with NULL casted away. You are allowed to use the
1182 // not-null value only if you are control dependent on the test.
1183 extern int explicit_null_checks_inserted,
1184 explicit_null_checks_elided;
1185 Node* GraphKit::null_check_common(Node* value, BasicType type,
1186 // optional arguments for variations:
1187 bool assert_null,
1188 Node* *null_control,
1189 bool speculative) {
1190 assert(!assert_null || null_control == NULL, "not both at once");
1191 if (stopped()) return top();
1192 if (!GenerateCompilerNullChecks && !assert_null && null_control == NULL) {
1193 // For some performance testing, we may wish to suppress null checking.
1194 value = cast_not_null(value); // Make it appear to be non-null (4962416).
1195 return value;
1196 }
1197 explicit_null_checks_inserted++;
1198
1199 // Construct NULL check
1200 Node *chk = NULL;
1201 switch(type) {
1202 case T_LONG : chk = new CmpLNode(value, _gvn.zerocon(T_LONG)); break;
1203 case T_INT : chk = new CmpINode(value, _gvn.intcon(0)); break;
1204 case T_ARRAY : // fall through
1205 type = T_OBJECT; // simplify further tests
1206 case T_OBJECT : {
1207 const Type *t = _gvn.type( value );
1208
1209 const TypeOopPtr* tp = t->isa_oopptr();
1210 if (tp != NULL && tp->klass() != NULL && !tp->klass()->is_loaded()
1211 // Only for do_null_check, not any of its siblings:
1212 && !assert_null && null_control == NULL) {
1213 // Usually, any field access or invocation on an unloaded oop type
1214 // will simply fail to link, since the statically linked class is
1215 // likely also to be unloaded. However, in -Xcomp mode, sometimes
1216 // the static class is loaded but the sharper oop type is not.
1217 // Rather than checking for this obscure case in lots of places,
1218 // we simply observe that a null check on an unloaded class
1219 // will always be followed by a nonsense operation, so we
1220 // can just issue the uncommon trap here.
1221 // Our access to the unloaded class will only be correct
1222 // after it has been loaded and initialized, which requires
1223 // a trip through the interpreter.
1230 return top();
1231 }
1232
1233 if (assert_null) {
1234 // See if the type is contained in NULL_PTR.
1235 // If so, then the value is already null.
1236 if (t->higher_equal(TypePtr::NULL_PTR)) {
1237 explicit_null_checks_elided++;
1238 return value; // Elided null assert quickly!
1239 }
1240 } else {
1241 // See if mixing in the NULL pointer changes type.
1242 // If so, then the NULL pointer was not allowed in the original
1243 // type. In other words, "value" was not-null.
1244 if (t->meet(TypePtr::NULL_PTR) != t->remove_speculative()) {
1245 // same as: if (!TypePtr::NULL_PTR->higher_equal(t)) ...
1246 explicit_null_checks_elided++;
1247 return value; // Elided null check quickly!
1248 }
1249 }
1250 chk = new CmpPNode( value, null() );
1251 break;
1252 }
1253
1254 default:
1255 fatal(err_msg_res("unexpected type: %s", type2name(type)));
1256 }
1257 assert(chk != NULL, "sanity check");
1258 chk = _gvn.transform(chk);
1259
1260 BoolTest::mask btest = assert_null ? BoolTest::eq : BoolTest::ne;
1261 BoolNode *btst = new BoolNode( chk, btest);
1262 Node *tst = _gvn.transform( btst );
1263
1264 //-----------
1265 // if peephole optimizations occurred, a prior test existed.
1266 // If a prior test existed, maybe it dominates as we can avoid this test.
1267 if (tst != btst && type == T_OBJECT) {
1268 // At this point we want to scan up the CFG to see if we can
1269 // find an identical test (and so avoid this test altogether).
1270 Node *cfg = control();
1271 int depth = 0;
1272 while( depth < 16 ) { // Limit search depth for speed
1273 if( cfg->Opcode() == Op_IfTrue &&
1274 cfg->in(0)->in(1) == tst ) {
1275 // Found prior test. Use "cast_not_null" to construct an identical
1276 // CastPP (and hence hash to) as already exists for the prior test.
1277 // Return that casted value.
1278 if (assert_null) {
1279 replace_in_map(value, null());
1280 return null(); // do not issue the redundant test
1281 }
1308 // must-be-null assertion has failed. This could cause performance
1309 // problems for a method after its first do_null_assert failure.
1310 // Consider using 'Reason_class_check' instead?
1311
1312 // To cause an implicit null check, we set the not-null probability
1313 // to the maximum (PROB_MAX). For an explicit check the probability
1314 // is set to a smaller value.
1315 if (null_control != NULL || too_many_traps(reason)) {
1316 // probability is less likely
1317 ok_prob = PROB_LIKELY_MAG(3);
1318 } else if (!assert_null &&
1319 (ImplicitNullCheckThreshold > 0) &&
1320 method() != NULL &&
1321 (method()->method_data()->trap_count(reason)
1322 >= (uint)ImplicitNullCheckThreshold)) {
1323 ok_prob = PROB_LIKELY_MAG(3);
1324 }
1325
1326 if (null_control != NULL) {
1327 IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
1328 Node* null_true = _gvn.transform( new IfFalseNode(iff));
1329 set_control( _gvn.transform( new IfTrueNode(iff)));
1330 if (null_true == top())
1331 explicit_null_checks_elided++;
1332 (*null_control) = null_true;
1333 } else {
1334 BuildCutout unless(this, tst, ok_prob);
1335 // Check for optimizer eliding test at parse time
1336 if (stopped()) {
1337 // Failure not possible; do not bother making uncommon trap.
1338 explicit_null_checks_elided++;
1339 } else if (assert_null) {
1340 uncommon_trap(reason,
1341 Deoptimization::Action_make_not_entrant,
1342 NULL, "assert_null");
1343 } else {
1344 replace_in_map(value, zerocon(type));
1345 builtin_throw(reason);
1346 }
1347 }
1348
1349 // Must throw exception, fall-thru not possible?
1361 // (If there is a null_control, a non-null value may come back to haunt us.)
1362 if (type == T_OBJECT) {
1363 Node* cast = cast_not_null(value, false);
1364 if (null_control == NULL || (*null_control) == top())
1365 replace_in_map(value, cast);
1366 value = cast;
1367 }
1368
1369 return value;
1370 }
1371
1372
1373 //------------------------------cast_not_null----------------------------------
1374 // Cast obj to not-null on this path
1375 Node* GraphKit::cast_not_null(Node* obj, bool do_replace_in_map) {
1376 const Type *t = _gvn.type(obj);
1377 const Type *t_not_null = t->join_speculative(TypePtr::NOTNULL);
1378 // Object is already not-null?
1379 if( t == t_not_null ) return obj;
1380
1381 Node *cast = new CastPPNode(obj,t_not_null);
1382 cast->init_req(0, control());
1383 cast = _gvn.transform( cast );
1384
1385 // Scan for instances of 'obj' in the current JVM mapping.
1386 // These instances are known to be not-null after the test.
1387 if (do_replace_in_map)
1388 replace_in_map(obj, cast);
1389
1390 return cast; // Return casted value
1391 }
1392
1393
1394 //--------------------------replace_in_map-------------------------------------
1395 void GraphKit::replace_in_map(Node* old, Node* neww) {
1396 if (old == neww) {
1397 return;
1398 }
1399
1400 map()->replace_edge(old, neww);
1401
1469 return p;
1470 }
1471
1472 //-----------------------------reset_memory------------------------------------
1473 Node* GraphKit::reset_memory() {
1474 Node* mem = map()->memory();
1475 // do not use this node for any more parsing!
1476 debug_only( map()->set_memory((Node*)NULL) );
1477 return _gvn.transform( mem );
1478 }
1479
1480 //------------------------------set_all_memory---------------------------------
1481 void GraphKit::set_all_memory(Node* newmem) {
1482 Node* mergemem = MergeMemNode::make(C, newmem);
1483 gvn().set_type_bottom(mergemem);
1484 map()->set_memory(mergemem);
1485 }
1486
1487 //------------------------------set_all_memory_call----------------------------
1488 void GraphKit::set_all_memory_call(Node* call, bool separate_io_proj) {
1489 Node* newmem = _gvn.transform( new ProjNode(call, TypeFunc::Memory, separate_io_proj) );
1490 set_all_memory(newmem);
1491 }
1492
1493 //=============================================================================
1494 //
1495 // parser factory methods for MemNodes
1496 //
1497 // These are layered on top of the factory methods in LoadNode and StoreNode,
1498 // and integrate with the parser's memory state and _gvn engine.
1499 //
1500
1501 // factory methods in "int adr_idx"
1502 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
1503 int adr_idx,
1504 MemNode::MemOrd mo, bool require_atomic_access) {
1505 assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" );
1506 const TypePtr* adr_type = NULL; // debug-mode-only argument
1507 debug_only(adr_type = C->get_adr_type(adr_idx));
1508 Node* mem = memory(adr_idx);
1509 Node* ld;
1704 intptr_t offset = header + ((intptr_t)idx_con << shift);
1705 return basic_plus_adr(ary, offset);
1706 }
1707
1708 // must be correct type for alignment purposes
1709 Node* base = basic_plus_adr(ary, header);
1710 #ifdef _LP64
1711 // The scaled index operand to AddP must be a clean 64-bit value.
1712 // Java allows a 32-bit int to be incremented to a negative
1713 // value, which appears in a 64-bit register as a large
1714 // positive number. Using that large positive number as an
1715 // operand in pointer arithmetic has bad consequences.
1716 // On the other hand, 32-bit overflow is rare, and the possibility
1717 // can often be excluded, if we annotate the ConvI2L node with
1718 // a type assertion that its value is known to be a small positive
1719 // number. (The prior range check has ensured this.)
1720 // This assertion is used by ConvI2LNode::Ideal.
1721 int index_max = max_jint - 1; // array size is max_jint, index is one less
1722 if (sizetype != NULL) index_max = sizetype->_hi - 1;
1723 const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
1724 idx = _gvn.transform( new ConvI2LNode(idx, lidxtype) );
1725 #endif
1726 Node* scale = _gvn.transform( new LShiftXNode(idx, intcon(shift)) );
1727 return basic_plus_adr(ary, base, scale);
1728 }
1729
1730 //-------------------------load_array_element-------------------------
1731 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) {
1732 const Type* elemtype = arytype->elem();
1733 BasicType elembt = elemtype->array_element_basic_type();
1734 Node* adr = array_element_address(ary, idx, elembt, arytype->size());
1735 Node* ld = make_load(ctl, adr, elemtype, elembt, arytype, MemNode::unordered);
1736 return ld;
1737 }
1738
1739 //-------------------------set_arguments_for_java_call-------------------------
1740 // Arguments (pre-popped from the stack) are taken from the JVMS.
1741 void GraphKit::set_arguments_for_java_call(CallJavaNode* call) {
1742 // Add the call arguments:
1743 uint nargs = call->method()->arg_size();
1744 for (uint i = 0; i < nargs; i++) {
1745 Node* arg = argument(i);
1746 call->init_req(i + TypeFunc::Parms, arg);
1754
1755 // Add the predefined inputs:
1756 call->init_req( TypeFunc::Control, control() );
1757 call->init_req( TypeFunc::I_O , i_o() );
1758 call->init_req( TypeFunc::Memory , reset_memory() );
1759 call->init_req( TypeFunc::FramePtr, frameptr() );
1760 call->init_req( TypeFunc::ReturnAdr, top() );
1761
1762 add_safepoint_edges(call, must_throw);
1763
1764 Node* xcall = _gvn.transform(call);
1765
1766 if (xcall == top()) {
1767 set_control(top());
1768 return;
1769 }
1770 assert(xcall == call, "call identity is stable");
1771
1772 // Re-use the current map to produce the result.
1773
1774 set_control(_gvn.transform(new ProjNode(call, TypeFunc::Control)));
1775 set_i_o( _gvn.transform(new ProjNode(call, TypeFunc::I_O , separate_io_proj)));
1776 set_all_memory_call(xcall, separate_io_proj);
1777
1778 //return xcall; // no need, caller already has it
1779 }
1780
1781 Node* GraphKit::set_results_for_java_call(CallJavaNode* call, bool separate_io_proj) {
1782 if (stopped()) return top(); // maybe the call folded up?
1783
1784 // Capture the return value, if any.
1785 Node* ret;
1786 if (call->method() == NULL ||
1787 call->method()->return_type()->basic_type() == T_VOID)
1788 ret = top();
1789 else ret = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
1790
1791 // Note: Since any out-of-line call can produce an exception,
1792 // we always insert an I_O projection from the call into the result.
1793
1794 make_slow_call_ex(call, env()->Throwable_klass(), separate_io_proj);
1795
1796 if (separate_io_proj) {
1797 // The caller requested separate projections be used by the fall
1798 // through and exceptional paths, so replace the projections for
1799 // the fall through path.
1800 set_i_o(_gvn.transform( new ProjNode(call, TypeFunc::I_O) ));
1801 set_all_memory(_gvn.transform( new ProjNode(call, TypeFunc::Memory) ));
1802 }
1803 return ret;
1804 }
1805
1806 //--------------------set_predefined_input_for_runtime_call--------------------
1807 // Reading and setting the memory state is way conservative here.
1808 // The real problem is that I am not doing real Type analysis on memory,
1809 // so I cannot distinguish card mark stores from other stores. Across a GC
1810 // point the Store Barrier and the card mark memory has to agree. I cannot
1811 // have a card mark store and its barrier split across the GC point from
1812 // either above or below. Here I get that to happen by reading ALL of memory.
1813 // A better answer would be to separate out card marks from other memory.
1814 // For now, return the input memory state, so that it can be reused
1815 // after the call, if this call has restricted memory effects.
1816 Node* GraphKit::set_predefined_input_for_runtime_call(SafePointNode* call) {
1817 // Set fixed predefined input arguments
1818 Node* memory = reset_memory();
1819 call->init_req( TypeFunc::Control, control() );
1820 call->init_req( TypeFunc::I_O, top() ); // does no i/o
1821 call->init_req( TypeFunc::Memory, memory ); // may gc ptrs
1822 call->init_req( TypeFunc::FramePtr, frameptr() );
1823 call->init_req( TypeFunc::ReturnAdr, top() );
1824 return memory;
1825 }
1826
1827 //-------------------set_predefined_output_for_runtime_call--------------------
1828 // Set control and memory (not i_o) from the call.
1829 // If keep_mem is not NULL, use it for the output state,
1830 // except for the RawPtr output of the call, if hook_mem is TypeRawPtr::BOTTOM.
1831 // If hook_mem is NULL, this call produces no memory effects at all.
1832 // If hook_mem is a Java-visible memory slice (such as arraycopy operands),
1833 // then only that memory slice is taken from the call.
1834 // In the last case, we must put an appropriate memory barrier before
1835 // the call, so as to create the correct anti-dependencies on loads
1836 // preceding the call.
1837 void GraphKit::set_predefined_output_for_runtime_call(Node* call,
1838 Node* keep_mem,
1839 const TypePtr* hook_mem) {
1840 // no i/o
1841 set_control(_gvn.transform( new ProjNode(call,TypeFunc::Control) ));
1842 if (keep_mem) {
1843 // First clone the existing memory state
1844 set_all_memory(keep_mem);
1845 if (hook_mem != NULL) {
1846 // Make memory for the call
1847 Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
1848 // Set the RawPtr memory state only. This covers all the heap top/GC stuff
1849 // We also use hook_mem to extract specific effects from arraycopy stubs.
1850 set_memory(mem, hook_mem);
1851 }
1852 // ...else the call has NO memory effects.
1853
1854 // Make sure the call advertises its memory effects precisely.
1855 // This lets us build accurate anti-dependences in gcm.cpp.
1856 assert(C->alias_type(call->adr_type()) == C->alias_type(hook_mem),
1857 "call node must be constructed correctly");
1858 } else {
1859 assert(hook_mem == NULL, "");
1860 // This is not a "slow path" call; all memory comes from the call.
1861 set_all_memory_call(call);
1862 }
1863 }
1864
1865
1866 // Replace the call with the current state of the kit.
1867 void GraphKit::replace_call(CallNode* call, Node* result) {
1951 }
1952 while (wl.size() > 0) {
1953 _gvn.transform(wl.pop());
1954 }
1955 }
1956 }
1957
1958
1959 //------------------------------increment_counter------------------------------
1960 // for statistics: increment a VM counter by 1
1961
1962 void GraphKit::increment_counter(address counter_addr) {
1963 Node* adr1 = makecon(TypeRawPtr::make(counter_addr));
1964 increment_counter(adr1);
1965 }
1966
1967 void GraphKit::increment_counter(Node* counter_addr) {
1968 int adr_type = Compile::AliasIdxRaw;
1969 Node* ctrl = control();
1970 Node* cnt = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
1971 Node* incr = _gvn.transform(new AddINode(cnt, _gvn.intcon(1)));
1972 store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
1973 }
1974
1975
1976 //------------------------------uncommon_trap----------------------------------
1977 // Bail out to the interpreter in mid-method. Implemented by calling the
1978 // uncommon_trap blob. This helper function inserts a runtime call with the
1979 // right debug info.
1980 void GraphKit::uncommon_trap(int trap_request,
1981 ciKlass* klass, const char* comment,
1982 bool must_throw,
1983 bool keep_exact_action) {
1984 if (failing()) stop();
1985 if (stopped()) return; // trap reachable?
1986
1987 // Note: If ProfileTraps is true, and if a deopt. actually
1988 // occurs here, the runtime will make sure an MDO exists. There is
1989 // no need to call method()->ensure_method_data() at this point.
1990
1991 // Set the stack pointer to the right value for reexecution:
2070 // Clear out dead values from the debug info.
2071 kill_dead_locals();
2072
2073 // Now insert the uncommon trap subroutine call
2074 address call_addr = SharedRuntime::uncommon_trap_blob()->entry_point();
2075 const TypePtr* no_memory_effects = NULL;
2076 // Pass the index of the class to be loaded
2077 Node* call = make_runtime_call(RC_NO_LEAF | RC_UNCOMMON |
2078 (must_throw ? RC_MUST_THROW : 0),
2079 OptoRuntime::uncommon_trap_Type(),
2080 call_addr, "uncommon_trap", no_memory_effects,
2081 intcon(trap_request));
2082 assert(call->as_CallStaticJava()->uncommon_trap_request() == trap_request,
2083 "must extract request correctly from the graph");
2084 assert(trap_request != 0, "zero value reserved by uncommon_trap_request");
2085
2086 call->set_req(TypeFunc::ReturnAdr, returnadr());
2087 // The debug info is the only real input to this call.
2088
2089 // Halt-and-catch fire here. The above call should never return!
2090 HaltNode* halt = new HaltNode(control(), frameptr());
2091 _gvn.set_type_bottom(halt);
2092 root()->add_req(halt);
2093
2094 stop_and_kill_map();
2095 }
2096
2097
2098 //--------------------------just_allocated_object------------------------------
2099 // Report the object that was just allocated.
2100 // It must be the case that there are no intervening safepoints.
2101 // We use this to determine if an object is so "fresh" that
2102 // it does not require card marks.
2103 Node* GraphKit::just_allocated_object(Node* current_control) {
2104 if (C->recent_alloc_ctl() == current_control)
2105 return C->recent_alloc_obj();
2106 return NULL;
2107 }
2108
2109
2110 void GraphKit::round_double_arguments(ciMethod* dest_method) {
2152 } else if (current_type->would_improve_ptr(maybe_null)) {
2153 // Profiling report that null was never seen so we can change the
2154 // speculative type to non null ptr.
2155 assert(!maybe_null, "nothing to improve");
2156 if (speculative == NULL) {
2157 speculative = TypePtr::NOTNULL;
2158 } else {
2159 const TypePtr* ptr = TypePtr::NOTNULL;
2160 speculative = speculative->cast_to_ptr_type(ptr->ptr())->is_ptr();
2161 }
2162 }
2163
2164 if (speculative != current_type->speculative()) {
2165 // Build a type with a speculative type (what we think we know
2166 // about the type but will need a guard when we use it)
2167 const TypeOopPtr* spec_type = TypeOopPtr::make(TypePtr::BotPTR, Type::OffsetBot, TypeOopPtr::InstanceBot, speculative);
2168 // We're changing the type, we need a new CheckCast node to carry
2169 // the new type. The new type depends on the control: what
2170 // profiling tells us is only valid from here as far as we can
2171 // tell.
2172 Node* cast = new CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
2173 cast = _gvn.transform(cast);
2174 replace_in_map(n, cast);
2175 n = cast;
2176 }
2177
2178 return n;
2179 }
2180
2181 /**
2182 * Record profiling data from receiver profiling at an invoke with the
2183 * type system so that it can propagate it (speculation)
2184 *
2185 * @param n receiver node
2186 *
2187 * @return node with improved type
2188 */
2189 Node* GraphKit::record_profiled_receiver_for_speculation(Node* n) {
2190 if (!UseTypeSpeculation) {
2191 return n;
2192 }
2270 void GraphKit::round_double_result(ciMethod* dest_method) {
2271 // A non-strict method may return a double value which has an extended
2272 // exponent, but this must not be visible in a caller which is 'strict'
2273 // If a strict caller invokes a non-strict callee, round a double result
2274
2275 BasicType result_type = dest_method->return_type()->basic_type();
2276 assert( method() != NULL, "must have caller context");
2277 if( result_type == T_DOUBLE && method()->is_strict() && !dest_method->is_strict() ) {
2278 // Destination method's return value is on top of stack
2279 // dstore_rounding() does gvn.transform
2280 Node *result = pop_pair();
2281 result = dstore_rounding(result);
2282 push_pair(result);
2283 }
2284 }
2285
2286 // rounding for strict float precision conformance
2287 Node* GraphKit::precision_rounding(Node* n) {
2288 return UseStrictFP && _method->flags().is_strict()
2289 && UseSSE == 0 && Matcher::strict_fp_requires_explicit_rounding
2290 ? _gvn.transform( new RoundFloatNode(0, n) )
2291 : n;
2292 }
2293
2294 // rounding for strict double precision conformance
2295 Node* GraphKit::dprecision_rounding(Node *n) {
2296 return UseStrictFP && _method->flags().is_strict()
2297 && UseSSE <= 1 && Matcher::strict_fp_requires_explicit_rounding
2298 ? _gvn.transform( new RoundDoubleNode(0, n) )
2299 : n;
2300 }
2301
2302 // rounding for non-strict double stores
2303 Node* GraphKit::dstore_rounding(Node* n) {
2304 return Matcher::strict_fp_requires_explicit_rounding
2305 && UseSSE <= 1
2306 ? _gvn.transform( new RoundDoubleNode(0, n) )
2307 : n;
2308 }
2309
2310 //=============================================================================
2311 // Generate a fast path/slow path idiom. Graph looks like:
2312 // [foo] indicates that 'foo' is a parameter
2313 //
2314 // [in] NULL
2315 // \ /
2316 // CmpP
2317 // Bool ne
2318 // If
2319 // / \
2320 // True False-<2>
2321 // / |
2322 // / cast_not_null
2323 // Load | | ^
2324 // [fast_test] | |
2325 // gvn to opt_test | |
2326 // / \ | <1>
2365 Deoptimization::DeoptReason reason = Deoptimization::reason_null_check(speculative);
2366 uncommon_trap(reason,
2367 Deoptimization::Action_make_not_entrant);
2368 (*null_control) = top(); // NULL path is dead
2369 }
2370 if ((*null_control) == top() && safe_for_replace) {
2371 replace_in_map(value, cast);
2372 }
2373
2374 // Cast away null-ness on the result
2375 return cast;
2376 }
2377
2378 //------------------------------opt_iff----------------------------------------
2379 // Optimize the fast-check IfNode. Set the fast-path region slot 2.
2380 // Return slow-path control.
2381 Node* GraphKit::opt_iff(Node* region, Node* iff) {
2382 IfNode *opt_iff = _gvn.transform(iff)->as_If();
2383
2384 // Fast path taken; set region slot 2
2385 Node *fast_taken = _gvn.transform( new IfFalseNode(opt_iff) );
2386 region->init_req(2,fast_taken); // Capture fast-control
2387
2388 // Fast path not-taken, i.e. slow path
2389 Node *slow_taken = _gvn.transform( new IfTrueNode(opt_iff) );
2390 return slow_taken;
2391 }
2392
2393 //-----------------------------make_runtime_call-------------------------------
2394 Node* GraphKit::make_runtime_call(int flags,
2395 const TypeFunc* call_type, address call_addr,
2396 const char* call_name,
2397 const TypePtr* adr_type,
2398 // The following parms are all optional.
2399 // The first NULL ends the list.
2400 Node* parm0, Node* parm1,
2401 Node* parm2, Node* parm3,
2402 Node* parm4, Node* parm5,
2403 Node* parm6, Node* parm7) {
2404 // Slow-path call
2405 bool is_leaf = !(flags & RC_NO_LEAF);
2406 bool has_io = (!is_leaf && !(flags & RC_NO_IO));
2407 if (call_name == NULL) {
2408 assert(!is_leaf, "must supply name for leaf");
2409 call_name = OptoRuntime::stub_name(call_addr);
2410 }
2411 CallNode* call;
2412 if (!is_leaf) {
2413 call = new CallStaticJavaNode(call_type, call_addr, call_name,
2414 bci(), adr_type);
2415 } else if (flags & RC_NO_FP) {
2416 call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
2417 } else {
2418 call = new CallLeafNode(call_type, call_addr, call_name, adr_type);
2419 }
2420
2421 // The following is similar to set_edges_for_java_call,
2422 // except that the memory effects of the call are restricted to AliasIdxRaw.
2423
2424 // Slow path call has no side-effects, uses few values
2425 bool wide_in = !(flags & RC_NARROW_MEM);
2426 bool wide_out = (C->get_alias_index(adr_type) == Compile::AliasIdxBot);
2427
2428 Node* prev_mem = NULL;
2429 if (wide_in) {
2430 prev_mem = set_predefined_input_for_runtime_call(call);
2431 } else {
2432 assert(!wide_out, "narrow in => narrow out");
2433 Node* narrow_mem = memory(adr_type);
2434 prev_mem = reset_memory();
2435 map()->set_memory(narrow_mem);
2436 set_predefined_input_for_runtime_call(call);
2437 }
2438
2459
2460 if (flags & RC_UNCOMMON) {
2461 // Set the count to a tiny probability. Cf. Estimate_Block_Frequency.
2462 // (An "if" probability corresponds roughly to an unconditional count.
2463 // Sort of.)
2464 call->set_cnt(PROB_UNLIKELY_MAG(4));
2465 }
2466
2467 Node* c = _gvn.transform(call);
2468 assert(c == call, "cannot disappear");
2469
2470 if (wide_out) {
2471 // Slow path call has full side-effects.
2472 set_predefined_output_for_runtime_call(call);
2473 } else {
2474 // Slow path call has few side-effects, and/or sets few values.
2475 set_predefined_output_for_runtime_call(call, prev_mem, adr_type);
2476 }
2477
2478 if (has_io) {
2479 set_i_o(_gvn.transform(new ProjNode(call, TypeFunc::I_O)));
2480 }
2481 return call;
2482
2483 }
2484
2485 //------------------------------merge_memory-----------------------------------
2486 // Merge memory from one path into the current memory state.
2487 void GraphKit::merge_memory(Node* new_mem, Node* region, int new_path) {
2488 for (MergeMemStream mms(merged_memory(), new_mem->as_MergeMem()); mms.next_non_empty2(); ) {
2489 Node* old_slice = mms.force_memory();
2490 Node* new_slice = mms.memory2();
2491 if (old_slice != new_slice) {
2492 PhiNode* phi;
2493 if (new_slice->is_Phi() && new_slice->as_Phi()->region() == region) {
2494 phi = new_slice->as_Phi();
2495 #ifdef ASSERT
2496 if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region)
2497 old_slice = old_slice->in(new_path);
2498 // Caller is responsible for ensuring that any pre-existing
2499 // phis are already aware of old memory.
2500 int old_path = (new_path > 1) ? 1 : 2; // choose old_path != new_path
2501 assert(phi->in(old_path) == old_slice, "pre-existing phis OK");
2502 #endif
2503 mms.set_memory(phi);
2504 } else {
2505 phi = PhiNode::make(region, old_slice, Type::MEMORY, mms.adr_type(C));
2506 _gvn.set_type(phi, Type::MEMORY);
2507 phi->set_req(new_path, new_slice);
2508 mms.set_memory(_gvn.transform(phi)); // assume it is complete
2509 }
2510 }
2511 }
2512 }
2513
2514 //------------------------------make_slow_call_ex------------------------------
2515 // Make the exception handler hookups for the slow call
2516 void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj) {
2517 if (stopped()) return;
2518
2519 // Make a catch node with just two handlers: fall-through and catch-all
2520 Node* i_o = _gvn.transform( new ProjNode(call, TypeFunc::I_O, separate_io_proj) );
2521 Node* catc = _gvn.transform( new CatchNode(control(), i_o, 2) );
2522 Node* norm = _gvn.transform( new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
2523 Node* excp = _gvn.transform( new CatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) );
2524
2525 { PreserveJVMState pjvms(this);
2526 set_control(excp);
2527 set_i_o(i_o);
2528
2529 if (excp != top()) {
2530 // Create an exception state also.
2531 // Use an exact type if the caller has specified a specific exception.
2532 const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
2533 Node* ex_oop = new CreateExNode(ex_type, control(), i_o);
2534 add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
2535 }
2536 }
2537
2538 // Get the no-exception control from the CatchNode.
2539 set_control(norm);
2540 }
2541
2542
2543 //-------------------------------gen_subtype_check-----------------------------
2544 // Generate a subtyping check. Takes as input the subtype and supertype.
2545 // Returns 2 values: sets the default control() to the true path and returns
2546 // the false path. Only reads invariant memory; sets no (visible) memory.
2547 // The PartialSubtypeCheckNode sets the hidden 1-word cache in the encoding
2548 // but that's not exposed to the optimizer. This call also doesn't take in an
2549 // Object; if you wish to check an Object you need to load the Object's class
2550 // prior to coming here.
2551 Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
2552 // Fast check for identical types, perhaps identical constants.
2553 // The types can even be identical non-constants, in cases
2563 // test before generating code. You may ask, why not just generate
2564 // the code and then let it fold up? The answer is that the generated
2565 // code will necessarily include null checks, which do not always
2566 // completely fold away. If they are also needless, then they turn
2567 // into a performance loss. Example:
2568 // Foo[] fa = blah(); Foo x = fa[0]; fa[1] = x;
2569 // Here, the type of 'fa' is often exact, so the store check
2570 // of fa[1]=x will fold up, without testing the nullness of x.
2571 switch (static_subtype_check(superk, subk)) {
2572 case SSC_always_false:
2573 {
2574 Node* always_fail = control();
2575 set_control(top());
2576 return always_fail;
2577 }
2578 case SSC_always_true:
2579 return top();
2580 case SSC_easy_test:
2581 {
2582 // Just do a direct pointer compare and be done.
2583 Node* cmp = _gvn.transform( new CmpPNode(subklass, superklass) );
2584 Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
2585 IfNode* iff = create_and_xform_if(control(), bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
2586 set_control( _gvn.transform( new IfTrueNode (iff) ) );
2587 return _gvn.transform( new IfFalseNode(iff) );
2588 }
2589 case SSC_full_test:
2590 break;
2591 default:
2592 ShouldNotReachHere();
2593 }
2594 }
2595
2596 // %%% Possible further optimization: Even if the superklass is not exact,
2597 // if the subklass is the unique subtype of the superklass, the check
2598 // will always succeed. We could leave a dependency behind to ensure this.
2599
2600 // First load the super-klass's check-offset
2601 Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
2602 Node *chk_off = _gvn.transform(new LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
2603 TypeInt::INT, MemNode::unordered));
2604 int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
2605 bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
2606
2607 // Load from the sub-klass's super-class display list, or a 1-word cache of
2608 // the secondary superclass list, or a failing value with a sentinel offset
2609 // if the super-klass is an interface or exceptionally deep in the Java
2610 // hierarchy and we have to scan the secondary superclass list the hard way.
2611 // Worst-case type is a little odd: NULL is allowed as a result (usually
2612 // klass loads can never produce a NULL).
2613 Node *chk_off_X = ConvI2X(chk_off);
2614 Node *p2 = _gvn.transform( new AddPNode(subklass,subklass,chk_off_X) );
2615 // For some types like interfaces the following loadKlass is from a 1-word
2616 // cache which is mutable so can't use immutable memory. Other
2617 // types load from the super-class display table which is immutable.
2618 Node *kmem = might_be_cache ? memory(p2) : immutable_memory();
2619 Node *nkls = _gvn.transform( LoadKlassNode::make( _gvn, kmem, p2, _gvn.type(p2)->is_ptr(), TypeKlassPtr::OBJECT_OR_NULL ) );
2620
2621 // Compile speed common case: ARE a subtype and we canNOT fail
2622 if( superklass == nkls )
2623 return top(); // false path is dead; no test needed.
2624
2625 // See if we get an immediate positive hit. Happens roughly 83% of the
2626 // time. Test to see if the value loaded just previously from the subklass
2627 // is exactly the superklass.
2628 Node *cmp1 = _gvn.transform( new CmpPNode( superklass, nkls ) );
2629 Node *bol1 = _gvn.transform( new BoolNode( cmp1, BoolTest::eq ) );
2630 IfNode *iff1 = create_and_xform_if( control(), bol1, PROB_LIKELY(0.83f), COUNT_UNKNOWN );
2631 Node *iftrue1 = _gvn.transform( new IfTrueNode ( iff1 ) );
2632 set_control( _gvn.transform( new IfFalseNode( iff1 ) ) );
2633
2634 // Compile speed common case: Check for being deterministic right now. If
2635 // chk_off is a constant and not equal to cacheoff then we are NOT a
2636 // subklass. In this case we need exactly the 1 test above and we can
2637 // return those results immediately.
2638 if (!might_be_cache) {
2639 Node* not_subtype_ctrl = control();
2640 set_control(iftrue1); // We need exactly the 1 test above
2641 return not_subtype_ctrl;
2642 }
2643
2644 // Gather the various success & failures here
2645 RegionNode *r_ok_subtype = new RegionNode(4);
2646 record_for_igvn(r_ok_subtype);
2647 RegionNode *r_not_subtype = new RegionNode(3);
2648 record_for_igvn(r_not_subtype);
2649
2650 r_ok_subtype->init_req(1, iftrue1);
2651
2652 // Check for immediate negative hit. Happens roughly 11% of the time (which
2653 // is roughly 63% of the remaining cases). Test to see if the loaded
2654 // check-offset points into the subklass display list or the 1-element
2655 // cache. If it points to the display (and NOT the cache) and the display
2656 // missed then it's not a subtype.
2657 Node *cacheoff = _gvn.intcon(cacheoff_con);
2658 Node *cmp2 = _gvn.transform( new CmpINode( chk_off, cacheoff ) );
2659 Node *bol2 = _gvn.transform( new BoolNode( cmp2, BoolTest::ne ) );
2660 IfNode *iff2 = create_and_xform_if( control(), bol2, PROB_LIKELY(0.63f), COUNT_UNKNOWN );
2661 r_not_subtype->init_req(1, _gvn.transform( new IfTrueNode (iff2) ) );
2662 set_control( _gvn.transform( new IfFalseNode(iff2) ) );
2663
2664 // Check for self. Very rare to get here, but it is taken 1/3 the time.
2665 // No performance impact (too rare) but allows sharing of secondary arrays
2666 // which has some footprint reduction.
2667 Node *cmp3 = _gvn.transform( new CmpPNode( subklass, superklass ) );
2668 Node *bol3 = _gvn.transform( new BoolNode( cmp3, BoolTest::eq ) );
2669 IfNode *iff3 = create_and_xform_if( control(), bol3, PROB_LIKELY(0.36f), COUNT_UNKNOWN );
2670 r_ok_subtype->init_req(2, _gvn.transform( new IfTrueNode ( iff3 ) ) );
2671 set_control( _gvn.transform( new IfFalseNode( iff3 ) ) );
2672
2673 // -- Roads not taken here: --
2674 // We could also have chosen to perform the self-check at the beginning
2675 // of this code sequence, as the assembler does. This would not pay off
2676 // the same way, since the optimizer, unlike the assembler, can perform
2677 // static type analysis to fold away many successful self-checks.
2678 // Non-foldable self checks work better here in second position, because
2679 // the initial primary superclass check subsumes a self-check for most
2680 // types. An exception would be a secondary type like array-of-interface,
2681 // which does not appear in its own primary supertype display.
2682 // Finally, we could have chosen to move the self-check into the
2683 // PartialSubtypeCheckNode, and from there out-of-line in a platform
2684 // dependent manner. But it is worthwhile to have the check here,
2685 // where it can be perhaps be optimized. The cost in code space is
2686 // small (register compare, branch).
2687
2688 // Now do a linear scan of the secondary super-klass array. Again, no real
2689 // performance impact (too rare) but it's gotta be done.
2690 // Since the code is rarely used, there is no penalty for moving it
2691 // out of line, and it can only improve I-cache density.
2692 // The decision to inline or out-of-line this final check is platform
2693 // dependent, and is found in the AD file definition of PartialSubtypeCheck.
2694 Node* psc = _gvn.transform(
2695 new PartialSubtypeCheckNode(control(), subklass, superklass) );
2696
2697 Node *cmp4 = _gvn.transform( new CmpPNode( psc, null() ) );
2698 Node *bol4 = _gvn.transform( new BoolNode( cmp4, BoolTest::ne ) );
2699 IfNode *iff4 = create_and_xform_if( control(), bol4, PROB_FAIR, COUNT_UNKNOWN );
2700 r_not_subtype->init_req(2, _gvn.transform( new IfTrueNode (iff4) ) );
2701 r_ok_subtype ->init_req(3, _gvn.transform( new IfFalseNode(iff4) ) );
2702
2703 // Return false path; set default control to true path.
2704 set_control( _gvn.transform(r_ok_subtype) );
2705 return _gvn.transform(r_not_subtype);
2706 }
2707
2708 //----------------------------static_subtype_check-----------------------------
2709 // Shortcut important common cases when superklass is exact:
2710 // (0) superklass is java.lang.Object (can occur in reflective code)
2711 // (1) subklass is already limited to a subtype of superklass => always ok
2712 // (2) subklass does not overlap with superklass => always fail
2713 // (3) superklass has NO subtypes and we can check with a simple compare.
2714 int GraphKit::static_subtype_check(ciKlass* superk, ciKlass* subk) {
2715 if (StressReflectiveCode) {
2716 return SSC_full_test; // Let caller generate the general case.
2717 }
2718
2719 if (superk == env()->Object_klass()) {
2720 return SSC_always_true; // (0) this test cannot fail
2721 }
2745 // Add a dependency if there is a chance of a later subclass.
2746 C->dependencies()->assert_leaf_type(ik);
2747 }
2748 return SSC_easy_test; // (3) caller can do a simple ptr comparison
2749 }
2750 } else {
2751 // A primitive array type has no subtypes.
2752 return SSC_easy_test; // (3) caller can do a simple ptr comparison
2753 }
2754
2755 return SSC_full_test;
2756 }
2757
2758 // Profile-driven exact type check:
2759 Node* GraphKit::type_check_receiver(Node* receiver, ciKlass* klass,
2760 float prob,
2761 Node* *casted_receiver) {
2762 const TypeKlassPtr* tklass = TypeKlassPtr::make(klass);
2763 Node* recv_klass = load_object_klass(receiver);
2764 Node* want_klass = makecon(tklass);
2765 Node* cmp = _gvn.transform( new CmpPNode(recv_klass, want_klass) );
2766 Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
2767 IfNode* iff = create_and_xform_if(control(), bol, prob, COUNT_UNKNOWN);
2768 set_control( _gvn.transform( new IfTrueNode (iff) ));
2769 Node* fail = _gvn.transform( new IfFalseNode(iff) );
2770
2771 const TypeOopPtr* recv_xtype = tklass->as_instance_type();
2772 assert(recv_xtype->klass_is_exact(), "");
2773
2774 // Subsume downstream occurrences of receiver with a cast to
2775 // recv_xtype, since now we know what the type will be.
2776 Node* cast = new CheckCastPPNode(control(), receiver, recv_xtype);
2777 (*casted_receiver) = _gvn.transform(cast);
2778 // (User must make the replace_in_map call.)
2779
2780 return fail;
2781 }
2782
2783
2784 //------------------------------seems_never_null-------------------------------
2785 // Use null_seen information if it is available from the profile.
2786 // If we see an unexpected null at a type check we record it and force a
2787 // recompile; the offending check will be recompiled to handle NULLs.
2788 // If we see several offending BCIs, then all checks in the
2789 // method will be recompiled.
2790 bool GraphKit::seems_never_null(Node* obj, ciProfileData* data, bool& speculating) {
2791 speculating = !_gvn.type(obj)->speculative_maybe_null();
2792 Deoptimization::DeoptReason reason = Deoptimization::reason_null_check(speculating);
2793 if (UncommonNullCast // Cutout for this technique
2794 && obj != null() // And not the -Xcomp stupid case?
2795 && !too_many_traps(reason)
2796 ) {
2903 if (!too_many_traps(Deoptimization::Reason_null_assert)) {
2904 Node* exact_obj = null_assert(obj);
2905 replace_in_map(obj, exact_obj);
2906 obj = exact_obj;
2907 }
2908 }
2909 return obj;
2910 }
2911
2912 //-------------------------------gen_instanceof--------------------------------
2913 // Generate an instance-of idiom. Used by both the instance-of bytecode
2914 // and the reflective instance-of call.
2915 Node* GraphKit::gen_instanceof(Node* obj, Node* superklass, bool safe_for_replace) {
2916 kill_dead_locals(); // Benefit all the uncommon traps
2917 assert( !stopped(), "dead parse path should be checked in callers" );
2918 assert(!TypePtr::NULL_PTR->higher_equal(_gvn.type(superklass)->is_klassptr()),
2919 "must check for not-null not-dead klass in callers");
2920
2921 // Make the merge point
2922 enum { _obj_path = 1, _fail_path, _null_path, PATH_LIMIT };
2923 RegionNode* region = new RegionNode(PATH_LIMIT);
2924 Node* phi = new PhiNode(region, TypeInt::BOOL);
2925 C->set_has_split_ifs(true); // Has chance for split-if optimization
2926
2927 ciProfileData* data = NULL;
2928 if (java_bc() == Bytecodes::_instanceof) { // Only for the bytecode
2929 data = method()->method_data()->bci_to_data(bci());
2930 }
2931 bool speculative_not_null = false;
2932 bool never_see_null = (ProfileDynamicTypes // aggressive use of profile
2933 && seems_never_null(obj, data, speculative_not_null));
2934
2935 // Null check; get casted pointer; set region slot 3
2936 Node* null_ctl = top();
2937 Node* not_null_obj = null_check_oop(obj, &null_ctl, never_see_null, safe_for_replace, speculative_not_null);
2938
2939 // If not_null_obj is dead, only null-path is taken
2940 if (stopped()) { // Doing instance-of on a NULL?
2941 set_control(null_ctl);
2942 return intcon(0);
2943 }
2944 region->init_req(_null_path, null_ctl);
3035 case SSC_always_false:
3036 // It needs a null check because a null will *pass* the cast check.
3037 // A non-null value will always produce an exception.
3038 return null_assert(obj);
3039 }
3040 }
3041 }
3042
3043 ciProfileData* data = NULL;
3044 bool safe_for_replace = false;
3045 if (failure_control == NULL) { // use MDO in regular case only
3046 assert(java_bc() == Bytecodes::_aastore ||
3047 java_bc() == Bytecodes::_checkcast,
3048 "interpreter profiles type checks only for these BCs");
3049 data = method()->method_data()->bci_to_data(bci());
3050 safe_for_replace = true;
3051 }
3052
3053 // Make the merge point
3054 enum { _obj_path = 1, _null_path, PATH_LIMIT };
3055 RegionNode* region = new RegionNode(PATH_LIMIT);
3056 Node* phi = new PhiNode(region, toop);
3057 C->set_has_split_ifs(true); // Has chance for split-if optimization
3058
3059 // Use null-cast information if it is available
3060 bool speculative_not_null = false;
3061 bool never_see_null = ((failure_control == NULL) // regular case only
3062 && seems_never_null(obj, data, speculative_not_null));
3063
3064 // Null check; get casted pointer; set region slot 3
3065 Node* null_ctl = top();
3066 Node* not_null_obj = null_check_oop(obj, &null_ctl, never_see_null, safe_for_replace, speculative_not_null);
3067
3068 // If not_null_obj is dead, only null-path is taken
3069 if (stopped()) { // Doing instance-of on a NULL?
3070 set_control(null_ctl);
3071 return null();
3072 }
3073 region->init_req(_null_path, null_ctl);
3074 phi ->init_req(_null_path, null()); // Set null path value
3075 if (null_ctl == top()) {
3076 // Do this eagerly, so that pattern matches like is_diamond_phi
3097 // all casts inserted by javac to implement generic types.
3098 data->as_CounterData()->count() >= 0)) {
3099 cast_obj = maybe_cast_profiled_receiver(not_null_obj, tk->klass(), spec_obj_type, safe_for_replace);
3100 if (cast_obj != NULL) {
3101 if (failure_control != NULL) // failure is now impossible
3102 (*failure_control) = top();
3103 // adjust the type of the phi to the exact klass:
3104 phi->raise_bottom_type(_gvn.type(cast_obj)->meet_speculative(TypePtr::NULL_PTR));
3105 }
3106 }
3107 }
3108
3109 if (cast_obj == NULL) {
3110 // Load the object's klass
3111 Node* obj_klass = load_object_klass(not_null_obj);
3112
3113 // Generate the subtype check
3114 Node* not_subtype_ctrl = gen_subtype_check( obj_klass, superklass );
3115
3116 // Plug in success path into the merge
3117 cast_obj = _gvn.transform(new CheckCastPPNode(control(), not_null_obj, toop));
3118 // Failure path ends in uncommon trap (or may be dead - failure impossible)
3119 if (failure_control == NULL) {
3120 if (not_subtype_ctrl != top()) { // If failure is possible
3121 PreserveJVMState pjvms(this);
3122 set_control(not_subtype_ctrl);
3123 builtin_throw(Deoptimization::Reason_class_check, obj_klass);
3124 }
3125 } else {
3126 (*failure_control) = not_subtype_ctrl;
3127 }
3128 }
3129
3130 region->init_req(_obj_path, control());
3131 phi ->init_req(_obj_path, cast_obj);
3132
3133 // A merge of NULL or Casted-NotNull obj
3134 Node* res = _gvn.transform(phi);
3135
3136 // Note I do NOT always 'replace_in_map(obj,result)' here.
3137 // if( tk->klass()->can_be_primary_super() )
3150 }
3151
3152 //------------------------------next_monitor-----------------------------------
3153 // What number should be given to the next monitor?
3154 int GraphKit::next_monitor() {
3155 int current = jvms()->monitor_depth()* C->sync_stack_slots();
3156 int next = current + C->sync_stack_slots();
3157 // Keep the toplevel high water mark current:
3158 if (C->fixed_slots() < next) C->set_fixed_slots(next);
3159 return current;
3160 }
3161
3162 //------------------------------insert_mem_bar---------------------------------
3163 // Memory barrier to avoid floating things around
3164 // The membar serves as a pinch point between both control and all memory slices.
3165 Node* GraphKit::insert_mem_bar(int opcode, Node* precedent) {
3166 MemBarNode* mb = MemBarNode::make(C, opcode, Compile::AliasIdxBot, precedent);
3167 mb->init_req(TypeFunc::Control, control());
3168 mb->init_req(TypeFunc::Memory, reset_memory());
3169 Node* membar = _gvn.transform(mb);
3170 set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
3171 set_all_memory_call(membar);
3172 return membar;
3173 }
3174
3175 //-------------------------insert_mem_bar_volatile----------------------------
3176 // Memory barrier to avoid floating things around
3177 // The membar serves as a pinch point between both control and memory(alias_idx).
3178 // If you want to make a pinch point on all memory slices, do not use this
3179 // function (even with AliasIdxBot); use insert_mem_bar() instead.
3180 Node* GraphKit::insert_mem_bar_volatile(int opcode, int alias_idx, Node* precedent) {
3181 // When Parse::do_put_xxx updates a volatile field, it appends a series
3182 // of MemBarVolatile nodes, one for *each* volatile field alias category.
3183 // The first membar is on the same memory slice as the field store opcode.
3184 // This forces the membar to follow the store. (Bug 6500685 broke this.)
3185 // All the other membars (for other volatile slices, including AliasIdxBot,
3186 // which stands for all unknown volatile slices) are control-dependent
3187 // on the first membar. This prevents later volatile loads or stores
3188 // from sliding up past the just-emitted store.
3189
3190 MemBarNode* mb = MemBarNode::make(C, opcode, alias_idx, precedent);
3191 mb->set_req(TypeFunc::Control,control());
3192 if (alias_idx == Compile::AliasIdxBot) {
3193 mb->set_req(TypeFunc::Memory, merged_memory()->base_memory());
3194 } else {
3195 assert(!(opcode == Op_Initialize && alias_idx != Compile::AliasIdxRaw), "fix caller");
3196 mb->set_req(TypeFunc::Memory, memory(alias_idx));
3197 }
3198 Node* membar = _gvn.transform(mb);
3199 set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
3200 if (alias_idx == Compile::AliasIdxBot) {
3201 merged_memory()->set_base_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)));
3202 } else {
3203 set_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)),alias_idx);
3204 }
3205 return membar;
3206 }
3207
3208 //------------------------------shared_lock------------------------------------
3209 // Emit locking code.
3210 FastLockNode* GraphKit::shared_lock(Node* obj) {
3211 // bci is either a monitorenter bc or InvocationEntryBci
3212 // %%% SynchronizationEntryBCI is redundant; use InvocationEntryBci in interfaces
3213 assert(SynchronizationEntryBCI == InvocationEntryBci, "");
3214
3215 if( !GenerateSynchronizationCode )
3216 return NULL; // Not locking things?
3217 if (stopped()) // Dead monitor?
3218 return NULL;
3219
3220 assert(dead_locals_are_killed(), "should kill locals before sync. point");
3221
3222 // Box the stack location
3223 Node* box = _gvn.transform(new BoxLockNode(next_monitor()));
3224 Node* mem = reset_memory();
3225
3226 FastLockNode * flock = _gvn.transform(new FastLockNode(0, obj, box) )->as_FastLock();
3227 if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
3228 // Create the counters for this fast lock.
3229 flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
3230 }
3231
3232 // Create the rtm counters for this fast lock if needed.
3233 flock->create_rtm_lock_counter(sync_jvms()); // sync_jvms used to get current bci
3234
3235 // Add monitor to debug info for the slow path. If we block inside the
3236 // slow path and de-opt, we need the monitor hanging around
3237 map()->push_monitor( flock );
3238
3239 const TypeFunc *tf = LockNode::lock_type();
3240 LockNode *lock = new LockNode(C, tf);
3241
3242 lock->init_req( TypeFunc::Control, control() );
3243 lock->init_req( TypeFunc::Memory , mem );
3244 lock->init_req( TypeFunc::I_O , top() ) ; // does no i/o
3245 lock->init_req( TypeFunc::FramePtr, frameptr() );
3246 lock->init_req( TypeFunc::ReturnAdr, top() );
3247
3248 lock->init_req(TypeFunc::Parms + 0, obj);
3249 lock->init_req(TypeFunc::Parms + 1, box);
3250 lock->init_req(TypeFunc::Parms + 2, flock);
3251 add_safepoint_edges(lock);
3252
3253 lock = _gvn.transform( lock )->as_Lock();
3254
3255 // lock has no side-effects, sets few values
3256 set_predefined_output_for_runtime_call(lock, mem, TypeRawPtr::BOTTOM);
3257
3258 insert_mem_bar(Op_MemBarAcquireLock);
3259
3260 // Add this to the worklist so that the lock can be eliminated
3274
3275
3276 //------------------------------shared_unlock----------------------------------
3277 // Emit unlocking code.
3278 void GraphKit::shared_unlock(Node* box, Node* obj) {
3279 // bci is either a monitorenter bc or InvocationEntryBci
3280 // %%% SynchronizationEntryBCI is redundant; use InvocationEntryBci in interfaces
3281 assert(SynchronizationEntryBCI == InvocationEntryBci, "");
3282
3283 if( !GenerateSynchronizationCode )
3284 return;
3285 if (stopped()) { // Dead monitor?
3286 map()->pop_monitor(); // Kill monitor from debug info
3287 return;
3288 }
3289
3290 // Memory barrier to avoid floating things down past the locked region
3291 insert_mem_bar(Op_MemBarReleaseLock);
3292
3293 const TypeFunc *tf = OptoRuntime::complete_monitor_exit_Type();
3294 UnlockNode *unlock = new UnlockNode(C, tf);
3295 uint raw_idx = Compile::AliasIdxRaw;
3296 unlock->init_req( TypeFunc::Control, control() );
3297 unlock->init_req( TypeFunc::Memory , memory(raw_idx) );
3298 unlock->init_req( TypeFunc::I_O , top() ) ; // does no i/o
3299 unlock->init_req( TypeFunc::FramePtr, frameptr() );
3300 unlock->init_req( TypeFunc::ReturnAdr, top() );
3301
3302 unlock->init_req(TypeFunc::Parms + 0, obj);
3303 unlock->init_req(TypeFunc::Parms + 1, box);
3304 unlock = _gvn.transform(unlock)->as_Unlock();
3305
3306 Node* mem = reset_memory();
3307
3308 // unlock has no side-effects, sets few values
3309 set_predefined_output_for_runtime_call(unlock, mem, TypeRawPtr::BOTTOM);
3310
3311 // Kill monitor from debug info
3312 map()->pop_monitor( );
3313 }
3314
3340 // We just put in an allocate/initialize with a big raw-memory effect.
3341 // Hook selected additional alias categories on the initialization.
3342 static void hook_memory_on_init(GraphKit& kit, int alias_idx,
3343 MergeMemNode* init_in_merge,
3344 Node* init_out_raw) {
3345 DEBUG_ONLY(Node* init_in_raw = init_in_merge->base_memory());
3346 assert(init_in_merge->memory_at(alias_idx) == init_in_raw, "");
3347
3348 Node* prevmem = kit.memory(alias_idx);
3349 init_in_merge->set_memory_at(alias_idx, prevmem);
3350 kit.set_memory(init_out_raw, alias_idx);
3351 }
3352
3353 //---------------------------set_output_for_allocation-------------------------
3354 Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
3355 const TypeOopPtr* oop_type) {
3356 int rawidx = Compile::AliasIdxRaw;
3357 alloc->set_req( TypeFunc::FramePtr, frameptr() );
3358 add_safepoint_edges(alloc);
3359 Node* allocx = _gvn.transform(alloc);
3360 set_control( _gvn.transform(new ProjNode(allocx, TypeFunc::Control) ) );
3361 // create memory projection for i_o
3362 set_memory ( _gvn.transform( new ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
3363 make_slow_call_ex(allocx, env()->Throwable_klass(), true);
3364
3365 // create a memory projection as for the normal control path
3366 Node* malloc = _gvn.transform(new ProjNode(allocx, TypeFunc::Memory));
3367 set_memory(malloc, rawidx);
3368
3369 // a normal slow-call doesn't change i_o, but an allocation does
3370 // we create a separate i_o projection for the normal control path
3371 set_i_o(_gvn.transform( new ProjNode(allocx, TypeFunc::I_O, false) ) );
3372 Node* rawoop = _gvn.transform( new ProjNode(allocx, TypeFunc::Parms) );
3373
3374 // put in an initialization barrier
3375 InitializeNode* init = insert_mem_bar_volatile(Op_Initialize, rawidx,
3376 rawoop)->as_Initialize();
3377 assert(alloc->initialization() == init, "2-way macro link must work");
3378 assert(init ->allocation() == alloc, "2-way macro link must work");
3379 {
3380 // Extract memory strands which may participate in the new object's
3381 // initialization, and source them from the new InitializeNode.
3382 // This will allow us to observe initializations when they occur,
3383 // and link them properly (as a group) to the InitializeNode.
3384 assert(init->in(InitializeNode::Memory) == malloc, "");
3385 MergeMemNode* minit_in = MergeMemNode::make(C, malloc);
3386 init->set_req(InitializeNode::Memory, minit_in);
3387 record_for_igvn(minit_in); // fold it up later, if possible
3388 Node* minit_out = memory(rawidx);
3389 assert(minit_out->is_Proj() && minit_out->in(0) == init, "");
3390 if (oop_type->isa_aryptr()) {
3391 const TypePtr* telemref = oop_type->add_offset(Type::OffsetBot);
3392 int elemidx = C->get_alias_index(telemref);
3393 hook_memory_on_init(*this, elemidx, minit_in, minit_out);
3394 } else if (oop_type->isa_instptr()) {
3395 ciInstanceKlass* ik = oop_type->klass()->as_instance_klass();
3396 for (int i = 0, len = ik->nof_nonstatic_fields(); i < len; i++) {
3397 ciField* field = ik->nonstatic_field_at(i);
3398 if (field->offset() >= TrackedInitializationLimit * HeapWordSize)
3399 continue; // do not bother to track really large numbers of fields
3400 // Find (or create) the alias category for this field:
3401 int fieldidx = C->alias_type(field)->index();
3402 hook_memory_on_init(*this, fieldidx, minit_in, minit_out);
3403 }
3404 }
3405 }
3406
3407 // Cast raw oop to the real thing...
3408 Node* javaoop = new CheckCastPPNode(control(), rawoop, oop_type);
3409 javaoop = _gvn.transform(javaoop);
3410 C->set_recent_alloc(control(), javaoop);
3411 assert(just_allocated_object(control()) == javaoop, "just allocated");
3412
3413 #ifdef ASSERT
3414 { // Verify that the AllocateNode::Ideal_allocation recognizers work:
3415 assert(AllocateNode::Ideal_allocation(rawoop, &_gvn) == alloc,
3416 "Ideal_allocation works");
3417 assert(AllocateNode::Ideal_allocation(javaoop, &_gvn) == alloc,
3418 "Ideal_allocation works");
3419 if (alloc->is_AllocateArray()) {
3420 assert(AllocateArrayNode::Ideal_array_allocation(rawoop, &_gvn) == alloc->as_AllocateArray(),
3421 "Ideal_allocation works");
3422 assert(AllocateArrayNode::Ideal_array_allocation(javaoop, &_gvn) == alloc->as_AllocateArray(),
3423 "Ideal_allocation works");
3424 } else {
3425 assert(alloc->in(AllocateNode::ALength)->is_top(), "no length, please");
3426 }
3427 }
3428 #endif //ASSERT
3447 // The layout_helper also encodes (in a low bit) the need for a slow path.
3448 jint layout_con = Klass::_lh_neutral_value;
3449 Node* layout_val = get_layout_helper(klass_node, layout_con);
3450 int layout_is_con = (layout_val == NULL);
3451
3452 if (extra_slow_test == NULL) extra_slow_test = intcon(0);
3453 // Generate the initial go-slow test. It's either ALWAYS (return a
3454 // Node for 1) or NEVER (return a NULL) or perhaps (in the reflective
3455 // case) a computed value derived from the layout_helper.
3456 Node* initial_slow_test = NULL;
3457 if (layout_is_con) {
3458 assert(!StressReflectiveCode, "stress mode does not use these paths");
3459 bool must_go_slow = Klass::layout_helper_needs_slow_path(layout_con);
3460 initial_slow_test = must_go_slow? intcon(1): extra_slow_test;
3461
3462 } else { // reflective case
3463 // This reflective path is used by Unsafe.allocateInstance.
3464 // (It may be stress-tested by specifying StressReflectiveCode.)
3465 // Basically, we want to get into the VM is there's an illegal argument.
3466 Node* bit = intcon(Klass::_lh_instance_slow_path_bit);
3467 initial_slow_test = _gvn.transform( new AndINode(layout_val, bit) );
3468 if (extra_slow_test != intcon(0)) {
3469 initial_slow_test = _gvn.transform( new OrINode(initial_slow_test, extra_slow_test) );
3470 }
3471 // (Macro-expander will further convert this to a Bool, if necessary.)
3472 }
3473
3474 // Find the size in bytes. This is easy; it's the layout_helper.
3475 // The size value must be valid even if the slow path is taken.
3476 Node* size = NULL;
3477 if (layout_is_con) {
3478 size = MakeConX(Klass::layout_helper_size_in_bytes(layout_con));
3479 } else { // reflective case
3480 // This reflective path is used by clone and Unsafe.allocateInstance.
3481 size = ConvI2X(layout_val);
3482
3483 // Clear the low bits to extract layout_helper_size_in_bytes:
3484 assert((int)Klass::_lh_instance_slow_path_bit < BytesPerLong, "clear bit");
3485 Node* mask = MakeConX(~ (intptr_t)right_n_bits(LogBytesPerLong));
3486 size = _gvn.transform( new AndXNode(size, mask) );
3487 }
3488 if (return_size_val != NULL) {
3489 (*return_size_val) = size;
3490 }
3491
3492 // This is a precise notnull oop of the klass.
3493 // (Actually, it need not be precise if this is a reflective allocation.)
3494 // It's what we cast the result to.
3495 const TypeKlassPtr* tklass = _gvn.type(klass_node)->isa_klassptr();
3496 if (!tklass) tklass = TypeKlassPtr::OBJECT;
3497 const TypeOopPtr* oop_type = tklass->as_instance_type();
3498
3499 // Now generate allocation code
3500
3501 // The entire memory state is needed for slow path of the allocation
3502 // since GC and deoptimization can happened.
3503 Node *mem = reset_memory();
3504 set_all_memory(mem); // Create new memory state
3505
3506 AllocateNode* alloc = new AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
3507 control(), mem, i_o(),
3508 size, klass_node,
3509 initial_slow_test);
3510
3511 return set_output_for_allocation(alloc, oop_type);
3512 }
3513
3514 //-------------------------------new_array-------------------------------------
3515 // helper for both newarray and anewarray
3516 // The 'length' parameter is (obviously) the length of the array.
3517 // See comments on new_instance for the meaning of the other arguments.
3518 Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
3519 Node* length, // number of array elements
3520 int nargs, // number of arguments to push back for uncommon trap
3521 Node* *return_size_val) {
3522 jint layout_con = Klass::_lh_neutral_value;
3523 Node* layout_val = get_layout_helper(klass_node, layout_con);
3524 int layout_is_con = (layout_val == NULL);
3525
3526 if (!layout_is_con && !StressReflectiveCode &&
3527 !too_many_traps(Deoptimization::Reason_class_check)) {
3528 // This is a reflective array creation site.
3529 // Optimistically assume that it is a subtype of Object[],
3530 // so that we can fold up all the address arithmetic.
3531 layout_con = Klass::array_layout_helper(T_OBJECT);
3532 Node* cmp_lh = _gvn.transform( new CmpINode(layout_val, intcon(layout_con)) );
3533 Node* bol_lh = _gvn.transform( new BoolNode(cmp_lh, BoolTest::eq) );
3534 { BuildCutout unless(this, bol_lh, PROB_MAX);
3535 inc_sp(nargs);
3536 uncommon_trap(Deoptimization::Reason_class_check,
3537 Deoptimization::Action_maybe_recompile);
3538 }
3539 layout_val = NULL;
3540 layout_is_con = true;
3541 }
3542
3543 // Generate the initial go-slow test. Make sure we do not overflow
3544 // if length is huge (near 2Gig) or negative! We do not need
3545 // exact double-words here, just a close approximation of needed
3546 // double-words. We can't add any offset or rounding bits, lest we
3547 // take a size -1 of bytes and make it positive. Use an unsigned
3548 // compare, so negative sizes look hugely positive.
3549 int fast_size_limit = FastAllocateSizeLimit;
3550 if (layout_is_con) {
3551 assert(!StressReflectiveCode, "stress mode does not use these paths");
3552 // Increase the size limit if we have exact knowledge of array type.
3553 int log2_esize = Klass::layout_helper_log2_element_size(layout_con);
3554 fast_size_limit <<= (LogBytesPerLong - log2_esize);
3555 }
3556
3557 Node* initial_slow_cmp = _gvn.transform( new CmpUNode( length, intcon( fast_size_limit ) ) );
3558 Node* initial_slow_test = _gvn.transform( new BoolNode( initial_slow_cmp, BoolTest::gt ) );
3559 if (initial_slow_test->is_Bool()) {
3560 // Hide it behind a CMoveI, or else PhaseIdealLoop::split_up will get sick.
3561 initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);
3562 }
3563
3564 // --- Size Computation ---
3565 // array_size = round_to_heap(array_header + (length << elem_shift));
3566 // where round_to_heap(x) == round_to(x, MinObjAlignmentInBytes)
3567 // and round_to(x, y) == ((x + y-1) & ~(y-1))
3568 // The rounding mask is strength-reduced, if possible.
3569 int round_mask = MinObjAlignmentInBytes - 1;
3570 Node* header_size = NULL;
3571 int header_size_min = arrayOopDesc::base_offset_in_bytes(T_BYTE);
3572 // (T_BYTE has the weakest alignment and size restrictions...)
3573 if (layout_is_con) {
3574 int hsize = Klass::layout_helper_header_size(layout_con);
3575 int eshift = Klass::layout_helper_log2_element_size(layout_con);
3576 BasicType etype = Klass::layout_helper_element_type(layout_con);
3577 if ((round_mask & ~right_n_bits(eshift)) == 0)
3578 round_mask = 0; // strength-reduce it if it goes away completely
3579 assert((hsize & right_n_bits(eshift)) == 0, "hsize is pre-rounded");
3580 assert(header_size_min <= hsize, "generic minimum is smallest");
3581 header_size_min = hsize;
3582 header_size = intcon(hsize + round_mask);
3583 } else {
3584 Node* hss = intcon(Klass::_lh_header_size_shift);
3585 Node* hsm = intcon(Klass::_lh_header_size_mask);
3586 Node* hsize = _gvn.transform( new URShiftINode(layout_val, hss) );
3587 hsize = _gvn.transform( new AndINode(hsize, hsm) );
3588 Node* mask = intcon(round_mask);
3589 header_size = _gvn.transform( new AddINode(hsize, mask) );
3590 }
3591
3592 Node* elem_shift = NULL;
3593 if (layout_is_con) {
3594 int eshift = Klass::layout_helper_log2_element_size(layout_con);
3595 if (eshift != 0)
3596 elem_shift = intcon(eshift);
3597 } else {
3598 // There is no need to mask or shift this value.
3599 // The semantics of LShiftINode include an implicit mask to 0x1F.
3600 assert(Klass::_lh_log2_element_size_shift == 0, "use shift in place");
3601 elem_shift = layout_val;
3602 }
3603
3604 // Transition to native address size for all offset calculations:
3605 Node* lengthx = ConvI2X(length);
3606 Node* headerx = ConvI2X(header_size);
3607 #ifdef _LP64
3608 { const TypeLong* tllen = _gvn.find_long_type(lengthx);
3609 if (tllen != NULL && tllen->_lo < 0) {
3610 // Add a manual constraint to a positive range. Cf. array_element_address.
3611 jlong size_max = arrayOopDesc::max_array_length(T_BYTE);
3612 if (size_max > tllen->_hi) size_max = tllen->_hi;
3613 const TypeLong* tlcon = TypeLong::make(CONST64(0), size_max, Type::WidenMin);
3614 lengthx = _gvn.transform( new ConvI2LNode(length, tlcon));
3615 }
3616 }
3617 #endif
3618
3619 // Combine header size (plus rounding) and body size. Then round down.
3620 // This computation cannot overflow, because it is used only in two
3621 // places, one where the length is sharply limited, and the other
3622 // after a successful allocation.
3623 Node* abody = lengthx;
3624 if (elem_shift != NULL)
3625 abody = _gvn.transform( new LShiftXNode(lengthx, elem_shift) );
3626 Node* size = _gvn.transform( new AddXNode(headerx, abody) );
3627 if (round_mask != 0) {
3628 Node* mask = MakeConX(~round_mask);
3629 size = _gvn.transform( new AndXNode(size, mask) );
3630 }
3631 // else if round_mask == 0, the size computation is self-rounding
3632
3633 if (return_size_val != NULL) {
3634 // This is the size
3635 (*return_size_val) = size;
3636 }
3637
3638 // Now generate allocation code
3639
3640 // The entire memory state is needed for slow path of the allocation
3641 // since GC and deoptimization can happened.
3642 Node *mem = reset_memory();
3643 set_all_memory(mem); // Create new memory state
3644
3645 // Create the AllocateArrayNode and its result projections
3646 AllocateArrayNode* alloc
3647 = new AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
3648 control(), mem, i_o(),
3649 size, klass_node,
3650 initial_slow_test,
3651 length);
3652
3653 // Cast to correct type. Note that the klass_node may be constant or not,
3654 // and in the latter case the actual array type will be inexact also.
3655 // (This happens via a non-constant argument to inline_native_newArray.)
3656 // In any case, the value of klass_node provides the desired array type.
3657 const TypeInt* length_type = _gvn.find_int_type(length);
3658 const TypeOopPtr* ary_type = _gvn.type(klass_node)->is_klassptr()->as_instance_type();
3659 if (ary_type->isa_aryptr() && length_type != NULL) {
3660 // Try to get a better type than POS for the size
3661 ary_type = ary_type->is_aryptr()->cast_to_size(length_type);
3662 }
3663
3664 Node* javaoop = set_output_for_allocation(alloc, ary_type);
3665
3666 // Cast length on remaining path to be as narrow as possible
3667 if (map()->find_edge(length) >= 0) {
3741
3742 //------------------------------add_predicate_impl----------------------------
3743 void GraphKit::add_predicate_impl(Deoptimization::DeoptReason reason, int nargs) {
3744 // Too many traps seen?
3745 if (too_many_traps(reason)) {
3746 #ifdef ASSERT
3747 if (TraceLoopPredicate) {
3748 int tc = C->trap_count(reason);
3749 tty->print("too many traps=%s tcount=%d in ",
3750 Deoptimization::trap_reason_name(reason), tc);
3751 method()->print(); // which method has too many predicate traps
3752 tty->cr();
3753 }
3754 #endif
3755 // We cannot afford to take more traps here,
3756 // do not generate predicate.
3757 return;
3758 }
3759
3760 Node *cont = _gvn.intcon(1);
3761 Node* opq = _gvn.transform(new Opaque1Node(C, cont));
3762 Node *bol = _gvn.transform(new Conv2BNode(opq));
3763 IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
3764 Node* iffalse = _gvn.transform(new IfFalseNode(iff));
3765 C->add_predicate_opaq(opq);
3766 {
3767 PreserveJVMState pjvms(this);
3768 set_control(iffalse);
3769 inc_sp(nargs);
3770 uncommon_trap(reason, Deoptimization::Action_maybe_recompile);
3771 }
3772 Node* iftrue = _gvn.transform(new IfTrueNode(iff));
3773 set_control(iftrue);
3774 }
3775
3776 //------------------------------add_predicate---------------------------------
3777 void GraphKit::add_predicate(int nargs) {
3778 if (UseLoopPredicate) {
3779 add_predicate_impl(Deoptimization::Reason_predicate, nargs);
3780 }
3781 // loop's limit check predicate should be near the loop.
3782 if (LoopLimitCheck) {
3783 add_predicate_impl(Deoptimization::Reason_loop_limit_check, nargs);
3784 }
3785 }
3786
3787 //----------------------------- store barriers ----------------------------
3788 #define __ ideal.
3789
3790 void GraphKit::sync_kit(IdealKit& ideal) {
3791 set_all_memory(__ merged_memory());
3792 set_i_o(__ i_o());
3944 // if (!marking)
3945 __ if_then(marking, BoolTest::ne, zero, unlikely); {
3946 BasicType index_bt = TypeX_X->basic_type();
3947 assert(sizeof(size_t) == type2aelembytes(index_bt), "Loading G1 PtrQueue::_index with wrong size.");
3948 Node* index = __ load(__ ctrl(), index_adr, TypeX_X, index_bt, Compile::AliasIdxRaw);
3949
3950 if (do_load) {
3951 // load original value
3952 // alias_idx correct??
3953 pre_val = __ load(__ ctrl(), adr, val_type, bt, alias_idx);
3954 }
3955
3956 // if (pre_val != NULL)
3957 __ if_then(pre_val, BoolTest::ne, null()); {
3958 Node* buffer = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw);
3959
3960 // is the queue for this thread full?
3961 __ if_then(index, BoolTest::ne, zeroX, likely); {
3962
3963 // decrement the index
3964 Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
3965
3966 // Now get the buffer location we will log the previous value into and store it
3967 Node *log_addr = __ AddP(no_base, buffer, next_index);
3968 __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw, MemNode::unordered);
3969 // update the index
3970 __ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw, MemNode::unordered);
3971
3972 } __ else_(); {
3973
3974 // logging buffer is full, call the runtime
3975 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type();
3976 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), "g1_wb_pre", pre_val, tls);
3977 } __ end_if(); // (!index)
3978 } __ end_if(); // (pre_val != NULL)
3979 } __ end_if(); // (!marking)
3980
3981 // Final sync IdealKit and GraphKit.
3982 final_sync(ideal);
3983 }
3984
3987 //
3988 void GraphKit::g1_mark_card(IdealKit& ideal,
3989 Node* card_adr,
3990 Node* oop_store,
3991 uint oop_alias_idx,
3992 Node* index,
3993 Node* index_adr,
3994 Node* buffer,
3995 const TypeFunc* tf) {
3996
3997 Node* zero = __ ConI(0);
3998 Node* zeroX = __ ConX(0);
3999 Node* no_base = __ top();
4000 BasicType card_bt = T_BYTE;
4001 // Smash zero into card. MUST BE ORDERED WRT TO STORE
4002 __ storeCM(__ ctrl(), card_adr, zero, oop_store, oop_alias_idx, card_bt, Compile::AliasIdxRaw);
4003
4004 // Now do the queue work
4005 __ if_then(index, BoolTest::ne, zeroX); {
4006
4007 Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
4008 Node* log_addr = __ AddP(no_base, buffer, next_index);
4009
4010 // Order, see storeCM.
4011 __ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered);
4012 __ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw, MemNode::unordered);
4013
4014 } __ else_(); {
4015 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), "g1_wb_post", card_adr, __ thread());
4016 } __ end_if();
4017
4018 }
4019
4020 void GraphKit::g1_write_barrier_post(Node* oop_store,
4021 Node* obj,
4022 Node* adr,
4023 uint alias_idx,
4024 Node* val,
4025 BasicType bt,
4026 bool use_precise) {
4027 // If we are writing a NULL then we need no post barrier
4194 false, NULL, 0);
4195 const TypePtr* value_field_type = string_type->add_offset(value_offset);
4196
4197 store_oop_to_object(ctrl, str, basic_plus_adr(str, value_offset), value_field_type,
4198 value, TypeAryPtr::CHARS, T_OBJECT, MemNode::unordered);
4199 }
4200
4201 void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) {
4202 int count_offset = java_lang_String::count_offset_in_bytes();
4203 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
4204 false, NULL, 0);
4205 const TypePtr* count_field_type = string_type->add_offset(count_offset);
4206 int count_field_idx = C->get_alias_index(count_field_type);
4207 store_to_memory(ctrl, basic_plus_adr(str, count_offset),
4208 value, T_INT, count_field_idx, MemNode::unordered);
4209 }
4210
4211 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
4212 // Reify the property as a CastPP node in Ideal graph to comply with monotonicity
4213 // assumption of CCP analysis.
4214 return _gvn.transform(new CastPPNode(ary, ary_type->cast_to_stable(true)));
4215 }
|