src/share/vm/opto/loopTransform.cpp

changeset 9756
2be326848943
parent 9637
eef07cd490d4
parent 9739
bf9503046dd4
child 9806
758c07667682
equal deleted inserted replaced
9707:b87dc103bf45 9756:2be326848943
1535 return _phase->dom_lca_internal(ctrl, backedge) == ctrl; 1535 return _phase->dom_lca_internal(ctrl, backedge) == ctrl;
1536 } 1536 }
1537 1537
1538 //------------------------------adjust_limit----------------------------------- 1538 //------------------------------adjust_limit-----------------------------------
1539 // Helper function for add_constraint(). 1539 // Helper function for add_constraint().
1540 Node* PhaseIdealLoop::adjust_limit(int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl) { 1540 Node* PhaseIdealLoop::adjust_limit(int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl, bool round_up) {
1541 // Compute "I :: (limit-offset)/scale" 1541 // Compute "I :: (limit-offset)/scale"
1542 Node *con = new (C) SubINode(rc_limit, offset); 1542 Node *con = new (C) SubINode(rc_limit, offset);
1543 register_new_node(con, pre_ctrl); 1543 register_new_node(con, pre_ctrl);
1544 Node *X = new (C) DivINode(0, con, scale); 1544 Node *X = new (C) DivINode(0, con, scale);
1545 register_new_node(X, pre_ctrl); 1545 register_new_node(X, pre_ctrl);
1546
1547 // When the absolute value of scale is greater than one, the integer
1548 // division may round limit down so add one to the limit.
1549 if (round_up) {
1550 X = new (C) AddINode(X, _igvn.intcon(1));
1551 register_new_node(X, pre_ctrl);
1552 }
1546 1553
1547 // Adjust loop limit 1554 // Adjust loop limit
1548 loop_limit = (stride_con > 0) 1555 loop_limit = (stride_con > 0)
1549 ? (Node*)(new (C) MinINode(loop_limit, X)) 1556 ? (Node*)(new (C) MinINode(loop_limit, X))
1550 : (Node*)(new (C) MaxINode(loop_limit, X)); 1557 : (Node*)(new (C) MaxINode(loop_limit, X));
1582 // ) 1589 // )
1583 // 1590 //
1584 // (upper_limit-offset) may overflow or underflow. 1591 // (upper_limit-offset) may overflow or underflow.
1585 // But it is fine since main loop will either have 1592 // But it is fine since main loop will either have
1586 // less iterations or will be skipped in such case. 1593 // less iterations or will be skipped in such case.
1587 *main_limit = adjust_limit(stride_con, scale, offset, upper_limit, *main_limit, pre_ctrl); 1594 *main_limit = adjust_limit(stride_con, scale, offset, upper_limit, *main_limit, pre_ctrl, false);
1588 1595
1589 // The underflow limit: low_limit <= scale*I+offset. 1596 // The underflow limit: low_limit <= scale*I+offset.
1590 // For pre-loop compute 1597 // For pre-loop compute
1591 // NOT(scale*I+offset >= low_limit) 1598 // NOT(scale*I+offset >= low_limit)
1592 // scale*I+offset < low_limit 1599 // scale*I+offset < low_limit
1618 // since (0-min_int) == min_int. It may be fine for stride > 0 1625 // since (0-min_int) == min_int. It may be fine for stride > 0
1619 // but for stride < 0 X will be < original_limit. To avoid it 1626 // but for stride < 0 X will be < original_limit. To avoid it
1620 // max(pre_limit, original_limit) is used in do_range_check(). 1627 // max(pre_limit, original_limit) is used in do_range_check().
1621 } 1628 }
1622 // Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond); 1629 // Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond);
1623 *pre_limit = adjust_limit((-stride_con), scale, offset, low_limit, *pre_limit, pre_ctrl); 1630 *pre_limit = adjust_limit((-stride_con), scale, offset, low_limit, *pre_limit, pre_ctrl,
1631 scale_con > 1 && stride_con > 0);
1624 1632
1625 } else { // stride_con*scale_con < 0 1633 } else { // stride_con*scale_con < 0
1626 // For negative stride*scale pre-loop checks for overflow and 1634 // For negative stride*scale pre-loop checks for overflow and
1627 // post-loop for underflow. 1635 // post-loop for underflow.
1628 // 1636 //
1644 set_ctrl(one, C->root()); 1652 set_ctrl(one, C->root());
1645 1653
1646 Node *plus_one = new (C) AddINode(offset, one); 1654 Node *plus_one = new (C) AddINode(offset, one);
1647 register_new_node( plus_one, pre_ctrl ); 1655 register_new_node( plus_one, pre_ctrl );
1648 // Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond); 1656 // Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond);
1649 *pre_limit = adjust_limit((-stride_con), scale, plus_one, upper_limit, *pre_limit, pre_ctrl); 1657 *pre_limit = adjust_limit((-stride_con), scale, plus_one, upper_limit, *pre_limit, pre_ctrl,
1658 scale_con < -1 && stride_con > 0);
1650 1659
1651 if (low_limit->get_int() == -max_jint) { 1660 if (low_limit->get_int() == -max_jint) {
1652 if (!RangeLimitCheck) return; 1661 if (!RangeLimitCheck) return;
1653 // We need this guard when scale*main_limit+offset >= limit 1662 // We need this guard when scale*main_limit+offset >= limit
1654 // due to underflow. So we need execute main-loop while 1663 // due to underflow. So we need execute main-loop while
1679 // I < (low_limit-(offset+1))/scale 1688 // I < (low_limit-(offset+1))/scale
1680 // else /* scale > 0 and stride < 0 */ 1689 // else /* scale > 0 and stride < 0 */
1681 // I > (low_limit-(offset+1))/scale 1690 // I > (low_limit-(offset+1))/scale
1682 // ) 1691 // )
1683 1692
1684 *main_limit = adjust_limit(stride_con, scale, plus_one, low_limit, *main_limit, pre_ctrl); 1693 *main_limit = adjust_limit(stride_con, scale, plus_one, low_limit, *main_limit, pre_ctrl,
1694 false);
1685 } 1695 }
1686 } 1696 }
1687 1697
1688 1698
1689 //------------------------------is_scaled_iv--------------------------------- 1699 //------------------------------is_scaled_iv---------------------------------

mercurial