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.
35 class DivINode : public Node {
36 public:
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
48 class DivLNode : public Node {
49 public:
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
61 class DivFNode : public Node {
62 public:
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
74 class DivDNode : public Node {
75 public:
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
87 class ModINode : public Node {
88 public:
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
99 class ModLNode : public Node {
100 public:
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
111 class ModFNode : public Node {
112 public:
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
122 class ModDNode : public Node {
123 public:
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.
133 class DivModNode : public MultiNode {
134 protected:
135 DivModNode( Node *c, Node *dividend, Node *divisor );
136 public:
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.
155 class DivModINode : public DivModNode {
156 public:
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.
168 class DivModLNode : public DivModNode {
169 public:
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 };