< prev index next >

src/hotspot/share/opto/divnode.cpp

Print this page 
1641   DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1642   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1643   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1644   return divmod;
1645 }
1646 
1647 //------------------------------make------------------------------------------
1648 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1649   Node* n = div_or_mod;
1650   assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1651          "only div or mod input pattern accepted");
1652 
1653   DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1654   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1655   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1656   return divmod;
1657 }
1658 
1659 //------------------------------match------------------------------------------
1660 // return result(s) along with their RegMask info
1661 Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
1662   uint ideal_reg = proj->ideal_reg();
1663   RegMask rm;
1664   if (proj->_con == first_proj_num) {
1665     rm.assignFrom(match->firstI_proj_mask());
1666   } else {
1667     assert(proj->_con == second_proj_num, "must be div or mod projection");
1668     rm.assignFrom(match->secondI_proj_mask());
1669   }
1670   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1671 }
1672 
1673 
1674 //------------------------------match------------------------------------------
1675 // return result(s) along with their RegMask info
1676 Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1677   uint ideal_reg = proj->ideal_reg();
1678   RegMask rm;
1679   if (proj->_con == first_proj_num) {
1680     rm.assignFrom(match->firstL_proj_mask());
1681   } else {
1682     assert(proj->_con == second_proj_num, "must be div or mod projection");
1683     rm.assignFrom(match->secondL_proj_mask());
1684   }
1685   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1686 }
1687 
1688 //------------------------------make------------------------------------------
1689 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1690   Node* n = div_or_mod;
1691   assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1692          "only div or mod input pattern accepted");
1693 
1694   UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1695   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1696   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1697   return divmod;
1698 }
1699 
1700 //------------------------------make------------------------------------------
1701 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1702   Node* n = div_or_mod;
1703   assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1704          "only div or mod input pattern accepted");
1705 
1706   UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1707   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1708   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1709   return divmod;
1710 }
1711 
1712 //------------------------------match------------------------------------------
1713 // return result(s) along with their RegMask info
1714 Node* UDivModINode::match( const ProjNode *proj, const Matcher *match ) {
1715   uint ideal_reg = proj->ideal_reg();
1716   RegMask rm;
1717   if (proj->_con == first_proj_num) {
1718     rm.assignFrom(match->firstI_proj_mask());
1719   } else {
1720     assert(proj->_con == second_proj_num, "must be div or mod projection");
1721     rm.assignFrom(match->secondI_proj_mask());
1722   }
1723   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1724 }
1725 
1726 
1727 //------------------------------match------------------------------------------
1728 // return result(s) along with their RegMask info
1729 Node* UDivModLNode::match( const ProjNode *proj, const Matcher *match ) {
1730   uint ideal_reg = proj->ideal_reg();
1731   RegMask rm;
1732   if (proj->_con == first_proj_num) {
1733     rm.assignFrom(match->firstL_proj_mask());
1734   } else {
1735     assert(proj->_con == second_proj_num, "must be div or mod projection");
1736     rm.assignFrom(match->secondL_proj_mask());
1737   }
1738   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1739 }

1641   DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
1642   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1643   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1644   return divmod;
1645 }
1646 
1647 //------------------------------make------------------------------------------
1648 DivModLNode* DivModLNode::make(Node* div_or_mod) {
1649   Node* n = div_or_mod;
1650   assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
1651          "only div or mod input pattern accepted");
1652 
1653   DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
1654   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1655   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1656   return divmod;
1657 }
1658 
1659 //------------------------------match------------------------------------------
1660 // return result(s) along with their RegMask info
1661 Node *DivModINode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1662   uint ideal_reg = proj->ideal_reg();
1663   RegMask rm;
1664   if (proj->_con == first_proj_num) {
1665     rm.assignFrom(match->firstI_proj_mask());
1666   } else {
1667     assert(proj->_con == second_proj_num, "must be div or mod projection");
1668     rm.assignFrom(match->secondI_proj_mask());
1669   }
1670   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1671 }
1672 
1673 
1674 //------------------------------match------------------------------------------
1675 // return result(s) along with their RegMask info
1676 Node *DivModLNode::match(const ProjNode *proj, const Matcher *match, const RegMask* mask) {
1677   uint ideal_reg = proj->ideal_reg();
1678   RegMask rm;
1679   if (proj->_con == first_proj_num) {
1680     rm.assignFrom(match->firstL_proj_mask());
1681   } else {
1682     assert(proj->_con == second_proj_num, "must be div or mod projection");
1683     rm.assignFrom(match->secondL_proj_mask());
1684   }
1685   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1686 }
1687 
1688 //------------------------------make------------------------------------------
1689 UDivModINode* UDivModINode::make(Node* div_or_mod) {
1690   Node* n = div_or_mod;
1691   assert(n->Opcode() == Op_UDivI || n->Opcode() == Op_UModI,
1692          "only div or mod input pattern accepted");
1693 
1694   UDivModINode* divmod = new UDivModINode(n->in(0), n->in(1), n->in(2));
1695   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1696   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1697   return divmod;
1698 }
1699 
1700 //------------------------------make------------------------------------------
1701 UDivModLNode* UDivModLNode::make(Node* div_or_mod) {
1702   Node* n = div_or_mod;
1703   assert(n->Opcode() == Op_UDivL || n->Opcode() == Op_UModL,
1704          "only div or mod input pattern accepted");
1705 
1706   UDivModLNode* divmod = new UDivModLNode(n->in(0), n->in(1), n->in(2));
1707   Node*        dproj  = new ProjNode(divmod, DivModNode::first_proj_num);
1708   Node*        mproj  = new ProjNode(divmod, DivModNode::second_proj_num);
1709   return divmod;
1710 }
1711 
1712 //------------------------------match------------------------------------------
1713 // return result(s) along with their RegMask info
1714 Node* UDivModINode::match(const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1715   uint ideal_reg = proj->ideal_reg();
1716   RegMask rm;
1717   if (proj->_con == first_proj_num) {
1718     rm.assignFrom(match->firstI_proj_mask());
1719   } else {
1720     assert(proj->_con == second_proj_num, "must be div or mod projection");
1721     rm.assignFrom(match->secondI_proj_mask());
1722   }
1723   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1724 }
1725 
1726 
1727 //------------------------------match------------------------------------------
1728 // return result(s) along with their RegMask info
1729 Node* UDivModLNode::match( const ProjNode* proj, const Matcher* match, const RegMask* mask) {
1730   uint ideal_reg = proj->ideal_reg();
1731   RegMask rm;
1732   if (proj->_con == first_proj_num) {
1733     rm.assignFrom(match->firstL_proj_mask());
1734   } else {
1735     assert(proj->_con == second_proj_num, "must be div or mod projection");
1736     rm.assignFrom(match->secondL_proj_mask());
1737   }
1738   return new MachProjNode(this, proj->_con, rm, ideal_reg);
1739 }
< prev index next >