1598 const Type* divisor_type = phase->type(divisor());
1599 if (dividend_type == Type::TOP || divisor_type == Type::TOP) {
1600 return phase->C->top();
1601 }
1602 const Type* constant_result = get_result_if_constant(dividend_type, divisor_type);
1603 if (constant_result != nullptr) {
1604 return make_tuple_of_input_state_and_constant_result(igvn, constant_result);
1605 }
1606 }
1607
1608 return CallLeafPureNode::Ideal(phase, can_reshape);
1609 }
1610
1611 /* Give a tuple node for ::Ideal to return, made of the input state (control to return addr)
1612 * and the given constant result. Idealization of projections will make sure to transparently
1613 * propagate the input state and replace the result by the said constant.
1614 */
1615 TupleNode* ModFloatingNode::make_tuple_of_input_state_and_constant_result(PhaseIterGVN* phase, const Type* con) const {
1616 Node* con_node = phase->makecon(con);
1617 TupleNode* tuple = TupleNode::make(
1618 tf()->range(),
1619 in(TypeFunc::Control),
1620 in(TypeFunc::I_O),
1621 in(TypeFunc::Memory),
1622 in(TypeFunc::FramePtr),
1623 in(TypeFunc::ReturnAdr),
1624 con_node);
1625
1626 return tuple;
1627 }
1628
1629 //=============================================================================
1630
1631 DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
1632 init_req(0, c);
1633 init_req(1, dividend);
1634 init_req(2, divisor);
1635 }
1636
1637 DivModNode* DivModNode::make(Node* div_or_mod, BasicType bt, bool is_unsigned) {
1638 assert(bt == T_INT || bt == T_LONG, "only int or long input pattern accepted");
1661 DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1662 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1663 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1664 return divmod;
1665 }
1666
1667 //------------------------------make------------------------------------------
1668 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1669 Node* n = div_or_mod;
1670 assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1671 "only div or mod input pattern accepted");
1672
1673 DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1674 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1675 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1676 return divmod;
1677 }
1678
1679 //------------------------------match------------------------------------------
1680 // return result(s) along with their RegMask info
1681 Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
1682 uint ideal_reg = proj->ideal_reg();
1683 RegMask rm;
1684 if (proj->_con == div_proj_num) {
1685 rm.assignFrom(match->divI_proj_mask());
1686 } else {
1687 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1688 rm.assignFrom(match->modI_proj_mask());
1689 }
1690 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1691 }
1692
1693
1694 //------------------------------match------------------------------------------
1695 // return result(s) along with their RegMask info
1696 Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1697 uint ideal_reg = proj->ideal_reg();
1698 RegMask rm;
1699 if (proj->_con == div_proj_num) {
1700 rm.assignFrom(match->divL_proj_mask());
1701 } else {
1702 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1703 rm.assignFrom(match->modL_proj_mask());
1704 }
1705 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1706 }
1707
1708 //------------------------------make------------------------------------------
1709 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1710 Node* n = div_or_mod;
1711 assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1712 "only div or mod input pattern accepted");
1713
1714 UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1715 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1716 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1717 return divmod;
1718 }
1719
1720 //------------------------------make------------------------------------------
1721 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1722 Node* n = div_or_mod;
1723 assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1724 "only div or mod input pattern accepted");
1725
1726 UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1727 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1728 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1729 return divmod;
1730 }
1731
1732 //------------------------------match------------------------------------------
1733 // return result(s) along with their RegMask info
1734 Node* UDivModINode::match( const ProjNode *proj, const Matcher *match ) {
1735 uint ideal_reg = proj->ideal_reg();
1736 RegMask rm;
1737 if (proj->_con == div_proj_num) {
1738 rm.assignFrom(match->divI_proj_mask());
1739 } else {
1740 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1741 rm.assignFrom(match->modI_proj_mask());
1742 }
1743 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1744 }
1745
1746
1747 //------------------------------match------------------------------------------
1748 // return result(s) along with their RegMask info
1749 Node* UDivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1750 uint ideal_reg = proj->ideal_reg();
1751 RegMask rm;
1752 if (proj->_con == div_proj_num) {
1753 rm.assignFrom(match->divL_proj_mask());
1754 } else {
1755 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1756 rm.assignFrom(match->modL_proj_mask());
1757 }
1758 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1759 }
|
1598 const Type* divisor_type = phase->type(divisor());
1599 if (dividend_type == Type::TOP || divisor_type == Type::TOP) {
1600 return phase->C->top();
1601 }
1602 const Type* constant_result = get_result_if_constant(dividend_type, divisor_type);
1603 if (constant_result != nullptr) {
1604 return make_tuple_of_input_state_and_constant_result(igvn, constant_result);
1605 }
1606 }
1607
1608 return CallLeafPureNode::Ideal(phase, can_reshape);
1609 }
1610
1611 /* Give a tuple node for ::Ideal to return, made of the input state (control to return addr)
1612 * and the given constant result. Idealization of projections will make sure to transparently
1613 * propagate the input state and replace the result by the said constant.
1614 */
1615 TupleNode* ModFloatingNode::make_tuple_of_input_state_and_constant_result(PhaseIterGVN* phase, const Type* con) const {
1616 Node* con_node = phase->makecon(con);
1617 TupleNode* tuple = TupleNode::make(
1618 tf()->range_cc(),
1619 in(TypeFunc::Control),
1620 in(TypeFunc::I_O),
1621 in(TypeFunc::Memory),
1622 in(TypeFunc::FramePtr),
1623 in(TypeFunc::ReturnAdr),
1624 con_node);
1625
1626 return tuple;
1627 }
1628
1629 //=============================================================================
1630
1631 DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
1632 init_req(0, c);
1633 init_req(1, dividend);
1634 init_req(2, divisor);
1635 }
1636
1637 DivModNode* DivModNode::make(Node* div_or_mod, BasicType bt, bool is_unsigned) {
1638 assert(bt == T_INT || bt == T_LONG, "only int or long input pattern accepted");
1661 DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1662 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1663 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1664 return divmod;
1665 }
1666
1667 //------------------------------make------------------------------------------
1668 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1669 Node* n = div_or_mod;
1670 assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1671 "only div or mod input pattern accepted");
1672
1673 DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1674 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1675 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1676 return divmod;
1677 }
1678
1679 //------------------------------match------------------------------------------
1680 // return result(s) along with their RegMask info
1681 Node *DivModINode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1682 uint ideal_reg = proj->ideal_reg();
1683 RegMask rm;
1684 if (proj->_con == div_proj_num) {
1685 rm.assignFrom(match->divI_proj_mask());
1686 } else {
1687 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1688 rm.assignFrom(match->modI_proj_mask());
1689 }
1690 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1691 }
1692
1693
1694 //------------------------------match------------------------------------------
1695 // return result(s) along with their RegMask info
1696 Node *DivModLNode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1697 uint ideal_reg = proj->ideal_reg();
1698 RegMask rm;
1699 if (proj->_con == div_proj_num) {
1700 rm.assignFrom(match->divL_proj_mask());
1701 } else {
1702 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1703 rm.assignFrom(match->modL_proj_mask());
1704 }
1705 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1706 }
1707
1708 //------------------------------make------------------------------------------
1709 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1710 Node* n = div_or_mod;
1711 assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1712 "only div or mod input pattern accepted");
1713
1714 UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1715 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1716 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1717 return divmod;
1718 }
1719
1720 //------------------------------make------------------------------------------
1721 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1722 Node* n = div_or_mod;
1723 assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1724 "only div or mod input pattern accepted");
1725
1726 UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1727 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1728 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1729 return divmod;
1730 }
1731
1732 //------------------------------match------------------------------------------
1733 // return result(s) along with their RegMask info
1734 Node* UDivModINode::match(const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1735 uint ideal_reg = proj->ideal_reg();
1736 RegMask rm;
1737 if (proj->_con == div_proj_num) {
1738 rm.assignFrom(match->divI_proj_mask());
1739 } else {
1740 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1741 rm.assignFrom(match->modI_proj_mask());
1742 }
1743 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1744 }
1745
1746
1747 //------------------------------match------------------------------------------
1748 // return result(s) along with their RegMask info
1749 Node* UDivModLNode::match( const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1750 uint ideal_reg = proj->ideal_reg();
1751 RegMask rm;
1752 if (proj->_con == div_proj_num) {
1753 rm.assignFrom(match->divL_proj_mask());
1754 } else {
1755 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1756 rm.assignFrom(match->modL_proj_mask());
1757 }
1758 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1759 }
|