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--------------------------------- |