divnode.hpp revision 1472:c18cbe5936b8
1/* 2 * Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25// Portions of code courtesy of Clifford Click 26 27// Optimization - Graph Style 28 29 30//------------------------------DivINode--------------------------------------- 31// Integer division 32// Note: this is division as defined by JVMS, i.e., MinInt/-1 == MinInt. 33// On processors which don't naturally support this special case (e.g., x86), 34// the matcher or runtime system must take care of this. 35class DivINode : public Node { 36public: 37 DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} 38 virtual int Opcode() const; 39 virtual Node *Identity( PhaseTransform *phase ); 40 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 41 virtual const Type *Value( PhaseTransform *phase ) const; 42 virtual const Type *bottom_type() const { return TypeInt::INT; } 43 virtual uint ideal_reg() const { return Op_RegI; } 44}; 45 46//------------------------------DivLNode--------------------------------------- 47// Long division 48class DivLNode : public Node { 49public: 50 DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} 51 virtual int Opcode() const; 52 virtual Node *Identity( PhaseTransform *phase ); 53 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 54 virtual const Type *Value( PhaseTransform *phase ) const; 55 virtual const Type *bottom_type() const { return TypeLong::LONG; } 56 virtual uint ideal_reg() const { return Op_RegL; } 57}; 58 59//------------------------------DivFNode--------------------------------------- 60// Float division 61class DivFNode : public Node { 62public: 63 DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {} 64 virtual int Opcode() const; 65 virtual Node *Identity( PhaseTransform *phase ); 66 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 67 virtual const Type *Value( PhaseTransform *phase ) const; 68 virtual const Type *bottom_type() const { return Type::FLOAT; } 69 virtual uint ideal_reg() const { return Op_RegF; } 70}; 71 72//------------------------------DivDNode--------------------------------------- 73// Double division 74class DivDNode : public Node { 75public: 76 DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {} 77 virtual int Opcode() const; 78 virtual Node *Identity( PhaseTransform *phase ); 79 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 80 virtual const Type *Value( PhaseTransform *phase ) const; 81 virtual const Type *bottom_type() const { return Type::DOUBLE; } 82 virtual uint ideal_reg() const { return Op_RegD; } 83}; 84 85//------------------------------ModINode--------------------------------------- 86// Integer modulus 87class ModINode : public Node { 88public: 89 ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} 90 virtual int Opcode() const; 91 virtual const Type *Value( PhaseTransform *phase ) const; 92 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 93 virtual const Type *bottom_type() const { return TypeInt::INT; } 94 virtual uint ideal_reg() const { return Op_RegI; } 95}; 96 97//------------------------------ModLNode--------------------------------------- 98// Long modulus 99class ModLNode : public Node { 100public: 101 ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} 102 virtual int Opcode() const; 103 virtual const Type *Value( PhaseTransform *phase ) const; 104 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 105 virtual const Type *bottom_type() const { return TypeLong::LONG; } 106 virtual uint ideal_reg() const { return Op_RegL; } 107}; 108 109//------------------------------ModFNode--------------------------------------- 110// Float Modulus 111class ModFNode : public Node { 112public: 113 ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} 114 virtual int Opcode() const; 115 virtual const Type *Value( PhaseTransform *phase ) const; 116 virtual const Type *bottom_type() const { return Type::FLOAT; } 117 virtual uint ideal_reg() const { return Op_RegF; } 118}; 119 120//------------------------------ModDNode--------------------------------------- 121// Double Modulus 122class ModDNode : public Node { 123public: 124 ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} 125 virtual int Opcode() const; 126 virtual const Type *Value( PhaseTransform *phase ) const; 127 virtual const Type *bottom_type() const { return Type::DOUBLE; } 128 virtual uint ideal_reg() const { return Op_RegD; } 129}; 130 131//------------------------------DivModNode--------------------------------------- 132// Division with remainder result. 133class DivModNode : public MultiNode { 134protected: 135 DivModNode( Node *c, Node *dividend, Node *divisor ); 136public: 137 enum { 138 div_proj_num = 0, // quotient 139 mod_proj_num = 1 // remainder 140 }; 141 virtual int Opcode() const; 142 virtual Node *Identity( PhaseTransform *phase ) { return this; } 143 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; } 144 virtual const Type *Value( PhaseTransform *phase ) const { return bottom_type(); } 145 virtual uint hash() const { return Node::hash(); } 146 virtual bool is_CFG() const { return false; } 147 virtual uint ideal_reg() const { return NotAMachineReg; } 148 149 ProjNode* div_proj() { return proj_out(div_proj_num); } 150 ProjNode* mod_proj() { return proj_out(mod_proj_num); } 151}; 152 153//------------------------------DivModINode--------------------------------------- 154// Integer division with remainder result. 155class DivModINode : public DivModNode { 156public: 157 DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} 158 virtual int Opcode() const; 159 virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; } 160 virtual Node *match( const ProjNode *proj, const Matcher *m ); 161 162 // Make a divmod and associated projections from a div or mod. 163 static DivModINode* make(Compile* C, Node* div_or_mod); 164}; 165 166//------------------------------DivModLNode--------------------------------------- 167// Long division with remainder result. 168class DivModLNode : public DivModNode { 169public: 170 DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} 171 virtual int Opcode() const; 172 virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; } 173 virtual Node *match( const ProjNode *proj, const Matcher *m ); 174 175 // Make a divmod and associated projections from a div or mod. 176 static DivModLNode* make(Compile* C, Node* div_or_mod); 177}; 178