Mercurial > hg > truffle
annotate src/share/vm/opto/subnode.hpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
author | ysr |
---|---|
date | Tue, 07 Dec 2010 21:55:53 -0800 |
parents | f95d63e2154a |
children | f1d6640088a1 |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1396
diff
changeset
|
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1396
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1396
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1396
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_OPTO_SUBNODE_HPP |
26 #define SHARE_VM_OPTO_SUBNODE_HPP | |
27 | |
28 #include "opto/node.hpp" | |
29 #include "opto/opcodes.hpp" | |
30 #include "opto/type.hpp" | |
31 | |
0 | 32 // Portions of code courtesy of Clifford Click |
33 | |
34 //------------------------------SUBNode---------------------------------------- | |
35 // Class SUBTRACTION functionality. This covers all the usual 'subtract' | |
36 // behaviors. Subtract-integer, -float, -double, binary xor, compare-integer, | |
37 // -float, and -double are all inherited from this class. The compare | |
38 // functions behave like subtract functions, except that all negative answers | |
39 // are compressed into -1, and all positive answers compressed to 1. | |
40 class SubNode : public Node { | |
41 public: | |
42 SubNode( Node *in1, Node *in2 ) : Node(0,in1,in2) { | |
43 init_class_id(Class_Sub); | |
44 } | |
45 | |
46 // Handle algebraic identities here. If we have an identity, return the Node | |
47 // we are equivalent to. We look for "add of zero" as an identity. | |
48 virtual Node *Identity( PhaseTransform *phase ); | |
49 | |
50 // Compute a new Type for this node. Basically we just do the pre-check, | |
51 // then call the virtual add() to set the type. | |
52 virtual const Type *Value( PhaseTransform *phase ) const; | |
53 | |
54 // Supplied function returns the subtractend of the inputs. | |
55 // This also type-checks the inputs for sanity. Guaranteed never to | |
56 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check. | |
57 virtual const Type *sub( const Type *, const Type * ) const = 0; | |
58 | |
59 // Supplied function to return the additive identity type. | |
60 // This is returned whenever the subtracts inputs are the same. | |
61 virtual const Type *add_id() const = 0; | |
62 | |
63 }; | |
64 | |
65 | |
66 // NOTE: SubINode should be taken away and replaced by add and negate | |
67 //------------------------------SubINode--------------------------------------- | |
68 // Subtract 2 integers | |
69 class SubINode : public SubNode { | |
70 public: | |
71 SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} | |
72 virtual int Opcode() const; | |
73 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
74 virtual const Type *sub( const Type *, const Type * ) const; | |
75 const Type *add_id() const { return TypeInt::ZERO; } | |
76 const Type *bottom_type() const { return TypeInt::INT; } | |
77 virtual uint ideal_reg() const { return Op_RegI; } | |
78 }; | |
79 | |
80 //------------------------------SubLNode--------------------------------------- | |
81 // Subtract 2 integers | |
82 class SubLNode : public SubNode { | |
83 public: | |
84 SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} | |
85 virtual int Opcode() const; | |
86 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
87 virtual const Type *sub( const Type *, const Type * ) const; | |
88 const Type *add_id() const { return TypeLong::ZERO; } | |
89 const Type *bottom_type() const { return TypeLong::LONG; } | |
90 virtual uint ideal_reg() const { return Op_RegL; } | |
91 }; | |
92 | |
93 // NOTE: SubFPNode should be taken away and replaced by add and negate | |
94 //------------------------------SubFPNode-------------------------------------- | |
95 // Subtract 2 floats or doubles | |
96 class SubFPNode : public SubNode { | |
97 protected: | |
98 SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} | |
99 public: | |
100 const Type *Value( PhaseTransform *phase ) const; | |
101 }; | |
102 | |
103 // NOTE: SubFNode should be taken away and replaced by add and negate | |
104 //------------------------------SubFNode--------------------------------------- | |
105 // Subtract 2 doubles | |
106 class SubFNode : public SubFPNode { | |
107 public: | |
108 SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} | |
109 virtual int Opcode() const; | |
110 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
111 virtual const Type *sub( const Type *, const Type * ) const; | |
112 const Type *add_id() const { return TypeF::ZERO; } | |
113 const Type *bottom_type() const { return Type::FLOAT; } | |
114 virtual uint ideal_reg() const { return Op_RegF; } | |
115 }; | |
116 | |
117 // NOTE: SubDNode should be taken away and replaced by add and negate | |
118 //------------------------------SubDNode--------------------------------------- | |
119 // Subtract 2 doubles | |
120 class SubDNode : public SubFPNode { | |
121 public: | |
122 SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} | |
123 virtual int Opcode() const; | |
124 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
125 virtual const Type *sub( const Type *, const Type * ) const; | |
126 const Type *add_id() const { return TypeD::ZERO; } | |
127 const Type *bottom_type() const { return Type::DOUBLE; } | |
128 virtual uint ideal_reg() const { return Op_RegD; } | |
129 }; | |
130 | |
131 //------------------------------CmpNode--------------------------------------- | |
132 // Compare 2 values, returning condition codes (-1, 0 or 1). | |
133 class CmpNode : public SubNode { | |
134 public: | |
135 CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) { | |
136 init_class_id(Class_Cmp); | |
137 } | |
138 virtual Node *Identity( PhaseTransform *phase ); | |
139 const Type *add_id() const { return TypeInt::ZERO; } | |
140 const Type *bottom_type() const { return TypeInt::CC; } | |
141 virtual uint ideal_reg() const { return Op_RegFlags; } | |
142 }; | |
143 | |
144 //------------------------------CmpINode--------------------------------------- | |
145 // Compare 2 signed values, returning condition codes (-1, 0 or 1). | |
146 class CmpINode : public CmpNode { | |
147 public: | |
148 CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
149 virtual int Opcode() const; | |
150 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
151 virtual const Type *sub( const Type *, const Type * ) const; | |
152 }; | |
153 | |
154 //------------------------------CmpUNode--------------------------------------- | |
155 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1). | |
156 class CmpUNode : public CmpNode { | |
157 public: | |
158 CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
159 virtual int Opcode() const; | |
160 virtual const Type *sub( const Type *, const Type * ) const; | |
161 }; | |
162 | |
163 //------------------------------CmpPNode--------------------------------------- | |
164 // Compare 2 pointer values, returning condition codes (-1, 0 or 1). | |
165 class CmpPNode : public CmpNode { | |
166 public: | |
167 CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
168 virtual int Opcode() const; | |
169 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
170 virtual const Type *sub( const Type *, const Type * ) const; | |
171 }; | |
172 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
173 //------------------------------CmpNNode-------------------------------------- |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
174 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1). |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
175 class CmpNNode : public CmpNode { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
176 public: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
177 CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
178 virtual int Opcode() const; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
179 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
180 virtual const Type *sub( const Type *, const Type * ) const; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
181 }; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
182 |
0 | 183 //------------------------------CmpLNode--------------------------------------- |
184 // Compare 2 long values, returning condition codes (-1, 0 or 1). | |
185 class CmpLNode : public CmpNode { | |
186 public: | |
187 CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
188 virtual int Opcode() const; | |
189 virtual const Type *sub( const Type *, const Type * ) const; | |
190 }; | |
191 | |
192 //------------------------------CmpL3Node-------------------------------------- | |
193 // Compare 2 long values, returning integer value (-1, 0 or 1). | |
194 class CmpL3Node : public CmpLNode { | |
195 public: | |
196 CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) { | |
197 // Since it is not consumed by Bools, it is not really a Cmp. | |
198 init_class_id(Class_Sub); | |
199 } | |
200 virtual int Opcode() const; | |
201 virtual uint ideal_reg() const { return Op_RegI; } | |
202 }; | |
203 | |
204 //------------------------------CmpFNode--------------------------------------- | |
205 // Compare 2 float values, returning condition codes (-1, 0 or 1). | |
206 // This implements the Java bytecode fcmpl, so unordered returns -1. | |
207 // Operands may not commute. | |
208 class CmpFNode : public CmpNode { | |
209 public: | |
210 CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
211 virtual int Opcode() const; | |
212 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } | |
213 const Type *Value( PhaseTransform *phase ) const; | |
214 }; | |
215 | |
216 //------------------------------CmpF3Node-------------------------------------- | |
217 // Compare 2 float values, returning integer value (-1, 0 or 1). | |
218 // This implements the Java bytecode fcmpl, so unordered returns -1. | |
219 // Operands may not commute. | |
220 class CmpF3Node : public CmpFNode { | |
221 public: | |
222 CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) { | |
223 // Since it is not consumed by Bools, it is not really a Cmp. | |
224 init_class_id(Class_Sub); | |
225 } | |
226 virtual int Opcode() const; | |
227 // Since it is not consumed by Bools, it is not really a Cmp. | |
228 virtual uint ideal_reg() const { return Op_RegI; } | |
229 }; | |
230 | |
231 | |
232 //------------------------------CmpDNode--------------------------------------- | |
233 // Compare 2 double values, returning condition codes (-1, 0 or 1). | |
234 // This implements the Java bytecode dcmpl, so unordered returns -1. | |
235 // Operands may not commute. | |
236 class CmpDNode : public CmpNode { | |
237 public: | |
238 CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} | |
239 virtual int Opcode() const; | |
240 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } | |
241 const Type *Value( PhaseTransform *phase ) const; | |
242 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
243 }; | |
244 | |
245 //------------------------------CmpD3Node-------------------------------------- | |
246 // Compare 2 double values, returning integer value (-1, 0 or 1). | |
247 // This implements the Java bytecode dcmpl, so unordered returns -1. | |
248 // Operands may not commute. | |
249 class CmpD3Node : public CmpDNode { | |
250 public: | |
251 CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) { | |
252 // Since it is not consumed by Bools, it is not really a Cmp. | |
253 init_class_id(Class_Sub); | |
254 } | |
255 virtual int Opcode() const; | |
256 virtual uint ideal_reg() const { return Op_RegI; } | |
257 }; | |
258 | |
259 | |
260 //------------------------------BoolTest--------------------------------------- | |
261 // Convert condition codes to a boolean test value (0 or -1). | |
262 // We pick the values as 3 bits; the low order 2 bits we compare against the | |
263 // condition codes, the high bit flips the sense of the result. | |
264 struct BoolTest VALUE_OBJ_CLASS_SPEC { | |
265 enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, illegal = 8 }; | |
266 mask _test; | |
267 BoolTest( mask btm ) : _test(btm) {} | |
268 const Type *cc2logical( const Type *CC ) const; | |
269 // Commute the test. I use a small table lookup. The table is created as | |
270 // a simple char array where each element is the ASCII version of a 'mask' | |
271 // enum from above. | |
272 mask commute( ) const { return mask("038147858"[_test]-'0'); } | |
273 mask negate( ) const { return mask(_test^4); } | |
274 bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le); } | |
275 #ifndef PRODUCT | |
276 void dump_on(outputStream *st) const; | |
277 #endif | |
278 }; | |
279 | |
280 //------------------------------BoolNode--------------------------------------- | |
281 // A Node to convert a Condition Codes to a Logical result. | |
282 class BoolNode : public Node { | |
283 virtual uint hash() const; | |
284 virtual uint cmp( const Node &n ) const; | |
285 virtual uint size_of() const; | |
286 public: | |
287 const BoolTest _test; | |
288 BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) { | |
289 init_class_id(Class_Bool); | |
290 } | |
291 // Convert an arbitrary int value to a Bool or other suitable predicate. | |
292 static Node* make_predicate(Node* test_value, PhaseGVN* phase); | |
293 // Convert self back to an integer value. | |
294 Node* as_int_value(PhaseGVN* phase); | |
295 // Invert sense of self, returning new Bool. | |
296 BoolNode* negate(PhaseGVN* phase); | |
297 virtual int Opcode() const; | |
298 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
299 virtual const Type *Value( PhaseTransform *phase ) const; | |
300 virtual const Type *bottom_type() const { return TypeInt::BOOL; } | |
301 uint match_edge(uint idx) const { return 0; } | |
302 virtual uint ideal_reg() const { return Op_RegI; } | |
303 | |
304 bool is_counted_loop_exit_test(); | |
305 #ifndef PRODUCT | |
306 virtual void dump_spec(outputStream *st) const; | |
307 #endif | |
308 }; | |
309 | |
310 //------------------------------AbsNode---------------------------------------- | |
311 // Abstract class for absolute value. Mostly used to get a handy wrapper | |
312 // for finding this pattern in the graph. | |
313 class AbsNode : public Node { | |
314 public: | |
315 AbsNode( Node *value ) : Node(0,value) {} | |
316 }; | |
317 | |
318 //------------------------------AbsINode--------------------------------------- | |
319 // Absolute value an integer. Since a naive graph involves control flow, we | |
320 // "match" it in the ideal world (so the control flow can be removed). | |
321 class AbsINode : public AbsNode { | |
322 public: | |
323 AbsINode( Node *in1 ) : AbsNode(in1) {} | |
324 virtual int Opcode() const; | |
325 const Type *bottom_type() const { return TypeInt::INT; } | |
326 virtual uint ideal_reg() const { return Op_RegI; } | |
327 }; | |
328 | |
329 //------------------------------AbsFNode--------------------------------------- | |
330 // Absolute value a float, a common float-point idiom with a cheap hardware | |
331 // implemention on most chips. Since a naive graph involves control flow, we | |
332 // "match" it in the ideal world (so the control flow can be removed). | |
333 class AbsFNode : public AbsNode { | |
334 public: | |
335 AbsFNode( Node *in1 ) : AbsNode(in1) {} | |
336 virtual int Opcode() const; | |
337 const Type *bottom_type() const { return Type::FLOAT; } | |
338 virtual uint ideal_reg() const { return Op_RegF; } | |
339 }; | |
340 | |
341 //------------------------------AbsDNode--------------------------------------- | |
342 // Absolute value a double, a common float-point idiom with a cheap hardware | |
343 // implemention on most chips. Since a naive graph involves control flow, we | |
344 // "match" it in the ideal world (so the control flow can be removed). | |
345 class AbsDNode : public AbsNode { | |
346 public: | |
347 AbsDNode( Node *in1 ) : AbsNode(in1) {} | |
348 virtual int Opcode() const; | |
349 const Type *bottom_type() const { return Type::DOUBLE; } | |
350 virtual uint ideal_reg() const { return Op_RegD; } | |
351 }; | |
352 | |
353 | |
354 //------------------------------CmpLTMaskNode---------------------------------- | |
355 // If p < q, return -1 else return 0. Nice for flow-free idioms. | |
356 class CmpLTMaskNode : public Node { | |
357 public: | |
358 CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {} | |
359 virtual int Opcode() const; | |
360 const Type *bottom_type() const { return TypeInt::INT; } | |
361 virtual uint ideal_reg() const { return Op_RegI; } | |
362 }; | |
363 | |
364 | |
365 //------------------------------NegNode---------------------------------------- | |
366 class NegNode : public Node { | |
367 public: | |
368 NegNode( Node *in1 ) : Node(0,in1) {} | |
369 }; | |
370 | |
371 //------------------------------NegFNode--------------------------------------- | |
372 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from | |
373 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction | |
374 // cannot be used to replace negation we have to implement negation as ideal | |
375 // node; note that negation and addition can replace subtraction. | |
376 class NegFNode : public NegNode { | |
377 public: | |
378 NegFNode( Node *in1 ) : NegNode(in1) {} | |
379 virtual int Opcode() const; | |
380 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
381 const Type *bottom_type() const { return Type::FLOAT; } | |
382 virtual uint ideal_reg() const { return Op_RegF; } | |
383 }; | |
384 | |
385 //------------------------------NegDNode--------------------------------------- | |
386 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from | |
387 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction | |
388 // cannot be used to replace negation we have to implement negation as ideal | |
389 // node; note that negation and addition can replace subtraction. | |
390 class NegDNode : public NegNode { | |
391 public: | |
392 NegDNode( Node *in1 ) : NegNode(in1) {} | |
393 virtual int Opcode() const; | |
394 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); | |
395 const Type *bottom_type() const { return Type::DOUBLE; } | |
396 virtual uint ideal_reg() const { return Op_RegD; } | |
397 }; | |
398 | |
399 //------------------------------CosDNode--------------------------------------- | |
400 // Cosinus of a double | |
401 class CosDNode : public Node { | |
402 public: | |
403 CosDNode( Node *in1 ) : Node(0, in1) {} | |
404 virtual int Opcode() const; | |
405 const Type *bottom_type() const { return Type::DOUBLE; } | |
406 virtual uint ideal_reg() const { return Op_RegD; } | |
407 virtual const Type *Value( PhaseTransform *phase ) const; | |
408 }; | |
409 | |
410 //------------------------------CosDNode--------------------------------------- | |
411 // Sinus of a double | |
412 class SinDNode : public Node { | |
413 public: | |
414 SinDNode( Node *in1 ) : Node(0, in1) {} | |
415 virtual int Opcode() const; | |
416 const Type *bottom_type() const { return Type::DOUBLE; } | |
417 virtual uint ideal_reg() const { return Op_RegD; } | |
418 virtual const Type *Value( PhaseTransform *phase ) const; | |
419 }; | |
420 | |
421 | |
422 //------------------------------TanDNode--------------------------------------- | |
423 // tangens of a double | |
424 class TanDNode : public Node { | |
425 public: | |
426 TanDNode(Node *in1 ) : Node(0, in1) {} | |
427 virtual int Opcode() const; | |
428 const Type *bottom_type() const { return Type::DOUBLE; } | |
429 virtual uint ideal_reg() const { return Op_RegD; } | |
430 virtual const Type *Value( PhaseTransform *phase ) const; | |
431 }; | |
432 | |
433 | |
434 //------------------------------AtanDNode-------------------------------------- | |
435 // arcus tangens of a double | |
436 class AtanDNode : public Node { | |
437 public: | |
438 AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} | |
439 virtual int Opcode() const; | |
440 const Type *bottom_type() const { return Type::DOUBLE; } | |
441 virtual uint ideal_reg() const { return Op_RegD; } | |
442 }; | |
443 | |
444 | |
445 //------------------------------SqrtDNode-------------------------------------- | |
446 // square root a double | |
447 class SqrtDNode : public Node { | |
448 public: | |
449 SqrtDNode(Node *c, Node *in1 ) : Node(c, in1) {} | |
450 virtual int Opcode() const; | |
451 const Type *bottom_type() const { return Type::DOUBLE; } | |
452 virtual uint ideal_reg() const { return Op_RegD; } | |
453 virtual const Type *Value( PhaseTransform *phase ) const; | |
454 }; | |
455 | |
456 //------------------------------ExpDNode--------------------------------------- | |
457 // Exponentiate a double | |
458 class ExpDNode : public Node { | |
459 public: | |
460 ExpDNode( Node *c, Node *in1 ) : Node(c, in1) {} | |
461 virtual int Opcode() const; | |
462 const Type *bottom_type() const { return Type::DOUBLE; } | |
463 virtual uint ideal_reg() const { return Op_RegD; } | |
464 virtual const Type *Value( PhaseTransform *phase ) const; | |
465 }; | |
466 | |
467 //------------------------------LogDNode--------------------------------------- | |
468 // Log_e of a double | |
469 class LogDNode : public Node { | |
470 public: | |
471 LogDNode( Node *in1 ) : Node(0, in1) {} | |
472 virtual int Opcode() const; | |
473 const Type *bottom_type() const { return Type::DOUBLE; } | |
474 virtual uint ideal_reg() const { return Op_RegD; } | |
475 virtual const Type *Value( PhaseTransform *phase ) const; | |
476 }; | |
477 | |
478 //------------------------------Log10DNode--------------------------------------- | |
479 // Log_10 of a double | |
480 class Log10DNode : public Node { | |
481 public: | |
482 Log10DNode( Node *in1 ) : Node(0, in1) {} | |
483 virtual int Opcode() const; | |
484 const Type *bottom_type() const { return Type::DOUBLE; } | |
485 virtual uint ideal_reg() const { return Op_RegD; } | |
486 virtual const Type *Value( PhaseTransform *phase ) const; | |
487 }; | |
488 | |
489 //------------------------------PowDNode--------------------------------------- | |
490 // Raise a double to a double power | |
491 class PowDNode : public Node { | |
492 public: | |
493 PowDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} | |
494 virtual int Opcode() const; | |
495 const Type *bottom_type() const { return Type::DOUBLE; } | |
496 virtual uint ideal_reg() const { return Op_RegD; } | |
497 virtual const Type *Value( PhaseTransform *phase ) const; | |
498 }; | |
499 | |
500 //-------------------------------ReverseBytesINode-------------------------------- | |
501 // reverse bytes of an integer | |
502 class ReverseBytesINode : public Node { | |
503 public: | |
504 ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} | |
505 virtual int Opcode() const; | |
506 const Type *bottom_type() const { return TypeInt::INT; } | |
507 virtual uint ideal_reg() const { return Op_RegI; } | |
508 }; | |
509 | |
510 //-------------------------------ReverseBytesLNode-------------------------------- | |
511 // reverse bytes of a long | |
512 class ReverseBytesLNode : public Node { | |
513 public: | |
514 ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} | |
515 virtual int Opcode() const; | |
516 const Type *bottom_type() const { return TypeLong::LONG; } | |
517 virtual uint ideal_reg() const { return Op_RegL; } | |
518 }; | |
1396
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
519 |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
520 //-------------------------------ReverseBytesUSNode-------------------------------- |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
521 // reverse bytes of an unsigned short / char |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
522 class ReverseBytesUSNode : public Node { |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
523 public: |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
524 ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
525 virtual int Opcode() const; |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
526 const Type *bottom_type() const { return TypeInt::CHAR; } |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
527 virtual uint ideal_reg() const { return Op_RegI; } |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
528 }; |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
529 |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
530 //-------------------------------ReverseBytesSNode-------------------------------- |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
531 // reverse bytes of a short |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
532 class ReverseBytesSNode : public Node { |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
533 public: |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
534 ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
535 virtual int Opcode() const; |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
536 const Type *bottom_type() const { return TypeInt::SHORT; } |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
537 virtual uint ideal_reg() const { return Op_RegI; } |
d7f654633cfe
6946040: add intrinsic for short and char reverseBytes
never
parents:
196
diff
changeset
|
538 }; |
1972 | 539 |
540 #endif // SHARE_VM_OPTO_SUBNODE_HPP |