1580 const Type* divisor_type = phase->type(divisor());
1581 if (dividend_type == Type::TOP || divisor_type == Type::TOP) {
1582 return phase->C->top();
1583 }
1584 const Type* constant_result = get_result_if_constant(dividend_type, divisor_type);
1585 if (constant_result != nullptr) {
1586 return make_tuple_of_input_state_and_constant_result(igvn, constant_result);
1587 }
1588 }
1589
1590 return CallLeafPureNode::Ideal(phase, can_reshape);
1591 }
1592
1593 /* Give a tuple node for ::Ideal to return, made of the input state (control to return addr)
1594 * and the given constant result. Idealization of projections will make sure to transparently
1595 * propagate the input state and replace the result by the said constant.
1596 */
1597 TupleNode* ModFloatingNode::make_tuple_of_input_state_and_constant_result(PhaseIterGVN* phase, const Type* con) const {
1598 Node* con_node = phase->makecon(con);
1599 TupleNode* tuple = TupleNode::make(
1600 tf()->range(),
1601 in(TypeFunc::Control),
1602 in(TypeFunc::I_O),
1603 in(TypeFunc::Memory),
1604 in(TypeFunc::FramePtr),
1605 in(TypeFunc::ReturnAdr),
1606 con_node);
1607
1608 return tuple;
1609 }
1610
1611 //=============================================================================
1612
1613 DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
1614 init_req(0, c);
1615 init_req(1, dividend);
1616 init_req(2, divisor);
1617 }
1618
1619 DivModNode* DivModNode::make(Node* div_or_mod, BasicType bt, bool is_unsigned) {
1620 assert(bt == T_INT || bt == T_LONG, "only int or long input pattern accepted");
1643 DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1644 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1645 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1646 return divmod;
1647 }
1648
1649 //------------------------------make------------------------------------------
1650 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1651 Node* n = div_or_mod;
1652 assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1653 "only div or mod input pattern accepted");
1654
1655 DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1656 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1657 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1658 return divmod;
1659 }
1660
1661 //------------------------------match------------------------------------------
1662 // return result(s) along with their RegMask info
1663 Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
1664 uint ideal_reg = proj->ideal_reg();
1665 RegMask rm;
1666 if (proj->_con == div_proj_num) {
1667 rm.assignFrom(match->divI_proj_mask());
1668 } else {
1669 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1670 rm.assignFrom(match->modI_proj_mask());
1671 }
1672 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1673 }
1674
1675
1676 //------------------------------match------------------------------------------
1677 // return result(s) along with their RegMask info
1678 Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1679 uint ideal_reg = proj->ideal_reg();
1680 RegMask rm;
1681 if (proj->_con == div_proj_num) {
1682 rm.assignFrom(match->divL_proj_mask());
1683 } else {
1684 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1685 rm.assignFrom(match->modL_proj_mask());
1686 }
1687 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1688 }
1689
1690 //------------------------------make------------------------------------------
1691 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1692 Node* n = div_or_mod;
1693 assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1694 "only div or mod input pattern accepted");
1695
1696 UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1697 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1698 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1699 return divmod;
1700 }
1701
1702 //------------------------------make------------------------------------------
1703 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1704 Node* n = div_or_mod;
1705 assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1706 "only div or mod input pattern accepted");
1707
1708 UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1709 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1710 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1711 return divmod;
1712 }
1713
1714 //------------------------------match------------------------------------------
1715 // return result(s) along with their RegMask info
1716 Node* UDivModINode::match( const ProjNode *proj, const Matcher *match ) {
1717 uint ideal_reg = proj->ideal_reg();
1718 RegMask rm;
1719 if (proj->_con == div_proj_num) {
1720 rm.assignFrom(match->divI_proj_mask());
1721 } else {
1722 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1723 rm.assignFrom(match->modI_proj_mask());
1724 }
1725 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1726 }
1727
1728
1729 //------------------------------match------------------------------------------
1730 // return result(s) along with their RegMask info
1731 Node* UDivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1732 uint ideal_reg = proj->ideal_reg();
1733 RegMask rm;
1734 if (proj->_con == div_proj_num) {
1735 rm.assignFrom(match->divL_proj_mask());
1736 } else {
1737 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1738 rm.assignFrom(match->modL_proj_mask());
1739 }
1740 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1741 }
|
1580 const Type* divisor_type = phase->type(divisor());
1581 if (dividend_type == Type::TOP || divisor_type == Type::TOP) {
1582 return phase->C->top();
1583 }
1584 const Type* constant_result = get_result_if_constant(dividend_type, divisor_type);
1585 if (constant_result != nullptr) {
1586 return make_tuple_of_input_state_and_constant_result(igvn, constant_result);
1587 }
1588 }
1589
1590 return CallLeafPureNode::Ideal(phase, can_reshape);
1591 }
1592
1593 /* Give a tuple node for ::Ideal to return, made of the input state (control to return addr)
1594 * and the given constant result. Idealization of projections will make sure to transparently
1595 * propagate the input state and replace the result by the said constant.
1596 */
1597 TupleNode* ModFloatingNode::make_tuple_of_input_state_and_constant_result(PhaseIterGVN* phase, const Type* con) const {
1598 Node* con_node = phase->makecon(con);
1599 TupleNode* tuple = TupleNode::make(
1600 tf()->range_cc(),
1601 in(TypeFunc::Control),
1602 in(TypeFunc::I_O),
1603 in(TypeFunc::Memory),
1604 in(TypeFunc::FramePtr),
1605 in(TypeFunc::ReturnAdr),
1606 con_node);
1607
1608 return tuple;
1609 }
1610
1611 //=============================================================================
1612
1613 DivModNode::DivModNode( Node *c, Node *dividend, Node *divisor ) : MultiNode(3) {
1614 init_req(0, c);
1615 init_req(1, dividend);
1616 init_req(2, divisor);
1617 }
1618
1619 DivModNode* DivModNode::make(Node* div_or_mod, BasicType bt, bool is_unsigned) {
1620 assert(bt == T_INT || bt == T_LONG, "only int or long input pattern accepted");
1643 DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1644 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1645 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1646 return divmod;
1647 }
1648
1649 //------------------------------make------------------------------------------
1650 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1651 Node* n = div_or_mod;
1652 assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1653 "only div or mod input pattern accepted");
1654
1655 DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1656 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1657 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1658 return divmod;
1659 }
1660
1661 //------------------------------match------------------------------------------
1662 // return result(s) along with their RegMask info
1663 Node *DivModINode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1664 uint ideal_reg = proj->ideal_reg();
1665 RegMask rm;
1666 if (proj->_con == div_proj_num) {
1667 rm.assignFrom(match->divI_proj_mask());
1668 } else {
1669 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1670 rm.assignFrom(match->modI_proj_mask());
1671 }
1672 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1673 }
1674
1675
1676 //------------------------------match------------------------------------------
1677 // return result(s) along with their RegMask info
1678 Node *DivModLNode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1679 uint ideal_reg = proj->ideal_reg();
1680 RegMask rm;
1681 if (proj->_con == div_proj_num) {
1682 rm.assignFrom(match->divL_proj_mask());
1683 } else {
1684 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1685 rm.assignFrom(match->modL_proj_mask());
1686 }
1687 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1688 }
1689
1690 //------------------------------make------------------------------------------
1691 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1692 Node* n = div_or_mod;
1693 assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1694 "only div or mod input pattern accepted");
1695
1696 UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1697 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1698 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1699 return divmod;
1700 }
1701
1702 //------------------------------make------------------------------------------
1703 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1704 Node* n = div_or_mod;
1705 assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1706 "only div or mod input pattern accepted");
1707
1708 UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1709 Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
1710 Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
1711 return divmod;
1712 }
1713
1714 //------------------------------match------------------------------------------
1715 // return result(s) along with their RegMask info
1716 Node* UDivModINode::match(const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1717 uint ideal_reg = proj->ideal_reg();
1718 RegMask rm;
1719 if (proj->_con == div_proj_num) {
1720 rm.assignFrom(match->divI_proj_mask());
1721 } else {
1722 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1723 rm.assignFrom(match->modI_proj_mask());
1724 }
1725 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1726 }
1727
1728
1729 //------------------------------match------------------------------------------
1730 // return result(s) along with their RegMask info
1731 Node* UDivModLNode::match( const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1732 uint ideal_reg = proj->ideal_reg();
1733 RegMask rm;
1734 if (proj->_con == div_proj_num) {
1735 rm.assignFrom(match->divL_proj_mask());
1736 } else {
1737 assert(proj->_con == mod_proj_num, "must be div or mod projection");
1738 rm.assignFrom(match->modL_proj_mask());
1739 }
1740 return new MachProjNode(this, proj->_con, rm, ideal_reg);
1741 }
|