Mercurial > hg > graal-jvmci-8
comparison src/share/vm/opto/loopopts.cpp @ 6804:e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
Summary: Deleted placement new operator of Node - node(size_t, Compile *, int).
Reviewed-by: kvn, twisti
Contributed-by: bharadwaj.yadavalli@oracle.com
author | kvn |
---|---|
date | Thu, 27 Sep 2012 09:38:42 -0700 |
parents | 5e990493719e |
children | b9a9ed0f8eeb 8e47bac5643a |
comparison
equal
deleted
inserted
replaced
6803:06f52c4d0e18 | 6804:e626685e9f6c |
---|---|
51 Node *phi; | 51 Node *phi; |
52 if (t_oop != NULL && t_oop->is_known_instance_field()) { | 52 if (t_oop != NULL && t_oop->is_known_instance_field()) { |
53 int iid = t_oop->instance_id(); | 53 int iid = t_oop->instance_id(); |
54 int index = C->get_alias_index(t_oop); | 54 int index = C->get_alias_index(t_oop); |
55 int offset = t_oop->offset(); | 55 int offset = t_oop->offset(); |
56 phi = new (C,region->req()) PhiNode(region, type, NULL, iid, index, offset); | 56 phi = new (C) PhiNode(region, type, NULL, iid, index, offset); |
57 } else { | 57 } else { |
58 phi = PhiNode::make_blank(region, n); | 58 phi = PhiNode::make_blank(region, n); |
59 } | 59 } |
60 uint old_unique = C->unique(); | 60 uint old_unique = C->unique(); |
61 for (uint i = 1; i < region->req(); i++) { | 61 for (uint i = 1; i < region->req(); i++) { |
354 // Convert I-V into I+ (0-V); same for V-I | 354 // Convert I-V into I+ (0-V); same for V-I |
355 if( add->Opcode() == Op_SubI && | 355 if( add->Opcode() == Op_SubI && |
356 _igvn.type( add->in(1) ) != TypeInt::ZERO ) { | 356 _igvn.type( add->in(1) ) != TypeInt::ZERO ) { |
357 Node *zero = _igvn.intcon(0); | 357 Node *zero = _igvn.intcon(0); |
358 set_ctrl(zero, C->root()); | 358 set_ctrl(zero, C->root()); |
359 Node *neg = new (C, 3) SubINode( _igvn.intcon(0), add->in(2) ); | 359 Node *neg = new (C) SubINode( _igvn.intcon(0), add->in(2) ); |
360 register_new_node( neg, get_ctrl(add->in(2) ) ); | 360 register_new_node( neg, get_ctrl(add->in(2) ) ); |
361 add = new (C, 3) AddINode( add->in(1), neg ); | 361 add = new (C) AddINode( add->in(1), neg ); |
362 register_new_node( add, add_ctrl ); | 362 register_new_node( add, add_ctrl ); |
363 } | 363 } |
364 if( add->Opcode() != Op_AddI ) return NULL; | 364 if( add->Opcode() != Op_AddI ) return NULL; |
365 // See if one add input is loop invariant | 365 // See if one add input is loop invariant |
366 Node *add_var = add->in(1); | 366 Node *add_var = add->in(1); |
382 return NULL; | 382 return NULL; |
383 if( n_loop == add_invar_loop || !add_invar_loop->is_member( n_loop ) ) | 383 if( n_loop == add_invar_loop || !add_invar_loop->is_member( n_loop ) ) |
384 return NULL; // No invariant part of the add? | 384 return NULL; // No invariant part of the add? |
385 | 385 |
386 // Yes! Reshape address expression! | 386 // Yes! Reshape address expression! |
387 Node *inv_scale = new (C, 3) LShiftINode( add_invar, scale ); | 387 Node *inv_scale = new (C) LShiftINode( add_invar, scale ); |
388 Node *inv_scale_ctrl = | 388 Node *inv_scale_ctrl = |
389 dom_depth(add_invar_ctrl) > dom_depth(scale_ctrl) ? | 389 dom_depth(add_invar_ctrl) > dom_depth(scale_ctrl) ? |
390 add_invar_ctrl : scale_ctrl; | 390 add_invar_ctrl : scale_ctrl; |
391 register_new_node( inv_scale, inv_scale_ctrl ); | 391 register_new_node( inv_scale, inv_scale_ctrl ); |
392 Node *var_scale = new (C, 3) LShiftINode( add_var, scale ); | 392 Node *var_scale = new (C) LShiftINode( add_var, scale ); |
393 register_new_node( var_scale, n_ctrl ); | 393 register_new_node( var_scale, n_ctrl ); |
394 Node *var_add = new (C, 3) AddINode( var_scale, inv_scale ); | 394 Node *var_add = new (C) AddINode( var_scale, inv_scale ); |
395 register_new_node( var_add, n_ctrl ); | 395 register_new_node( var_add, n_ctrl ); |
396 _igvn.replace_node( n, var_add ); | 396 _igvn.replace_node( n, var_add ); |
397 return var_add; | 397 return var_add; |
398 } | 398 } |
399 | 399 |
421 Node *n23_ctrl = get_ctrl(n->in(2)->in(3)); | 421 Node *n23_ctrl = get_ctrl(n->in(2)->in(3)); |
422 IdealLoopTree *n22loop = get_loop( n22_ctrl ); | 422 IdealLoopTree *n22loop = get_loop( n22_ctrl ); |
423 IdealLoopTree *n23_loop = get_loop( n23_ctrl ); | 423 IdealLoopTree *n23_loop = get_loop( n23_ctrl ); |
424 if( n22loop != n_loop && n22loop->is_member(n_loop) && | 424 if( n22loop != n_loop && n22loop->is_member(n_loop) && |
425 n23_loop == n_loop ) { | 425 n23_loop == n_loop ) { |
426 Node *add1 = new (C, 4) AddPNode( n->in(1), n->in(2)->in(2), n->in(3) ); | 426 Node *add1 = new (C) AddPNode( n->in(1), n->in(2)->in(2), n->in(3) ); |
427 // Stuff new AddP in the loop preheader | 427 // Stuff new AddP in the loop preheader |
428 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); | 428 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); |
429 Node *add2 = new (C, 4) AddPNode( n->in(1), add1, n->in(2)->in(3) ); | 429 Node *add2 = new (C) AddPNode( n->in(1), add1, n->in(2)->in(3) ); |
430 register_new_node( add2, n_ctrl ); | 430 register_new_node( add2, n_ctrl ); |
431 _igvn.replace_node( n, add2 ); | 431 _igvn.replace_node( n, add2 ); |
432 return add2; | 432 return add2; |
433 } | 433 } |
434 } | 434 } |
442 if( is_member(n_loop,get_ctrl(V)) ) { | 442 if( is_member(n_loop,get_ctrl(V)) ) { |
443 } else { | 443 } else { |
444 Node *tmp = V; V = I; I = tmp; | 444 Node *tmp = V; V = I; I = tmp; |
445 } | 445 } |
446 if( !is_member(n_loop,get_ctrl(I)) ) { | 446 if( !is_member(n_loop,get_ctrl(I)) ) { |
447 Node *add1 = new (C, 4) AddPNode( n->in(1), n->in(2), I ); | 447 Node *add1 = new (C) AddPNode( n->in(1), n->in(2), I ); |
448 // Stuff new AddP in the loop preheader | 448 // Stuff new AddP in the loop preheader |
449 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); | 449 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); |
450 Node *add2 = new (C, 4) AddPNode( n->in(1), add1, V ); | 450 Node *add2 = new (C) AddPNode( n->in(1), add1, V ); |
451 register_new_node( add2, n_ctrl ); | 451 register_new_node( add2, n_ctrl ); |
452 _igvn.replace_node( n, add2 ); | 452 _igvn.replace_node( n, add2 ); |
453 return add2; | 453 return add2; |
454 } | 454 } |
455 } | 455 } |
1092 | 1092 |
1093 Node *sample_bool = phi->in(1); | 1093 Node *sample_bool = phi->in(1); |
1094 Node *sample_cmp = sample_bool->in(1); | 1094 Node *sample_cmp = sample_bool->in(1); |
1095 | 1095 |
1096 // Make Phis to merge the Cmp's inputs. | 1096 // Make Phis to merge the Cmp's inputs. |
1097 int size = phi->in(0)->req(); | 1097 PhiNode *phi1 = new (C) PhiNode( phi->in(0), Type::TOP ); |
1098 PhiNode *phi1 = new (C, size) PhiNode( phi->in(0), Type::TOP ); | 1098 PhiNode *phi2 = new (C) PhiNode( phi->in(0), Type::TOP ); |
1099 PhiNode *phi2 = new (C, size) PhiNode( phi->in(0), Type::TOP ); | |
1100 for( i = 1; i < phi->req(); i++ ) { | 1099 for( i = 1; i < phi->req(); i++ ) { |
1101 Node *n1 = phi->in(i)->in(1)->in(1); | 1100 Node *n1 = phi->in(i)->in(1)->in(1); |
1102 Node *n2 = phi->in(i)->in(1)->in(2); | 1101 Node *n2 = phi->in(i)->in(1)->in(2); |
1103 phi1->set_req( i, n1 ); | 1102 phi1->set_req( i, n1 ); |
1104 phi2->set_req( i, n2 ); | 1103 phi2->set_req( i, n2 ); |
1161 } | 1160 } |
1162 | 1161 |
1163 Node *sample_cmp = phi->in(1); | 1162 Node *sample_cmp = phi->in(1); |
1164 | 1163 |
1165 // Make Phis to merge the Cmp's inputs. | 1164 // Make Phis to merge the Cmp's inputs. |
1166 int size = phi->in(0)->req(); | 1165 PhiNode *phi1 = new (C) PhiNode( phi->in(0), Type::TOP ); |
1167 PhiNode *phi1 = new (C, size) PhiNode( phi->in(0), Type::TOP ); | 1166 PhiNode *phi2 = new (C) PhiNode( phi->in(0), Type::TOP ); |
1168 PhiNode *phi2 = new (C, size) PhiNode( phi->in(0), Type::TOP ); | |
1169 for( uint j = 1; j < phi->req(); j++ ) { | 1167 for( uint j = 1; j < phi->req(); j++ ) { |
1170 Node *cmp_top = phi->in(j); // Inputs are all Cmp or TOP | 1168 Node *cmp_top = phi->in(j); // Inputs are all Cmp or TOP |
1171 Node *n1, *n2; | 1169 Node *n1, *n2; |
1172 if( cmp_top->is_Cmp() ) { | 1170 if( cmp_top->is_Cmp() ) { |
1173 n1 = cmp_top->in(1); | 1171 n1 = cmp_top->in(1); |
1327 set_loop(newuse, use_loop); | 1325 set_loop(newuse, use_loop); |
1328 set_idom(newuse, nnn, dom_depth(nnn) + 1 ); | 1326 set_idom(newuse, nnn, dom_depth(nnn) + 1 ); |
1329 | 1327 |
1330 // We need a Region to merge the exit from the peeled body and the | 1328 // We need a Region to merge the exit from the peeled body and the |
1331 // exit from the old loop body. | 1329 // exit from the old loop body. |
1332 RegionNode *r = new (C, 3) RegionNode(3); | 1330 RegionNode *r = new (C) RegionNode(3); |
1333 // Map the old use to the new merge point | 1331 // Map the old use to the new merge point |
1334 old_new.map( use->_idx, r ); | 1332 old_new.map( use->_idx, r ); |
1335 uint dd_r = MIN2(dom_depth(newuse),dom_depth(use)); | 1333 uint dd_r = MIN2(dom_depth(newuse),dom_depth(use)); |
1336 assert( dd_r >= dom_depth(dom_lca(newuse,use)), "" ); | 1334 assert( dd_r >= dom_depth(dom_lca(newuse,use)), "" ); |
1337 | 1335 |
1673 | 1671 |
1674 proj->set_req(0, NULL); // temporary disconnect | 1672 proj->set_req(0, NULL); // temporary disconnect |
1675 ProjNode* proj2 = proj_clone(proj, iff); | 1673 ProjNode* proj2 = proj_clone(proj, iff); |
1676 register_node(proj2, loop, iff, ddepth); | 1674 register_node(proj2, loop, iff, ddepth); |
1677 | 1675 |
1678 Node* cmp = Signed ? (Node*) new (C,3)CmpINode(left, right) : (Node*) new (C,3)CmpUNode(left, right); | 1676 Node* cmp = Signed ? (Node*) new (C)CmpINode(left, right) : (Node*) new (C)CmpUNode(left, right); |
1679 register_node(cmp, loop, proj2, ddepth); | 1677 register_node(cmp, loop, proj2, ddepth); |
1680 | 1678 |
1681 BoolNode* bol = new (C,2)BoolNode(cmp, relop); | 1679 BoolNode* bol = new (C)BoolNode(cmp, relop); |
1682 register_node(bol, loop, proj2, ddepth); | 1680 register_node(bol, loop, proj2, ddepth); |
1683 | 1681 |
1684 IfNode* new_if = new (C,2)IfNode(proj2, bol, iff->_prob, iff->_fcnt); | 1682 IfNode* new_if = new (C)IfNode(proj2, bol, iff->_prob, iff->_fcnt); |
1685 register_node(new_if, loop, proj2, ddepth); | 1683 register_node(new_if, loop, proj2, ddepth); |
1686 | 1684 |
1687 proj->set_req(0, new_if); // reattach | 1685 proj->set_req(0, new_if); // reattach |
1688 set_idom(proj, new_if, ddepth); | 1686 set_idom(proj, new_if, ddepth); |
1689 | 1687 |
1730 | 1728 |
1731 proj->set_req(0, NULL); // temporary disconnect | 1729 proj->set_req(0, NULL); // temporary disconnect |
1732 ProjNode* proj2 = proj_clone(proj, iff); | 1730 ProjNode* proj2 = proj_clone(proj, iff); |
1733 register_node(proj2, loop, iff, ddepth); | 1731 register_node(proj2, loop, iff, ddepth); |
1734 | 1732 |
1735 RegionNode* reg = new (C,2)RegionNode(2); | 1733 RegionNode* reg = new (C)RegionNode(2); |
1736 reg->set_req(1, proj2); | 1734 reg->set_req(1, proj2); |
1737 register_node(reg, loop, iff, ddepth); | 1735 register_node(reg, loop, iff, ddepth); |
1738 | 1736 |
1739 IfNode* dum_if = new (C,2)IfNode(reg, short_circuit_if(NULL, proj), iff->_prob, iff->_fcnt); | 1737 IfNode* dum_if = new (C)IfNode(reg, short_circuit_if(NULL, proj), iff->_prob, iff->_fcnt); |
1740 register_node(dum_if, loop, reg, ddepth); | 1738 register_node(dum_if, loop, reg, ddepth); |
1741 | 1739 |
1742 proj->set_req(0, dum_if); // reattach | 1740 proj->set_req(0, dum_if); // reattach |
1743 set_idom(proj, dum_if, ddepth); | 1741 set_idom(proj, dum_if, ddepth); |
1744 | 1742 |
2545 | 2543 |
2546 // Step 3: clone loop, retarget control, and insert new phis | 2544 // Step 3: clone loop, retarget control, and insert new phis |
2547 | 2545 |
2548 // Create new loop head for new phis and to hang | 2546 // Create new loop head for new phis and to hang |
2549 // the nodes being moved (sinked) from the peel region. | 2547 // the nodes being moved (sinked) from the peel region. |
2550 LoopNode* new_head = new (C, 3) LoopNode(last_peel, last_peel); | 2548 LoopNode* new_head = new (C) LoopNode(last_peel, last_peel); |
2551 new_head->set_unswitch_count(head->unswitch_count()); // Preserve | 2549 new_head->set_unswitch_count(head->unswitch_count()); // Preserve |
2552 _igvn.register_new_node_with_optimizer(new_head); | 2550 _igvn.register_new_node_with_optimizer(new_head); |
2553 assert(first_not_peeled->in(0) == last_peel, "last_peel <- first_not_peeled"); | 2551 assert(first_not_peeled->in(0) == last_peel, "last_peel <- first_not_peeled"); |
2554 first_not_peeled->set_req(0, new_head); | 2552 first_not_peeled->set_req(0, new_head); |
2555 set_loop(new_head, loop); | 2553 set_loop(new_head, loop); |
2744 // Check that use is live out the bottom. Assuming the trip-counter | 2742 // Check that use is live out the bottom. Assuming the trip-counter |
2745 // update is right at the bottom, uses of of the loop middle are ok. | 2743 // update is right at the bottom, uses of of the loop middle are ok. |
2746 if (dom_lca(exit, u_ctrl) != exit) continue; | 2744 if (dom_lca(exit, u_ctrl) != exit) continue; |
2747 // Hit! Refactor use to use the post-incremented tripcounter. | 2745 // Hit! Refactor use to use the post-incremented tripcounter. |
2748 // Compute a post-increment tripcounter. | 2746 // Compute a post-increment tripcounter. |
2749 Node *opaq = new (C, 2) Opaque2Node( C, cle->incr() ); | 2747 Node *opaq = new (C) Opaque2Node( C, cle->incr() ); |
2750 register_new_node( opaq, u_ctrl ); | 2748 register_new_node( opaq, u_ctrl ); |
2751 Node *neg_stride = _igvn.intcon(-cle->stride_con()); | 2749 Node *neg_stride = _igvn.intcon(-cle->stride_con()); |
2752 set_ctrl(neg_stride, C->root()); | 2750 set_ctrl(neg_stride, C->root()); |
2753 Node *post = new (C, 3) AddINode( opaq, neg_stride); | 2751 Node *post = new (C) AddINode( opaq, neg_stride); |
2754 register_new_node( post, u_ctrl ); | 2752 register_new_node( post, u_ctrl ); |
2755 _igvn.rehash_node_delayed(use); | 2753 _igvn.rehash_node_delayed(use); |
2756 for (uint j = 1; j < use->req(); j++) { | 2754 for (uint j = 1; j < use->req(); j++) { |
2757 if (use->in(j) == phi) | 2755 if (use->in(j) == phi) |
2758 use->set_req(j, post); | 2756 use->set_req(j, post); |