284 igvn->register_new_node_with_optimizer(opq);
285 igvn->register_new_node_with_optimizer(bol);
286 }
287 igvn->hash_delete(iff);
288 iff->set_req(1, bol);
289 return new_predicate_proj;
290 }
291
292
293 //--------------------------clone_loop_predicates-----------------------
294 // Interface from IGVN
295 Node* PhaseIterGVN::clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check) {
296 return PhaseIdealLoop::clone_loop_predicates(old_entry, new_entry, clone_limit_check, NULL, this);
297 }
298
299 // Interface from PhaseIdealLoop
300 Node* PhaseIdealLoop::clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check) {
301 return clone_loop_predicates(old_entry, new_entry, clone_limit_check, this, &this->_igvn);
302 }
303
304 // Clone loop predicates to cloned loops (peeled, unswitched, split_if).
305 Node* PhaseIdealLoop::clone_loop_predicates(Node* old_entry, Node* new_entry,
306 bool clone_limit_check,
307 PhaseIdealLoop* loop_phase,
308 PhaseIterGVN* igvn) {
309 #ifdef ASSERT
310 if (new_entry == NULL || !(new_entry->is_Proj() || new_entry->is_Region() || new_entry->is_SafePoint())) {
311 if (new_entry != NULL)
312 new_entry->dump();
313 assert(false, "not IfTrue, IfFalse, Region or SafePoint");
314 }
315 #endif
316 // Search original predicates
317 Node* entry = old_entry;
318 ProjNode* limit_check_proj = NULL;
319 limit_check_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_loop_limit_check);
320 if (limit_check_proj != NULL) {
321 entry = entry->in(0)->in(0);
322 }
323 ProjNode* profile_predicate_proj = NULL;
324 ProjNode* predicate_proj = NULL;
325 if (UseProfiledLoopPredicate) {
326 profile_predicate_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_profile_predicate);
327 if (profile_predicate_proj != NULL) {
328 entry = skip_loop_predicates(entry);
329 }
330 }
331 if (UseLoopPredicate) {
332 predicate_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_predicate);
333 }
334 if (predicate_proj != NULL) { // right pattern that can be used by loop predication
335 // clone predicate
336 new_entry = clone_predicate(predicate_proj, new_entry,
337 Deoptimization::Reason_predicate,
338 loop_phase, igvn);
339 assert(new_entry != NULL && new_entry->is_Proj(), "IfTrue or IfFalse after clone predicate");
340 if (TraceLoopPredicate) {
341 tty->print("Loop Predicate cloned: ");
342 debug_only( new_entry->in(0)->dump(); );
343 }
344 }
345 if (profile_predicate_proj != NULL) { // right pattern that can be used by loop predication
346 // clone predicate
347 new_entry = clone_predicate(profile_predicate_proj, new_entry,
348 Deoptimization::Reason_profile_predicate,
349 loop_phase, igvn);
350 assert(new_entry != NULL && new_entry->is_Proj(), "IfTrue or IfFalse after clone predicate");
351 if (TraceLoopPredicate) {
352 tty->print("Loop Predicate cloned: ");
353 debug_only( new_entry->in(0)->dump(); );
354 }
355 }
356 if (limit_check_proj != NULL && clone_limit_check) {
357 // Clone loop limit check last to insert it before loop.
358 // Don't clone a limit check which was already finalized
359 // for this counted loop (only one limit check is needed).
360 new_entry = clone_predicate(limit_check_proj, new_entry,
361 Deoptimization::Reason_loop_limit_check,
362 loop_phase, igvn);
|
284 igvn->register_new_node_with_optimizer(opq);
285 igvn->register_new_node_with_optimizer(bol);
286 }
287 igvn->hash_delete(iff);
288 iff->set_req(1, bol);
289 return new_predicate_proj;
290 }
291
292
293 //--------------------------clone_loop_predicates-----------------------
294 // Interface from IGVN
295 Node* PhaseIterGVN::clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check) {
296 return PhaseIdealLoop::clone_loop_predicates(old_entry, new_entry, clone_limit_check, NULL, this);
297 }
298
299 // Interface from PhaseIdealLoop
300 Node* PhaseIdealLoop::clone_loop_predicates(Node* old_entry, Node* new_entry, bool clone_limit_check) {
301 return clone_loop_predicates(old_entry, new_entry, clone_limit_check, this, &this->_igvn);
302 }
303
304 void PhaseIdealLoop::clone_loop_predicates_fix_mem(ProjNode* dom_proj , ProjNode* proj,
305 PhaseIdealLoop* loop_phase,
306 PhaseIterGVN* igvn) {
307 Compile* C = NULL;
308 if (loop_phase != NULL) {
309 igvn = &loop_phase->igvn();
310 }
311 C = igvn->C;
312 ProjNode* other_dom_proj = dom_proj->in(0)->as_Multi()->proj_out(1-dom_proj->_con);
313 Node* dom_r = other_dom_proj->unique_ctrl_out();
314 if (dom_r->is_Region()) {
315 assert(dom_r->unique_ctrl_out()->is_Call(), "unc expected");
316 ProjNode* other_proj = proj->in(0)->as_Multi()->proj_out(1-proj->_con);
317 Node* r = other_proj->unique_ctrl_out();
318 assert(r->is_Region() && r->unique_ctrl_out()->is_Call(), "cloned predicate should have caused region to be added");
319 for (DUIterator_Fast imax, i = dom_r->fast_outs(imax); i < imax; i++) {
320 Node* dom_use = dom_r->fast_out(i);
321 if (dom_use->is_Phi() && dom_use->bottom_type() == Type::MEMORY) {
322 assert(dom_use->in(0) == dom_r, "");
323 Node* phi = NULL;
324 for (DUIterator_Fast jmax, j = r->fast_outs(jmax); j < jmax; j++) {
325 Node* use = r->fast_out(j);
326 if (use->is_Phi() && use->bottom_type() == Type::MEMORY &&
327 use->adr_type() == dom_use->adr_type()) {
328 assert(use->in(0) == r, "");
329 assert(phi == NULL, "only one phi");
330 phi = use;
331 }
332 }
333 if (phi == NULL) {
334 Node* call = r->unique_ctrl_out();
335 Node* mem = call->in(TypeFunc::Memory);
336 MergeMemNode* mm = NULL;
337 if (mem->is_MergeMem()) {
338 mm = mem->clone()->as_MergeMem();
339 } else {
340 mm = MergeMemNode::make(mem);
341 }
342 phi = PhiNode::make(r, mem, Type::MEMORY, dom_use->adr_type());
343 mm->set_memory_at(C->get_alias_index(phi->adr_type()), phi);
344 if (loop_phase != NULL) {
345 loop_phase->register_new_node(mm, r);
346 loop_phase->register_new_node(phi, r);
347 } else {
348 igvn->register_new_node_with_optimizer(mm);
349 igvn->register_new_node_with_optimizer(phi);
350 }
351 igvn->replace_input_of(call, TypeFunc::Memory, mm);
352 }
353 igvn->replace_input_of(phi, r->req()-1, dom_use->in(dom_r->find_edge(other_dom_proj)));
354 }
355 }
356 }
357 }
358
359
360 // Clone loop predicates to cloned loops (peeled, unswitched, split_if).
361 Node* PhaseIdealLoop::clone_loop_predicates(Node* old_entry, Node* new_entry,
362 bool clone_limit_check,
363 PhaseIdealLoop* loop_phase,
364 PhaseIterGVN* igvn) {
365 #ifdef ASSERT
366 if (new_entry == NULL || !(new_entry->is_Proj() || new_entry->is_Region() || new_entry->is_SafePoint())) {
367 if (new_entry != NULL)
368 new_entry->dump();
369 assert(false, "not IfTrue, IfFalse, Region or SafePoint");
370 }
371 #endif
372 // Search original predicates
373 Node* entry = old_entry;
374 ProjNode* limit_check_proj = NULL;
375 limit_check_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_loop_limit_check);
376 if (limit_check_proj != NULL) {
377 entry = entry->in(0)->in(0);
378 }
379 ProjNode* profile_predicate_proj = NULL;
380 ProjNode* predicate_proj = NULL;
381 if (UseProfiledLoopPredicate) {
382 profile_predicate_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_profile_predicate);
383 if (profile_predicate_proj != NULL) {
384 entry = skip_loop_predicates(entry);
385 }
386 }
387 if (UseLoopPredicate) {
388 predicate_proj = find_predicate_insertion_point(entry, Deoptimization::Reason_predicate);
389 }
390 if (predicate_proj != NULL) { // right pattern that can be used by loop predication
391 // clone predicate
392 ProjNode* proj = clone_predicate(predicate_proj, new_entry,
393 Deoptimization::Reason_predicate,
394 loop_phase, igvn);
395 assert(proj != NULL, "IfTrue or IfFalse after clone predicate");
396 new_entry = proj;
397 if (TraceLoopPredicate) {
398 tty->print("Loop Predicate cloned: ");
399 debug_only( new_entry->in(0)->dump(); );
400 }
401 if (profile_predicate_proj != NULL) {
402 // A node that produces memory may be out of loop and depend on
403 // a profiled predicates. In that case the memory state at the
404 // end of profiled predicates and at the end of predicates are
405 // not the same. The cloned predicates are dominated by the
406 // profiled predicates but may have the wrong memory
407 // state. Update it.
408 clone_loop_predicates_fix_mem(profile_predicate_proj, proj, loop_phase, igvn);
409 }
410 }
411 if (profile_predicate_proj != NULL) { // right pattern that can be used by loop predication
412 // clone predicate
413 new_entry = clone_predicate(profile_predicate_proj, new_entry,
414 Deoptimization::Reason_profile_predicate,
415 loop_phase, igvn);
416 assert(new_entry != NULL && new_entry->is_Proj(), "IfTrue or IfFalse after clone predicate");
417 if (TraceLoopPredicate) {
418 tty->print("Loop Predicate cloned: ");
419 debug_only( new_entry->in(0)->dump(); );
420 }
421 }
422 if (limit_check_proj != NULL && clone_limit_check) {
423 // Clone loop limit check last to insert it before loop.
424 // Don't clone a limit check which was already finalized
425 // for this counted loop (only one limit check is needed).
426 new_entry = clone_predicate(limit_check_proj, new_entry,
427 Deoptimization::Reason_loop_limit_check,
428 loop_phase, igvn);
|