Mercurial > hg > truffle

comparison src/share/vm/opto/connode.hpp @ 0:a61af66fc99e jdk7-b24

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