1 /*
2  * Copyright (c) 1997, 2019, 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 #ifndef SHARE_OPTO_ADDNODE_HPP
26 #define SHARE_OPTO_ADDNODE_HPP
27 
28 #include "opto/node.hpp"
29 #include "opto/opcodes.hpp"
30 #include "opto/type.hpp"
31 
32 // Portions of code courtesy of Clifford Click
33 
34 class PhaseTransform;
35 
36 //------------------------------AddNode----------------------------------------
37 // Classic Add functionality.  This covers all the usual 'add' behaviors for
38 // an algebraic ring.  Add-integer, add-float, add-double, and binary-or are
39 // all inherited from this class.  The various identity values are supplied
40 // by virtual functions.
41 class AddNode : public Node {
42   virtual uint hash() const;
43 public:
AddNode(Node * in1,Node * in2)44   AddNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {
45     init_class_id(Class_Add);
46   }
47 
48   // Handle algebraic identities here.  If we have an identity, return the Node
49   // we are equivalent to.  We look for "add of zero" as an identity.
50   virtual Node* Identity(PhaseGVN* phase);
51 
52   // We also canonicalize the Node, moving constants to the right input,
53   // and flatten expressions (so that 1+x+2 becomes x+3).
54   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
55 
56   // Compute a new Type for this node.  Basically we just do the pre-check,
57   // then call the virtual add() to set the type.
58   virtual const Type* Value(PhaseGVN* phase) const;
59 
60   // Check if this addition involves the additive identity
61   virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
62 
63   // Supplied function returns the sum of the inputs.
64   // This also type-checks the inputs for sanity.  Guaranteed never to
65   // be passed a TOP or BOTTOM type, these are filtered out by a pre-check.
66   virtual const Type *add_ring( const Type *, const Type * ) const = 0;
67 
68   // Supplied function to return the additive identity type
69   virtual const Type *add_id() const = 0;
70 
71 };
72 
73 //------------------------------AddINode---------------------------------------
74 // Add 2 integers
75 class AddINode : public AddNode {
76 public:
AddINode(Node * in1,Node * in2)77   AddINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
78   virtual int Opcode() const;
79   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const80   virtual const Type *add_id() const { return TypeInt::ZERO; }
bottom_type() const81   virtual const Type *bottom_type() const { return TypeInt::INT; }
82   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
83   virtual Node* Identity(PhaseGVN* phase);
ideal_reg() const84   virtual uint ideal_reg() const { return Op_RegI; }
85 };
86 
87 //------------------------------AddLNode---------------------------------------
88 // Add 2 longs
89 class AddLNode : public AddNode {
90 public:
AddLNode(Node * in1,Node * in2)91   AddLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
92   virtual int Opcode() const;
93   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const94   virtual const Type *add_id() const { return TypeLong::ZERO; }
bottom_type() const95   virtual const Type *bottom_type() const { return TypeLong::LONG; }
96   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
97   virtual Node* Identity(PhaseGVN* phase);
ideal_reg() const98   virtual uint ideal_reg() const { return Op_RegL; }
99 };
100 
101 //------------------------------AddFNode---------------------------------------
102 // Add 2 floats
103 class AddFNode : public AddNode {
104 public:
AddFNode(Node * in1,Node * in2)105   AddFNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
106   virtual int Opcode() const;
107   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
108   virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
109   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const110   virtual const Type *add_id() const { return TypeF::ZERO; }
bottom_type() const111   virtual const Type *bottom_type() const { return Type::FLOAT; }
Identity(PhaseGVN * phase)112   virtual Node* Identity(PhaseGVN* phase) { return this; }
ideal_reg() const113   virtual uint ideal_reg() const { return Op_RegF; }
114 };
115 
116 //------------------------------AddDNode---------------------------------------
117 // Add 2 doubles
118 class AddDNode : public AddNode {
119 public:
AddDNode(Node * in1,Node * in2)120   AddDNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
121   virtual int Opcode() const;
122   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
123   virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
124   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const125   virtual const Type *add_id() const { return TypeD::ZERO; }
bottom_type() const126   virtual const Type *bottom_type() const { return Type::DOUBLE; }
Identity(PhaseGVN * phase)127   virtual Node* Identity(PhaseGVN* phase) { return this; }
ideal_reg() const128   virtual uint ideal_reg() const { return Op_RegD; }
129 };
130 
131 //------------------------------AddPNode---------------------------------------
132 // Add pointer plus integer to get pointer.  NOT commutative, really.
133 // So not really an AddNode.  Lives here, because people associate it with
134 // an add.
135 class AddPNode : public Node {
136 public:
137   enum { Control,               // When is it safe to do this add?
138          Base,                  // Base oop, for GC purposes
139          Address,               // Actually address, derived from base
140          Offset } ;             // Offset added to address
AddPNode(Node * base,Node * ptr,Node * off)141   AddPNode( Node *base, Node *ptr, Node *off ) : Node(0,base,ptr,off) {
142     init_class_id(Class_AddP);
143   }
144   virtual int Opcode() const;
145   virtual Node* Identity(PhaseGVN* phase);
146   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
147   virtual const Type* Value(PhaseGVN* phase) const;
148   virtual const Type *bottom_type() const;
ideal_reg() const149   virtual uint  ideal_reg() const { return Op_RegP; }
base_node()150   Node         *base_node() { assert( req() > Base, "Missing base"); return in(Base); }
151   static Node* Ideal_base_and_offset(Node* ptr, PhaseTransform* phase,
152                                      // second return value:
153                                      intptr_t& offset);
154 
155   // Collect the AddP offset values into the elements array, giving up
156   // if there are more than length.
157   int unpack_offsets(Node* elements[], int length);
158 
159   // Do not match base-ptr edge
160   virtual uint match_edge(uint idx) const;
161 };
162 
163 //------------------------------OrINode----------------------------------------
164 // Logically OR 2 integers.  Included with the ADD nodes because it inherits
165 // all the behavior of addition on a ring.
166 class OrINode : public AddNode {
167 public:
OrINode(Node * in1,Node * in2)168   OrINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
169   virtual int Opcode() const;
170   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const171   virtual const Type *add_id() const { return TypeInt::ZERO; }
bottom_type() const172   virtual const Type *bottom_type() const { return TypeInt::INT; }
173   virtual Node* Identity(PhaseGVN* phase);
ideal_reg() const174   virtual uint ideal_reg() const { return Op_RegI; }
175 };
176 
177 //------------------------------OrLNode----------------------------------------
178 // Logically OR 2 longs.  Included with the ADD nodes because it inherits
179 // all the behavior of addition on a ring.
180 class OrLNode : public AddNode {
181 public:
OrLNode(Node * in1,Node * in2)182   OrLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
183   virtual int Opcode() const;
184   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const185   virtual const Type *add_id() const { return TypeLong::ZERO; }
bottom_type() const186   virtual const Type *bottom_type() const { return TypeLong::LONG; }
187   virtual Node* Identity(PhaseGVN* phase);
ideal_reg() const188   virtual uint ideal_reg() const { return Op_RegL; }
189 };
190 
191 //------------------------------XorINode---------------------------------------
192 // XOR'ing 2 integers
193 class XorINode : public AddNode {
194 public:
XorINode(Node * in1,Node * in2)195   XorINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
196   virtual int Opcode() const;
197   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const198   virtual const Type *add_id() const { return TypeInt::ZERO; }
bottom_type() const199   virtual const Type *bottom_type() const { return TypeInt::INT; }
ideal_reg() const200   virtual uint ideal_reg() const { return Op_RegI; }
201 };
202 
203 //------------------------------XorINode---------------------------------------
204 // XOR'ing 2 longs
205 class XorLNode : public AddNode {
206 public:
XorLNode(Node * in1,Node * in2)207   XorLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
208   virtual int Opcode() const;
209   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const210   virtual const Type *add_id() const { return TypeLong::ZERO; }
bottom_type() const211   virtual const Type *bottom_type() const { return TypeLong::LONG; }
ideal_reg() const212   virtual uint ideal_reg() const { return Op_RegL; }
213 };
214 
215 //------------------------------MaxNode----------------------------------------
216 // Max (or min) of 2 values.  Included with the ADD nodes because it inherits
217 // all the behavior of addition on a ring.  Only new thing is that we allow
218 // 2 equal inputs to be equal.
219 class MaxNode : public AddNode {
220 public:
MaxNode(Node * in1,Node * in2)221   MaxNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
222   virtual int Opcode() const = 0;
223 };
224 
225 //------------------------------MaxINode---------------------------------------
226 // Maximum of 2 integers.  Included with the ADD nodes because it inherits
227 // all the behavior of addition on a ring.
228 class MaxINode : public MaxNode {
229 public:
MaxINode(Node * in1,Node * in2)230   MaxINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {}
231   virtual int Opcode() const;
232   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const233   virtual const Type *add_id() const { return TypeInt::make(min_jint); }
bottom_type() const234   virtual const Type *bottom_type() const { return TypeInt::INT; }
ideal_reg() const235   virtual uint ideal_reg() const { return Op_RegI; }
236 };
237 
238 //------------------------------MinINode---------------------------------------
239 // MINimum of 2 integers.  Included with the ADD nodes because it inherits
240 // all the behavior of addition on a ring.
241 class MinINode : public MaxNode {
242 public:
MinINode(Node * in1,Node * in2)243   MinINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {}
244   virtual int Opcode() const;
245   virtual const Type *add_ring( const Type *, const Type * ) const;
add_id() const246   virtual const Type *add_id() const { return TypeInt::make(max_jint); }
bottom_type() const247   virtual const Type *bottom_type() const { return TypeInt::INT; }
ideal_reg() const248   virtual uint ideal_reg() const { return Op_RegI; }
249   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
250 };
251 
252 //------------------------------MaxFNode---------------------------------------
253 // Maximum of 2 floats.
254 class MaxFNode : public MaxNode {
255 public:
MaxFNode(Node * in1,Node * in2)256   MaxFNode(Node *in1, Node *in2) : MaxNode(in1, in2) {}
257   virtual int Opcode() const;
258   virtual const Type *add_ring(const Type*, const Type*) const;
add_id() const259   virtual const Type *add_id() const { return TypeF::NEG_INF; }
bottom_type() const260   virtual const Type *bottom_type() const { return Type::FLOAT; }
ideal_reg() const261   virtual uint ideal_reg() const { return Op_RegF; }
262 };
263 
264 //------------------------------MinFNode---------------------------------------
265 // Minimum of 2 floats.
266 class MinFNode : public MaxNode {
267 public:
MinFNode(Node * in1,Node * in2)268   MinFNode(Node *in1, Node *in2) : MaxNode(in1, in2) {}
269   virtual int Opcode() const;
270   virtual const Type *add_ring(const Type*, const Type*) const;
add_id() const271   virtual const Type *add_id() const { return TypeF::POS_INF; }
bottom_type() const272   virtual const Type *bottom_type() const { return Type::FLOAT; }
ideal_reg() const273   virtual uint ideal_reg() const { return Op_RegF; }
274 };
275 
276 //------------------------------MaxDNode---------------------------------------
277 // Maximum of 2 doubles.
278 class MaxDNode : public MaxNode {
279 public:
MaxDNode(Node * in1,Node * in2)280   MaxDNode(Node *in1, Node *in2) : MaxNode(in1, in2) {}
281   virtual int Opcode() const;
282   virtual const Type *add_ring(const Type*, const Type*) const;
add_id() const283   virtual const Type *add_id() const { return TypeD::NEG_INF; }
bottom_type() const284   virtual const Type *bottom_type() const { return Type::DOUBLE; }
ideal_reg() const285   virtual uint ideal_reg() const { return Op_RegD; }
286 };
287 
288 //------------------------------MinDNode---------------------------------------
289 // Minimum of 2 doubles.
290 class MinDNode : public MaxNode {
291 public:
MinDNode(Node * in1,Node * in2)292   MinDNode(Node *in1, Node *in2) : MaxNode(in1, in2) {}
293   virtual int Opcode() const;
294   virtual const Type *add_ring(const Type*, const Type*) const;
add_id() const295   virtual const Type *add_id() const { return TypeD::POS_INF; }
bottom_type() const296   virtual const Type *bottom_type() const { return Type::DOUBLE; }
ideal_reg() const297   virtual uint ideal_reg() const { return Op_RegD; }
298 };
299 
300 #endif // SHARE_OPTO_ADDNODE_HPP
301