< prev index next >

src/hotspot/share/opto/divnode.cpp

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

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