annotate src/share/vm/opto/addnode.hpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes
author ysr
date Thu, 20 Nov 2008 12:27:41 -0800
parents ff5961f4c095
children b5fdf39b9749
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
a61af66fc99e Initial load
duke
parents:
diff changeset
2 * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // Portions of code courtesy of Clifford Click
a61af66fc99e Initial load
duke
parents:
diff changeset
26
a61af66fc99e Initial load
duke
parents:
diff changeset
27 class PhaseTransform;
a61af66fc99e Initial load
duke
parents:
diff changeset
28
a61af66fc99e Initial load
duke
parents:
diff changeset
29 //------------------------------AddNode----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // Classic Add functionality. This covers all the usual 'add' behaviors for
a61af66fc99e Initial load
duke
parents:
diff changeset
31 // an algebraic ring. Add-integer, add-float, add-double, and binary-or are
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // all inherited from this class. The various identity values are supplied
a61af66fc99e Initial load
duke
parents:
diff changeset
33 // by virtual functions.
a61af66fc99e Initial load
duke
parents:
diff changeset
34 class AddNode : public Node {
a61af66fc99e Initial load
duke
parents:
diff changeset
35 virtual uint hash() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
36 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
37 AddNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
38 init_class_id(Class_Add);
a61af66fc99e Initial load
duke
parents:
diff changeset
39 }
a61af66fc99e Initial load
duke
parents:
diff changeset
40
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // Handle algebraic identities here. If we have an identity, return the Node
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // we are equivalent to. We look for "add of zero" as an identity.
a61af66fc99e Initial load
duke
parents:
diff changeset
43 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
44
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // We also canonicalize the Node, moving constants to the right input,
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // and flatten expressions (so that 1+x+2 becomes x+3).
a61af66fc99e Initial load
duke
parents:
diff changeset
47 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
48
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // Compute a new Type for this node. Basically we just do the pre-check,
a61af66fc99e Initial load
duke
parents:
diff changeset
50 // then call the virtual add() to set the type.
a61af66fc99e Initial load
duke
parents:
diff changeset
51 virtual const Type *Value( PhaseTransform *phase ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
52
a61af66fc99e Initial load
duke
parents:
diff changeset
53 // Check if this addition involves the additive identity
a61af66fc99e Initial load
duke
parents:
diff changeset
54 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
55
a61af66fc99e Initial load
duke
parents:
diff changeset
56 // Supplied function returns the sum of the inputs.
a61af66fc99e Initial load
duke
parents:
diff changeset
57 // This also type-checks the inputs for sanity. Guaranteed never to
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check.
a61af66fc99e Initial load
duke
parents:
diff changeset
59 virtual const Type *add_ring( const Type *, const Type * ) const = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
60
a61af66fc99e Initial load
duke
parents:
diff changeset
61 // Supplied function to return the additive identity type
a61af66fc99e Initial load
duke
parents:
diff changeset
62 virtual const Type *add_id() const = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 };
a61af66fc99e Initial load
duke
parents:
diff changeset
65
a61af66fc99e Initial load
duke
parents:
diff changeset
66 //------------------------------AddINode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
67 // Add 2 integers
a61af66fc99e Initial load
duke
parents:
diff changeset
68 class AddINode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
69 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
70 AddINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
71 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
72 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
73 virtual const Type *add_id() const { return TypeInt::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
74 virtual const Type *bottom_type() const { return TypeInt::INT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
75 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
76 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
77 virtual uint ideal_reg() const { return Op_RegI; }
a61af66fc99e Initial load
duke
parents:
diff changeset
78 };
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 //------------------------------AddLNode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // Add 2 longs
a61af66fc99e Initial load
duke
parents:
diff changeset
82 class AddLNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
83 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
84 AddLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
85 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
86 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
87 virtual const Type *add_id() const { return TypeLong::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
88 virtual const Type *bottom_type() const { return TypeLong::LONG; }
a61af66fc99e Initial load
duke
parents:
diff changeset
89 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
90 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
91 virtual uint ideal_reg() const { return Op_RegL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
92 };
a61af66fc99e Initial load
duke
parents:
diff changeset
93
a61af66fc99e Initial load
duke
parents:
diff changeset
94 //------------------------------AddFNode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
95 // Add 2 floats
a61af66fc99e Initial load
duke
parents:
diff changeset
96 class AddFNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
97 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
98 AddFNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
99 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
100 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
101 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
102 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
103 virtual const Type *add_id() const { return TypeF::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
104 virtual const Type *bottom_type() const { return Type::FLOAT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
105 virtual Node *Identity( PhaseTransform *phase ) { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
106 virtual uint ideal_reg() const { return Op_RegF; }
a61af66fc99e Initial load
duke
parents:
diff changeset
107 };
a61af66fc99e Initial load
duke
parents:
diff changeset
108
a61af66fc99e Initial load
duke
parents:
diff changeset
109 //------------------------------AddDNode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // Add 2 doubles
a61af66fc99e Initial load
duke
parents:
diff changeset
111 class AddDNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
112 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
113 AddDNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
114 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
115 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
116 virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
117 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
118 virtual const Type *add_id() const { return TypeD::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
119 virtual const Type *bottom_type() const { return Type::DOUBLE; }
a61af66fc99e Initial load
duke
parents:
diff changeset
120 virtual Node *Identity( PhaseTransform *phase ) { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
121 virtual uint ideal_reg() const { return Op_RegD; }
a61af66fc99e Initial load
duke
parents:
diff changeset
122 };
a61af66fc99e Initial load
duke
parents:
diff changeset
123
a61af66fc99e Initial load
duke
parents:
diff changeset
124 //------------------------------AddPNode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
125 // Add pointer plus integer to get pointer. NOT commutative, really.
a61af66fc99e Initial load
duke
parents:
diff changeset
126 // So not really an AddNode. Lives here, because people associate it with
a61af66fc99e Initial load
duke
parents:
diff changeset
127 // an add.
a61af66fc99e Initial load
duke
parents:
diff changeset
128 class AddPNode : public Node {
a61af66fc99e Initial load
duke
parents:
diff changeset
129 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
130 enum { Control, // When is it safe to do this add?
a61af66fc99e Initial load
duke
parents:
diff changeset
131 Base, // Base oop, for GC purposes
a61af66fc99e Initial load
duke
parents:
diff changeset
132 Address, // Actually address, derived from base
a61af66fc99e Initial load
duke
parents:
diff changeset
133 Offset } ; // Offset added to address
a61af66fc99e Initial load
duke
parents:
diff changeset
134 AddPNode( Node *base, Node *ptr, Node *off ) : Node(0,base,ptr,off) {
a61af66fc99e Initial load
duke
parents:
diff changeset
135 init_class_id(Class_AddP);
a61af66fc99e Initial load
duke
parents:
diff changeset
136 }
a61af66fc99e Initial load
duke
parents:
diff changeset
137 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
138 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
139 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
140 virtual const Type *Value( PhaseTransform *phase ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
141 virtual const Type *bottom_type() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
142 virtual uint ideal_reg() const { return Op_RegP; }
a61af66fc99e Initial load
duke
parents:
diff changeset
143 Node *base_node() { assert( req() > Base, "Missing base"); return in(Base); }
a61af66fc99e Initial load
duke
parents:
diff changeset
144 static Node* Ideal_base_and_offset(Node* ptr, PhaseTransform* phase,
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // second return value:
a61af66fc99e Initial load
duke
parents:
diff changeset
146 intptr_t& offset);
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
147
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
148 // Collect the AddP offset values into the elements array, giving up
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
149 // if there are more than length.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
150 int unpack_offsets(Node* elements[], int length);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
151
0
a61af66fc99e Initial load
duke
parents:
diff changeset
152 // Do not match base-ptr edge
a61af66fc99e Initial load
duke
parents:
diff changeset
153 virtual uint match_edge(uint idx) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
154 static const Type *mach_bottom_type(const MachNode* n); // used by ad_<arch>.hpp
a61af66fc99e Initial load
duke
parents:
diff changeset
155 };
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 //------------------------------OrINode----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
158 // Logically OR 2 integers. Included with the ADD nodes because it inherits
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // all the behavior of addition on a ring.
a61af66fc99e Initial load
duke
parents:
diff changeset
160 class OrINode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
161 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
162 OrINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
163 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
164 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
165 virtual const Type *add_id() const { return TypeInt::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
166 virtual const Type *bottom_type() const { return TypeInt::INT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
167 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
168 virtual uint ideal_reg() const { return Op_RegI; }
a61af66fc99e Initial load
duke
parents:
diff changeset
169 };
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 //------------------------------OrLNode----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
172 // Logically OR 2 longs. Included with the ADD nodes because it inherits
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // all the behavior of addition on a ring.
a61af66fc99e Initial load
duke
parents:
diff changeset
174 class OrLNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
175 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
176 OrLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
177 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
178 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
179 virtual const Type *add_id() const { return TypeLong::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
180 virtual const Type *bottom_type() const { return TypeLong::LONG; }
a61af66fc99e Initial load
duke
parents:
diff changeset
181 virtual Node *Identity( PhaseTransform *phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
182 virtual uint ideal_reg() const { return Op_RegL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
183 };
a61af66fc99e Initial load
duke
parents:
diff changeset
184
a61af66fc99e Initial load
duke
parents:
diff changeset
185 //------------------------------XorINode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
186 // XOR'ing 2 integers
a61af66fc99e Initial load
duke
parents:
diff changeset
187 class XorINode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
188 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
189 XorINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
190 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
191 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
192 virtual const Type *add_id() const { return TypeInt::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
193 virtual const Type *bottom_type() const { return TypeInt::INT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
194 virtual uint ideal_reg() const { return Op_RegI; }
a61af66fc99e Initial load
duke
parents:
diff changeset
195 };
a61af66fc99e Initial load
duke
parents:
diff changeset
196
a61af66fc99e Initial load
duke
parents:
diff changeset
197 //------------------------------XorINode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // XOR'ing 2 longs
a61af66fc99e Initial load
duke
parents:
diff changeset
199 class XorLNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
200 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
201 XorLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
202 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
203 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
204 virtual const Type *add_id() const { return TypeLong::ZERO; }
a61af66fc99e Initial load
duke
parents:
diff changeset
205 virtual const Type *bottom_type() const { return TypeLong::LONG; }
a61af66fc99e Initial load
duke
parents:
diff changeset
206 virtual uint ideal_reg() const { return Op_RegL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
207 };
a61af66fc99e Initial load
duke
parents:
diff changeset
208
a61af66fc99e Initial load
duke
parents:
diff changeset
209 //------------------------------MaxNode----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // Max (or min) of 2 values. Included with the ADD nodes because it inherits
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // all the behavior of addition on a ring. Only new thing is that we allow
a61af66fc99e Initial load
duke
parents:
diff changeset
212 // 2 equal inputs to be equal.
a61af66fc99e Initial load
duke
parents:
diff changeset
213 class MaxNode : public AddNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
214 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
215 MaxNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
216 virtual int Opcode() const = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
217 };
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 //------------------------------MaxINode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
220 // Maximum of 2 integers. Included with the ADD nodes because it inherits
a61af66fc99e Initial load
duke
parents:
diff changeset
221 // all the behavior of addition on a ring.
a61af66fc99e Initial load
duke
parents:
diff changeset
222 class MaxINode : public MaxNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
223 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
224 MaxINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
225 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
226 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
227 virtual const Type *add_id() const { return TypeInt::make(min_jint); }
a61af66fc99e Initial load
duke
parents:
diff changeset
228 virtual const Type *bottom_type() const { return TypeInt::INT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
229 virtual uint ideal_reg() const { return Op_RegI; }
a61af66fc99e Initial load
duke
parents:
diff changeset
230 };
a61af66fc99e Initial load
duke
parents:
diff changeset
231
a61af66fc99e Initial load
duke
parents:
diff changeset
232 //------------------------------MinINode---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
233 // MINimum of 2 integers. Included with the ADD nodes because it inherits
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // all the behavior of addition on a ring.
a61af66fc99e Initial load
duke
parents:
diff changeset
235 class MinINode : public MaxNode {
a61af66fc99e Initial load
duke
parents:
diff changeset
236 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
237 MinINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
238 virtual int Opcode() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
239 virtual const Type *add_ring( const Type *, const Type * ) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 virtual const Type *add_id() const { return TypeInt::make(max_jint); }
a61af66fc99e Initial load
duke
parents:
diff changeset
241 virtual const Type *bottom_type() const { return TypeInt::INT; }
a61af66fc99e Initial load
duke
parents:
diff changeset
242 virtual uint ideal_reg() const { return Op_RegI; }
a61af66fc99e Initial load
duke
parents:
diff changeset
243 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
244 };