1 /*
2 * Copyright 1997-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 class PhaseTransform;
26 class MachNode;
27
28 //------------------------------ConNode----------------------------------------
29 // Simple constants
30 class ConNode : public TypeNode {
31 public:
32 ConNode( const Type *t ) : TypeNode(t,1) {
33 init_req(0, (Node*)Compile::current()->root());
34 init_flags(Flag_is_Con);
35 }
36 virtual int Opcode() const;
37 virtual uint hash() const;
38 virtual const RegMask &out_RegMask() const { return RegMask::Empty; }
39 virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; }
40
41 // Polymorphic factory method:
42 static ConNode* make( Compile* C, const Type *t );
43 };
44
45 //------------------------------ConINode---------------------------------------
46 // Simple integer constants
47 class ConINode : public ConNode {
48 public:
49 ConINode( const TypeInt *t ) : ConNode(t) {}
50 virtual int Opcode() const;
51
52 // Factory method:
53 static ConINode* make( Compile* C, int con ) {
54 return new (C, 1) ConINode( TypeInt::make(con) );
55 }
56
57 };
58
59 //------------------------------ConPNode---------------------------------------
60 // Simple pointer constants
61 class ConPNode : public ConNode {
62 public:
63 ConPNode( const TypePtr *t ) : ConNode(t) {}
64 virtual int Opcode() const;
65
66 // Factory methods:
67 static ConPNode* make( Compile *C ,address con ) {
68 if (con == NULL)
69 return new (C, 1) ConPNode( TypePtr::NULL_PTR ) ;
70 else
71 return new (C, 1) ConPNode( TypeRawPtr::make(con) );
72 }
73
74 static ConPNode* make( Compile *C, ciObject* con ) {
75 return new (C, 1) ConPNode( TypeOopPtr::make_from_constant(con) );
76 }
77
78 };
79
80
81 //------------------------------ConNNode--------------------------------------
82 // Simple narrow oop constants
83 class ConNNode : public ConNode {
84 public:
85 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {}
86 virtual int Opcode() const;
87
88 static ConNNode* make( Compile *C, ciObject* con ) {
89 return new (C, 1) ConNNode( TypeNarrowOop::make_from_constant(con) );
90 }
91
92 };
93
94
95 //------------------------------ConLNode---------------------------------------
96 // Simple long constants
97 class ConLNode : public ConNode {
98 public:
99 ConLNode( const TypeLong *t ) : ConNode(t) {}
100 virtual int Opcode() const;
101
102 // Factory method:
103 static ConLNode* make( Compile *C ,jlong con ) {
104 return new (C, 1) ConLNode( TypeLong::make(con) );
105 }
106
107 };
108
109 //------------------------------ConFNode---------------------------------------
110 // Simple float constants
111 class ConFNode : public ConNode {
112 public:
113 ConFNode( const TypeF *t ) : ConNode(t) {}
114 virtual int Opcode() const;
115
116 // Factory method:
117 static ConFNode* make( Compile *C, float con ) {
118 return new (C, 1) ConFNode( TypeF::make(con) );
119 }
120
121 };
122
123 //------------------------------ConDNode---------------------------------------
124 // Simple double constants
125 class ConDNode : public ConNode {
126 public:
127 ConDNode( const TypeD *t ) : ConNode(t) {}
128 virtual int Opcode() const;
129
130 // Factory method:
131 static ConDNode* make( Compile *C, double con ) {
132 return new (C, 1) ConDNode( TypeD::make(con) );
133 }
134
135 };
136
137 //------------------------------BinaryNode-------------------------------------
138 // Place holder for the 2 conditional inputs to a CMove. CMove needs 4
139 // inputs: the Bool (for the lt/gt/eq/ne bits), the flags (result of some
140 // compare), and the 2 values to select between. The Matcher requires a
141 // binary tree so we break it down like this:
142 // (CMove (Binary bol cmp) (Binary src1 src2))
143 class BinaryNode : public Node {
144 public:
145 BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { }
146 virtual int Opcode() const;
147 virtual uint ideal_reg() const { return 0; }
148 };
149
150 //------------------------------CMoveNode--------------------------------------
151 // Conditional move
152 class CMoveNode : public TypeNode {
153 public:
154 enum { Control, // When is it safe to do this cmove?
155 Condition, // Condition controlling the cmove
156 IfFalse, // Value if condition is false
157 IfTrue }; // Value if condition is true
158 CMoveNode( Node *bol, Node *left, Node *right, const Type *t ) : TypeNode(t,4)
159 {
160 init_class_id(Class_CMove);
161 // all inputs are nullified in Node::Node(int)
162 // init_req(Control,NULL);
163 init_req(Condition,bol);
164 init_req(IfFalse,left);
165 init_req(IfTrue,right);
166 }
167 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
168 virtual const Type *Value( PhaseTransform *phase ) const;
169 virtual Node *Identity( PhaseTransform *phase );
170 static CMoveNode *make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t );
171 // Helper function to spot cmove graph shapes
172 static Node *is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b );
173 };
174
175 //------------------------------CMoveDNode-------------------------------------
176 class CMoveDNode : public CMoveNode {
177 public:
178 CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){}
179 virtual int Opcode() const;
180 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
181 };
182
183 //------------------------------CMoveFNode-------------------------------------
184 class CMoveFNode : public CMoveNode {
185 public:
186 CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {}
187 virtual int Opcode() const;
188 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
189 };
190
191 //------------------------------CMoveINode-------------------------------------
192 class CMoveINode : public CMoveNode {
193 public:
194 CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){}
195 virtual int Opcode() const;
196 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
197 };
198
199 //------------------------------CMoveLNode-------------------------------------
200 class CMoveLNode : public CMoveNode {
201 public:
202 CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){}
203 virtual int Opcode() const;
204 };
205
206 //------------------------------CMovePNode-------------------------------------
207 class CMovePNode : public CMoveNode {
208 public:
209 CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
210 virtual int Opcode() const;
211 };
212
213 //------------------------------ConstraintCastNode-------------------------------------
214 // cast to a different range
215 class ConstraintCastNode: public TypeNode {
216 public:
217 ConstraintCastNode (Node *n, const Type *t ): TypeNode(t,2) {
218 init_class_id(Class_ConstraintCast);
219 init_req(1, n);
220 }
221 virtual Node *Identity( PhaseTransform *phase );
222 virtual const Type *Value( PhaseTransform *phase ) const;
223 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
224 virtual int Opcode() const;
225 virtual uint ideal_reg() const = 0;
226 virtual Node *Ideal_DU_postCCP( PhaseCCP * );
227 };
228
229 //------------------------------CastIINode-------------------------------------
230 // cast integer to integer (different range)
231 class CastIINode: public ConstraintCastNode {
232 public:
233 CastIINode (Node *n, const Type *t ): ConstraintCastNode(n,t) {}
234 virtual int Opcode() const;
235 virtual uint ideal_reg() const { return Op_RegI; }
236 };
237
238 //------------------------------CastPPNode-------------------------------------
239 // cast pointer to pointer (different type)
240 class CastPPNode: public ConstraintCastNode {
241 public:
242 CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {
243 // Only CastPP is safe. CastII can cause optimizer loops.
244 init_flags(Flag_is_dead_loop_safe);
245 }
246 virtual int Opcode() const;
247 virtual uint ideal_reg() const { return Op_RegP; }
248 virtual Node *Ideal_DU_postCCP( PhaseCCP * );
249 };
250
251 //------------------------------CheckCastPPNode--------------------------------
252 // for _checkcast, cast pointer to pointer (different type), without JOIN,
253 class CheckCastPPNode: public TypeNode {
254 public:
255 CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) {
256 init_class_id(Class_CheckCastPP);
257 init_flags(Flag_is_dead_loop_safe);
258 init_req(0, c);
259 init_req(1, n);
260 }
261 virtual Node *Identity( PhaseTransform *phase );
262 virtual const Type *Value( PhaseTransform *phase ) const;
263 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
264 virtual int Opcode() const;
265 virtual uint ideal_reg() const { return Op_RegP; }
266 // No longer remove CheckCast after CCP as it gives me a place to hang
267 // the proper address type - which is required to compute anti-deps.
268 //virtual Node *Ideal_DU_postCCP( PhaseCCP * );
269 };
270
271
272 //------------------------------EncodeP--------------------------------
273 // Encodes an oop pointers into its compressed form
274 // Takes an extra argument which is the real heap base as a long which
275 // may be useful for code generation in the backend.
276 class EncodePNode : public TypeNode {
277 public:
278 EncodePNode(Node* value, const Type* type):
279 TypeNode(type, 2) {
280 init_req(0, NULL);
281 init_req(1, value);
282 }
283 virtual int Opcode() const;
284 virtual Node *Identity( PhaseTransform *phase );
285 virtual const Type *Value( PhaseTransform *phase ) const;
286 virtual uint ideal_reg() const { return Op_RegN; }
287
288 static Node* encode(PhaseGVN* phase, Node* value);
289 };
290
291 //------------------------------DecodeN--------------------------------
292 // Converts a narrow oop into a real oop ptr.
293 // Takes an extra argument which is the real heap base as a long which
294 // may be useful for code generation in the backend.
295 class DecodeNNode : public TypeNode {
296 public:
297 DecodeNNode(Node* value, const Type* type):
298 TypeNode(type, 2) {
299 init_req(0, NULL);
300 init_req(1, value);
301 }
302 virtual int Opcode() const;
303 virtual Node *Identity( PhaseTransform *phase );
304 virtual const Type *Value( PhaseTransform *phase ) const;
305 virtual uint ideal_reg() const { return Op_RegP; }
306
307 static Node* decode(PhaseGVN* phase, Node* value);
308 };
309
310 //------------------------------Conv2BNode-------------------------------------
311 // Convert int/pointer to a Boolean. Map zero to zero, all else to 1.
312 class Conv2BNode : public Node {
313 public:
314 Conv2BNode( Node *i ) : Node(0,i) {}
315 virtual int Opcode() const;
316 virtual const Type *bottom_type() const { return TypeInt::BOOL; }
317 virtual Node *Identity( PhaseTransform *phase );
318 virtual const Type *Value( PhaseTransform *phase ) const;
319 virtual uint ideal_reg() const { return Op_RegI; }
320 };
321
322 // The conversions operations are all Alpha sorted. Please keep it that way!
323 //------------------------------ConvD2FNode------------------------------------
324 // Convert double to float
325 class ConvD2FNode : public Node {
326 public:
327 ConvD2FNode( Node *in1 ) : Node(0,in1) {}
328 virtual int Opcode() const;
329 virtual const Type *bottom_type() const { return Type::FLOAT; }
330 virtual const Type *Value( PhaseTransform *phase ) const;
331 virtual Node *Identity( PhaseTransform *phase );
332 virtual uint ideal_reg() const { return Op_RegF; }
333 };
334
335 //------------------------------ConvD2INode------------------------------------
336 // Convert Double to Integer
337 class ConvD2INode : public Node {
338 public:
339 ConvD2INode( Node *in1 ) : Node(0,in1) {}
340 virtual int Opcode() const;
341 virtual const Type *bottom_type() const { return TypeInt::INT; }
342 virtual const Type *Value( PhaseTransform *phase ) const;
343 virtual Node *Identity( PhaseTransform *phase );
344 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
345 virtual uint ideal_reg() const { return Op_RegI; }
346 };
347
348 //------------------------------ConvD2LNode------------------------------------
349 // Convert Double to Long
350 class ConvD2LNode : public Node {
351 public:
352 ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
353 virtual int Opcode() const;
354 virtual const Type *bottom_type() const { return TypeLong::LONG; }
355 virtual const Type *Value( PhaseTransform *phase ) const;
356 virtual Node *Identity( PhaseTransform *phase );
357 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
358 virtual uint ideal_reg() const { return Op_RegL; }
359 };
360
361 //------------------------------ConvF2DNode------------------------------------
362 // Convert Float to a Double.
363 class ConvF2DNode : public Node {
364 public:
365 ConvF2DNode( Node *in1 ) : Node(0,in1) {}
366 virtual int Opcode() const;
367 virtual const Type *bottom_type() const { return Type::DOUBLE; }
368 virtual const Type *Value( PhaseTransform *phase ) const;
369 virtual uint ideal_reg() const { return Op_RegD; }
370 };
371
372 //------------------------------ConvF2INode------------------------------------
373 // Convert float to integer
374 class ConvF2INode : public Node {
375 public:
376 ConvF2INode( Node *in1 ) : Node(0,in1) {}
377 virtual int Opcode() const;
378 virtual const Type *bottom_type() const { return TypeInt::INT; }
379 virtual const Type *Value( PhaseTransform *phase ) const;
380 virtual Node *Identity( PhaseTransform *phase );
381 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
382 virtual uint ideal_reg() const { return Op_RegI; }
383 };
384
385 //------------------------------ConvF2LNode------------------------------------
386 // Convert float to long
387 class ConvF2LNode : public Node {
388 public:
389 ConvF2LNode( Node *in1 ) : Node(0,in1) {}
390 virtual int Opcode() const;
391 virtual const Type *bottom_type() const { return TypeLong::LONG; }
392 virtual const Type *Value( PhaseTransform *phase ) const;
393 virtual Node *Identity( PhaseTransform *phase );
394 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
395 virtual uint ideal_reg() const { return Op_RegL; }
396 };
397
398 //------------------------------ConvI2DNode------------------------------------
399 // Convert Integer to Double
400 class ConvI2DNode : public Node {
401 public:
402 ConvI2DNode( Node *in1 ) : Node(0,in1) {}
403 virtual int Opcode() const;
404 virtual const Type *bottom_type() const { return Type::DOUBLE; }
405 virtual const Type *Value( PhaseTransform *phase ) const;
406 virtual uint ideal_reg() const { return Op_RegD; }
407 };
408
409 //------------------------------ConvI2FNode------------------------------------
410 // Convert Integer to Float
411 class ConvI2FNode : public Node {
412 public:
413 ConvI2FNode( Node *in1 ) : Node(0,in1) {}
414 virtual int Opcode() const;
415 virtual const Type *bottom_type() const { return Type::FLOAT; }
416 virtual const Type *Value( PhaseTransform *phase ) const;
417 virtual Node *Identity( PhaseTransform *phase );
418 virtual uint ideal_reg() const { return Op_RegF; }
419 };
420
421 //------------------------------ConvI2LNode------------------------------------
422 // Convert integer to long
423 class ConvI2LNode : public TypeNode {
424 public:
425 ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT)
426 : TypeNode(t, 2)
427 { init_req(1, in1); }
428 virtual int Opcode() const;
429 virtual const Type *Value( PhaseTransform *phase ) const;
430 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
431 virtual uint ideal_reg() const { return Op_RegL; }
432 };
433
434 //------------------------------ConvL2DNode------------------------------------
435 // Convert Long to Double
436 class ConvL2DNode : public Node {
437 public:
438 ConvL2DNode( Node *in1 ) : Node(0,in1) {}
439 virtual int Opcode() const;
440 virtual const Type *bottom_type() const { return Type::DOUBLE; }
441 virtual const Type *Value( PhaseTransform *phase ) const;
442 virtual uint ideal_reg() const { return Op_RegD; }
443 };
444
445 //------------------------------ConvL2FNode------------------------------------
446 // Convert Long to Float
447 class ConvL2FNode : public Node {
448 public:
449 ConvL2FNode( Node *in1 ) : Node(0,in1) {}
450 virtual int Opcode() const;
451 virtual const Type *bottom_type() const { return Type::FLOAT; }
452 virtual const Type *Value( PhaseTransform *phase ) const;
453 virtual uint ideal_reg() const { return Op_RegF; }
454 };
455
456 //------------------------------ConvL2INode------------------------------------
457 // Convert long to integer
458 class ConvL2INode : public Node {
459 public:
460 ConvL2INode( Node *in1 ) : Node(0,in1) {}
461 virtual int Opcode() const;
462 virtual const Type *bottom_type() const { return TypeInt::INT; }
463 virtual Node *Identity( PhaseTransform *phase );
464 virtual const Type *Value( PhaseTransform *phase ) const;
465 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
466 virtual uint ideal_reg() const { return Op_RegI; }
467 };
468
469 //------------------------------CastX2PNode-------------------------------------
470 // convert a machine-pointer-sized integer to a raw pointer
471 class CastX2PNode : public Node {
472 public:
473 CastX2PNode( Node *n ) : Node(NULL, n) {}
474 virtual int Opcode() const;
475 virtual const Type *Value( PhaseTransform *phase ) const;
476 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
477 virtual Node *Identity( PhaseTransform *phase );
478 virtual uint ideal_reg() const { return Op_RegP; }
479 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
480 };
481
482 //------------------------------CastP2XNode-------------------------------------
483 // Used in both 32-bit and 64-bit land.
484 // Used for card-marks and unsafe pointer math.
485 class CastP2XNode : public Node {
486 public:
487 CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {}
488 virtual int Opcode() const;
489 virtual const Type *Value( PhaseTransform *phase ) const;
490 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
491 virtual Node *Identity( PhaseTransform *phase );
492 virtual uint ideal_reg() const { return Op_RegX; }
493 virtual const Type *bottom_type() const { return TypeX_X; }
494 // Return false to keep node from moving away from an associated card mark.
495 virtual bool depends_only_on_test() const { return false; }
496 };
497
498 //------------------------------MemMoveNode------------------------------------
499 // Memory to memory move. Inserted very late, after allocation.
500 class MemMoveNode : public Node {
501 public:
502 MemMoveNode( Node *dst, Node *src ) : Node(0,dst,src) {}
503 virtual int Opcode() const;
504 };
505
506 //------------------------------ThreadLocalNode--------------------------------
507 // Ideal Node which returns the base of ThreadLocalStorage.
508 class ThreadLocalNode : public Node {
509 public:
510 ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
511 virtual int Opcode() const;
512 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
513 virtual uint ideal_reg() const { return Op_RegP; }
514 };
515
516 //------------------------------LoadReturnPCNode-------------------------------
517 class LoadReturnPCNode: public Node {
518 public:
519 LoadReturnPCNode(Node *c) : Node(c) { }
520 virtual int Opcode() const;
521 virtual uint ideal_reg() const { return Op_RegP; }
522 };
523
524
525 //-----------------------------RoundFloatNode----------------------------------
526 class RoundFloatNode: public Node {
527 public:
528 RoundFloatNode(Node* c, Node *in1): Node(c, in1) {}
529 virtual int Opcode() const;
530 virtual const Type *bottom_type() const { return Type::FLOAT; }
531 virtual uint ideal_reg() const { return Op_RegF; }
532 virtual Node *Identity( PhaseTransform *phase );
533 virtual const Type *Value( PhaseTransform *phase ) const;
534 };
535
536
537 //-----------------------------RoundDoubleNode---------------------------------
538 class RoundDoubleNode: public Node {
539 public:
540 RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {}
541 virtual int Opcode() const;
542 virtual const Type *bottom_type() const { return Type::DOUBLE; }
543 virtual uint ideal_reg() const { return Op_RegD; }
544 virtual Node *Identity( PhaseTransform *phase );
545 virtual const Type *Value( PhaseTransform *phase ) const;
546 };
547
548 //------------------------------Opaque1Node------------------------------------
549 // A node to prevent unwanted optimizations. Allows constant folding.
550 // Stops value-numbering, Ideal calls or Identity functions.
551 class Opaque1Node : public Node {
552 virtual uint hash() const ; // { return NO_HASH; }
553 virtual uint cmp( const Node &n ) const;
554 public:
555 Opaque1Node( Node *n ) : Node(0,n) {}
556 // Special version for the pre-loop to hold the original loop limit
557 // which is consumed by range check elimination.
558 Opaque1Node( Node *n, Node* orig_limit ) : Node(0,n,orig_limit) {}
559 Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }
560 virtual int Opcode() const;
561 virtual const Type *bottom_type() const { return TypeInt::INT; }
562 virtual Node *Identity( PhaseTransform *phase );
563 };
564
565 //------------------------------Opaque2Node------------------------------------
566 // A node to prevent unwanted optimizations. Allows constant folding. Stops
567 // value-numbering, most Ideal calls or Identity functions. This Node is
568 // specifically designed to prevent the pre-increment value of a loop trip
569 // counter from being live out of the bottom of the loop (hence causing the
570 // pre- and post-increment values both being live and thus requiring an extra
571 // temp register and an extra move). If we "accidentally" optimize through
572 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus
573 // it's OK to be slightly sloppy on optimizations here.
574 class Opaque2Node : public Node {
575 virtual uint hash() const ; // { return NO_HASH; }
576 virtual uint cmp( const Node &n ) const;
577 public:
578 Opaque2Node( Node *n ) : Node(0,n) {}
579 virtual int Opcode() const;
580 virtual const Type *bottom_type() const { return TypeInt::INT; }
581 };
582
583 //----------------------PartialSubtypeCheckNode--------------------------------
584 // The 2nd slow-half of a subtype check. Scan the subklass's 2ndary superklass
585 // array for an instance of the superklass. Set a hidden internal cache on a
586 // hit (cache is checked with exposed code in gen_subtype_check()). Return
587 // not zero for a miss or zero for a hit.
588 class PartialSubtypeCheckNode : public Node {
589 public:
590 PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {}
591 virtual int Opcode() const;
592 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
593 virtual uint ideal_reg() const { return Op_RegP; }
594 };
595
596 //
597 class MoveI2FNode : public Node {
598 public:
599 MoveI2FNode( Node *value ) : Node(0,value) {}
600 virtual int Opcode() const;
601 virtual const Type *bottom_type() const { return Type::FLOAT; }
602 virtual uint ideal_reg() const { return Op_RegF; }
603 virtual const Type* Value( PhaseTransform *phase ) const;
604 };
605
606 class MoveL2DNode : public Node {
607 public:
608 MoveL2DNode( Node *value ) : Node(0,value) {}
609 virtual int Opcode() const;
610 virtual const Type *bottom_type() const { return Type::DOUBLE; }
611 virtual uint ideal_reg() const { return Op_RegD; }
612 virtual const Type* Value( PhaseTransform *phase ) const;
613 };
614
615 class MoveF2INode : public Node {
616 public:
617 MoveF2INode( Node *value ) : Node(0,value) {}
618 virtual int Opcode() const;
619 virtual const Type *bottom_type() const { return TypeInt::INT; }
620 virtual uint ideal_reg() const { return Op_RegI; }
621 virtual const Type* Value( PhaseTransform *phase ) const;
622 };
623
624 class MoveD2LNode : public Node {
625 public:
626 MoveD2LNode( Node *value ) : Node(0,value) {}
627 virtual int Opcode() const;
628 virtual const Type *bottom_type() const { return TypeLong::LONG; }
629 virtual uint ideal_reg() const { return Op_RegL; }
630 virtual const Type* Value( PhaseTransform *phase ) const;
631 };