Thu, 01 Aug 2013 17:25:10 -0700
Merge
1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_OPTO_CONNODE_HPP
26 #define SHARE_VM_OPTO_CONNODE_HPP
28 #include "opto/node.hpp"
29 #include "opto/opcodes.hpp"
30 #include "opto/type.hpp"
32 class PhaseTransform;
33 class MachNode;
35 //------------------------------ConNode----------------------------------------
36 // Simple constants
37 class ConNode : public TypeNode {
38 public:
39 ConNode( const Type *t ) : TypeNode(t,1) {
40 init_req(0, (Node*)Compile::current()->root());
41 init_flags(Flag_is_Con);
42 }
43 virtual int Opcode() const;
44 virtual uint hash() const;
45 virtual const RegMask &out_RegMask() const { return RegMask::Empty; }
46 virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; }
48 // Polymorphic factory method:
49 static ConNode* make( Compile* C, const Type *t );
50 };
52 //------------------------------ConINode---------------------------------------
53 // Simple integer constants
54 class ConINode : public ConNode {
55 public:
56 ConINode( const TypeInt *t ) : ConNode(t) {}
57 virtual int Opcode() const;
59 // Factory method:
60 static ConINode* make( Compile* C, int con ) {
61 return new (C) ConINode( TypeInt::make(con) );
62 }
64 };
66 //------------------------------ConPNode---------------------------------------
67 // Simple pointer constants
68 class ConPNode : public ConNode {
69 public:
70 ConPNode( const TypePtr *t ) : ConNode(t) {}
71 virtual int Opcode() const;
73 // Factory methods:
74 static ConPNode* make( Compile *C ,address con ) {
75 if (con == NULL)
76 return new (C) ConPNode( TypePtr::NULL_PTR ) ;
77 else
78 return new (C) ConPNode( TypeRawPtr::make(con) );
79 }
80 };
83 //------------------------------ConNNode--------------------------------------
84 // Simple narrow oop constants
85 class ConNNode : public ConNode {
86 public:
87 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {}
88 virtual int Opcode() const;
89 };
91 //------------------------------ConNKlassNode---------------------------------
92 // Simple narrow klass constants
93 class ConNKlassNode : public ConNode {
94 public:
95 ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {}
96 virtual int Opcode() const;
97 };
100 //------------------------------ConLNode---------------------------------------
101 // Simple long constants
102 class ConLNode : public ConNode {
103 public:
104 ConLNode( const TypeLong *t ) : ConNode(t) {}
105 virtual int Opcode() const;
107 // Factory method:
108 static ConLNode* make( Compile *C ,jlong con ) {
109 return new (C) ConLNode( TypeLong::make(con) );
110 }
112 };
114 //------------------------------ConFNode---------------------------------------
115 // Simple float constants
116 class ConFNode : public ConNode {
117 public:
118 ConFNode( const TypeF *t ) : ConNode(t) {}
119 virtual int Opcode() const;
121 // Factory method:
122 static ConFNode* make( Compile *C, float con ) {
123 return new (C) ConFNode( TypeF::make(con) );
124 }
126 };
128 //------------------------------ConDNode---------------------------------------
129 // Simple double constants
130 class ConDNode : public ConNode {
131 public:
132 ConDNode( const TypeD *t ) : ConNode(t) {}
133 virtual int Opcode() const;
135 // Factory method:
136 static ConDNode* make( Compile *C, double con ) {
137 return new (C) ConDNode( TypeD::make(con) );
138 }
140 };
142 //------------------------------BinaryNode-------------------------------------
143 // Place holder for the 2 conditional inputs to a CMove. CMove needs 4
144 // inputs: the Bool (for the lt/gt/eq/ne bits), the flags (result of some
145 // compare), and the 2 values to select between. The Matcher requires a
146 // binary tree so we break it down like this:
147 // (CMove (Binary bol cmp) (Binary src1 src2))
148 class BinaryNode : public Node {
149 public:
150 BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { }
151 virtual int Opcode() const;
152 virtual uint ideal_reg() const { return 0; }
153 };
155 //------------------------------CMoveNode--------------------------------------
156 // Conditional move
157 class CMoveNode : public TypeNode {
158 public:
159 enum { Control, // When is it safe to do this cmove?
160 Condition, // Condition controlling the cmove
161 IfFalse, // Value if condition is false
162 IfTrue }; // Value if condition is true
163 CMoveNode( Node *bol, Node *left, Node *right, const Type *t ) : TypeNode(t,4)
164 {
165 init_class_id(Class_CMove);
166 // all inputs are nullified in Node::Node(int)
167 // init_req(Control,NULL);
168 init_req(Condition,bol);
169 init_req(IfFalse,left);
170 init_req(IfTrue,right);
171 }
172 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
173 virtual const Type *Value( PhaseTransform *phase ) const;
174 virtual Node *Identity( PhaseTransform *phase );
175 static CMoveNode *make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t );
176 // Helper function to spot cmove graph shapes
177 static Node *is_cmove_id( PhaseTransform *phase, Node *cmp, Node *t, Node *f, BoolNode *b );
178 };
180 //------------------------------CMoveDNode-------------------------------------
181 class CMoveDNode : public CMoveNode {
182 public:
183 CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){}
184 virtual int Opcode() const;
185 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
186 };
188 //------------------------------CMoveFNode-------------------------------------
189 class CMoveFNode : public CMoveNode {
190 public:
191 CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {}
192 virtual int Opcode() const;
193 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
194 };
196 //------------------------------CMoveINode-------------------------------------
197 class CMoveINode : public CMoveNode {
198 public:
199 CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){}
200 virtual int Opcode() const;
201 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
202 };
204 //------------------------------CMoveLNode-------------------------------------
205 class CMoveLNode : public CMoveNode {
206 public:
207 CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){}
208 virtual int Opcode() const;
209 };
211 //------------------------------CMovePNode-------------------------------------
212 class CMovePNode : public CMoveNode {
213 public:
214 CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
215 virtual int Opcode() const;
216 };
218 //------------------------------CMoveNNode-------------------------------------
219 class CMoveNNode : public CMoveNode {
220 public:
221 CMoveNNode( Node *c, Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); }
222 virtual int Opcode() const;
223 };
225 //------------------------------ConstraintCastNode-----------------------------
226 // cast to a different range
227 class ConstraintCastNode: public TypeNode {
228 public:
229 ConstraintCastNode (Node *n, const Type *t ): TypeNode(t,2) {
230 init_class_id(Class_ConstraintCast);
231 init_req(1, n);
232 }
233 virtual Node *Identity( PhaseTransform *phase );
234 virtual const Type *Value( PhaseTransform *phase ) const;
235 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
236 virtual int Opcode() const;
237 virtual uint ideal_reg() const = 0;
238 virtual Node *Ideal_DU_postCCP( PhaseCCP * );
239 };
241 //------------------------------CastIINode-------------------------------------
242 // cast integer to integer (different range)
243 class CastIINode: public ConstraintCastNode {
244 public:
245 CastIINode (Node *n, const Type *t ): ConstraintCastNode(n,t) {}
246 virtual int Opcode() const;
247 virtual uint ideal_reg() const { return Op_RegI; }
248 };
250 //------------------------------CastPPNode-------------------------------------
251 // cast pointer to pointer (different type)
252 class CastPPNode: public ConstraintCastNode {
253 public:
254 CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {}
255 virtual int Opcode() const;
256 virtual uint ideal_reg() const { return Op_RegP; }
257 virtual Node *Ideal_DU_postCCP( PhaseCCP * );
258 };
260 //------------------------------CheckCastPPNode--------------------------------
261 // for _checkcast, cast pointer to pointer (different type), without JOIN,
262 class CheckCastPPNode: public TypeNode {
263 public:
264 CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) {
265 init_class_id(Class_CheckCastPP);
266 init_req(0, c);
267 init_req(1, n);
268 }
270 virtual Node *Identity( PhaseTransform *phase );
271 virtual const Type *Value( PhaseTransform *phase ) const;
272 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
273 virtual int Opcode() const;
274 virtual uint ideal_reg() const { return Op_RegP; }
275 // No longer remove CheckCast after CCP as it gives me a place to hang
276 // the proper address type - which is required to compute anti-deps.
277 //virtual Node *Ideal_DU_postCCP( PhaseCCP * );
278 };
281 //------------------------------EncodeNarrowPtr--------------------------------
282 class EncodeNarrowPtrNode : public TypeNode {
283 protected:
284 EncodeNarrowPtrNode(Node* value, const Type* type):
285 TypeNode(type, 2) {
286 init_class_id(Class_EncodeNarrowPtr);
287 init_req(0, NULL);
288 init_req(1, value);
289 }
290 public:
291 virtual uint ideal_reg() const { return Op_RegN; }
292 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
293 };
295 //------------------------------EncodeP--------------------------------
296 // Encodes an oop pointers into its compressed form
297 // Takes an extra argument which is the real heap base as a long which
298 // may be useful for code generation in the backend.
299 class EncodePNode : public EncodeNarrowPtrNode {
300 public:
301 EncodePNode(Node* value, const Type* type):
302 EncodeNarrowPtrNode(value, type) {
303 init_class_id(Class_EncodeP);
304 }
305 virtual int Opcode() const;
306 virtual Node *Identity( PhaseTransform *phase );
307 virtual const Type *Value( PhaseTransform *phase ) const;
308 };
310 //------------------------------EncodePKlass--------------------------------
311 // Encodes a klass pointer into its compressed form
312 // Takes an extra argument which is the real heap base as a long which
313 // may be useful for code generation in the backend.
314 class EncodePKlassNode : public EncodeNarrowPtrNode {
315 public:
316 EncodePKlassNode(Node* value, const Type* type):
317 EncodeNarrowPtrNode(value, type) {
318 init_class_id(Class_EncodePKlass);
319 }
320 virtual int Opcode() const;
321 virtual Node *Identity( PhaseTransform *phase );
322 virtual const Type *Value( PhaseTransform *phase ) const;
323 };
325 //------------------------------DecodeNarrowPtr--------------------------------
326 class DecodeNarrowPtrNode : public TypeNode {
327 protected:
328 DecodeNarrowPtrNode(Node* value, const Type* type):
329 TypeNode(type, 2) {
330 init_class_id(Class_DecodeNarrowPtr);
331 init_req(0, NULL);
332 init_req(1, value);
333 }
334 public:
335 virtual uint ideal_reg() const { return Op_RegP; }
336 };
338 //------------------------------DecodeN--------------------------------
339 // Converts a narrow oop into a real oop ptr.
340 // Takes an extra argument which is the real heap base as a long which
341 // may be useful for code generation in the backend.
342 class DecodeNNode : public DecodeNarrowPtrNode {
343 public:
344 DecodeNNode(Node* value, const Type* type):
345 DecodeNarrowPtrNode(value, type) {
346 init_class_id(Class_DecodeN);
347 }
348 virtual int Opcode() const;
349 virtual const Type *Value( PhaseTransform *phase ) const;
350 virtual Node *Identity( PhaseTransform *phase );
351 };
353 //------------------------------DecodeNKlass--------------------------------
354 // Converts a narrow klass pointer into a real klass ptr.
355 // Takes an extra argument which is the real heap base as a long which
356 // may be useful for code generation in the backend.
357 class DecodeNKlassNode : public DecodeNarrowPtrNode {
358 public:
359 DecodeNKlassNode(Node* value, const Type* type):
360 DecodeNarrowPtrNode(value, type) {
361 init_class_id(Class_DecodeNKlass);
362 }
363 virtual int Opcode() const;
364 virtual const Type *Value( PhaseTransform *phase ) const;
365 virtual Node *Identity( PhaseTransform *phase );
366 };
368 //------------------------------Conv2BNode-------------------------------------
369 // Convert int/pointer to a Boolean. Map zero to zero, all else to 1.
370 class Conv2BNode : public Node {
371 public:
372 Conv2BNode( Node *i ) : Node(0,i) {}
373 virtual int Opcode() const;
374 virtual const Type *bottom_type() const { return TypeInt::BOOL; }
375 virtual Node *Identity( PhaseTransform *phase );
376 virtual const Type *Value( PhaseTransform *phase ) const;
377 virtual uint ideal_reg() const { return Op_RegI; }
378 };
380 // The conversions operations are all Alpha sorted. Please keep it that way!
381 //------------------------------ConvD2FNode------------------------------------
382 // Convert double to float
383 class ConvD2FNode : public Node {
384 public:
385 ConvD2FNode( Node *in1 ) : Node(0,in1) {}
386 virtual int Opcode() const;
387 virtual const Type *bottom_type() const { return Type::FLOAT; }
388 virtual const Type *Value( PhaseTransform *phase ) const;
389 virtual Node *Identity( PhaseTransform *phase );
390 virtual uint ideal_reg() const { return Op_RegF; }
391 };
393 //------------------------------ConvD2INode------------------------------------
394 // Convert Double to Integer
395 class ConvD2INode : public Node {
396 public:
397 ConvD2INode( Node *in1 ) : Node(0,in1) {}
398 virtual int Opcode() const;
399 virtual const Type *bottom_type() const { return TypeInt::INT; }
400 virtual const Type *Value( PhaseTransform *phase ) const;
401 virtual Node *Identity( PhaseTransform *phase );
402 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
403 virtual uint ideal_reg() const { return Op_RegI; }
404 };
406 //------------------------------ConvD2LNode------------------------------------
407 // Convert Double to Long
408 class ConvD2LNode : public Node {
409 public:
410 ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
411 virtual int Opcode() const;
412 virtual const Type *bottom_type() const { return TypeLong::LONG; }
413 virtual const Type *Value( PhaseTransform *phase ) const;
414 virtual Node *Identity( PhaseTransform *phase );
415 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
416 virtual uint ideal_reg() const { return Op_RegL; }
417 };
419 //------------------------------ConvF2DNode------------------------------------
420 // Convert Float to a Double.
421 class ConvF2DNode : public Node {
422 public:
423 ConvF2DNode( Node *in1 ) : Node(0,in1) {}
424 virtual int Opcode() const;
425 virtual const Type *bottom_type() const { return Type::DOUBLE; }
426 virtual const Type *Value( PhaseTransform *phase ) const;
427 virtual uint ideal_reg() const { return Op_RegD; }
428 };
430 //------------------------------ConvF2INode------------------------------------
431 // Convert float to integer
432 class ConvF2INode : public Node {
433 public:
434 ConvF2INode( Node *in1 ) : Node(0,in1) {}
435 virtual int Opcode() const;
436 virtual const Type *bottom_type() const { return TypeInt::INT; }
437 virtual const Type *Value( PhaseTransform *phase ) const;
438 virtual Node *Identity( PhaseTransform *phase );
439 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
440 virtual uint ideal_reg() const { return Op_RegI; }
441 };
443 //------------------------------ConvF2LNode------------------------------------
444 // Convert float to long
445 class ConvF2LNode : public Node {
446 public:
447 ConvF2LNode( Node *in1 ) : Node(0,in1) {}
448 virtual int Opcode() const;
449 virtual const Type *bottom_type() const { return TypeLong::LONG; }
450 virtual const Type *Value( PhaseTransform *phase ) const;
451 virtual Node *Identity( PhaseTransform *phase );
452 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
453 virtual uint ideal_reg() const { return Op_RegL; }
454 };
456 //------------------------------ConvI2DNode------------------------------------
457 // Convert Integer to Double
458 class ConvI2DNode : public Node {
459 public:
460 ConvI2DNode( Node *in1 ) : Node(0,in1) {}
461 virtual int Opcode() const;
462 virtual const Type *bottom_type() const { return Type::DOUBLE; }
463 virtual const Type *Value( PhaseTransform *phase ) const;
464 virtual uint ideal_reg() const { return Op_RegD; }
465 };
467 //------------------------------ConvI2FNode------------------------------------
468 // Convert Integer to Float
469 class ConvI2FNode : public Node {
470 public:
471 ConvI2FNode( Node *in1 ) : Node(0,in1) {}
472 virtual int Opcode() const;
473 virtual const Type *bottom_type() const { return Type::FLOAT; }
474 virtual const Type *Value( PhaseTransform *phase ) const;
475 virtual Node *Identity( PhaseTransform *phase );
476 virtual uint ideal_reg() const { return Op_RegF; }
477 };
479 //------------------------------ConvI2LNode------------------------------------
480 // Convert integer to long
481 class ConvI2LNode : public TypeNode {
482 public:
483 ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT)
484 : TypeNode(t, 2)
485 { init_req(1, in1); }
486 virtual int Opcode() const;
487 virtual const Type *Value( PhaseTransform *phase ) const;
488 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
489 virtual uint ideal_reg() const { return Op_RegL; }
490 };
492 //------------------------------ConvL2DNode------------------------------------
493 // Convert Long to Double
494 class ConvL2DNode : public Node {
495 public:
496 ConvL2DNode( Node *in1 ) : Node(0,in1) {}
497 virtual int Opcode() const;
498 virtual const Type *bottom_type() const { return Type::DOUBLE; }
499 virtual const Type *Value( PhaseTransform *phase ) const;
500 virtual uint ideal_reg() const { return Op_RegD; }
501 };
503 //------------------------------ConvL2FNode------------------------------------
504 // Convert Long to Float
505 class ConvL2FNode : public Node {
506 public:
507 ConvL2FNode( Node *in1 ) : Node(0,in1) {}
508 virtual int Opcode() const;
509 virtual const Type *bottom_type() const { return Type::FLOAT; }
510 virtual const Type *Value( PhaseTransform *phase ) const;
511 virtual uint ideal_reg() const { return Op_RegF; }
512 };
514 //------------------------------ConvL2INode------------------------------------
515 // Convert long to integer
516 class ConvL2INode : public Node {
517 public:
518 ConvL2INode( Node *in1 ) : Node(0,in1) {}
519 virtual int Opcode() const;
520 virtual const Type *bottom_type() const { return TypeInt::INT; }
521 virtual Node *Identity( PhaseTransform *phase );
522 virtual const Type *Value( PhaseTransform *phase ) const;
523 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
524 virtual uint ideal_reg() const { return Op_RegI; }
525 };
527 //------------------------------CastX2PNode-------------------------------------
528 // convert a machine-pointer-sized integer to a raw pointer
529 class CastX2PNode : public Node {
530 public:
531 CastX2PNode( Node *n ) : Node(NULL, n) {}
532 virtual int Opcode() const;
533 virtual const Type *Value( PhaseTransform *phase ) const;
534 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
535 virtual Node *Identity( PhaseTransform *phase );
536 virtual uint ideal_reg() const { return Op_RegP; }
537 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
538 };
540 //------------------------------CastP2XNode-------------------------------------
541 // Used in both 32-bit and 64-bit land.
542 // Used for card-marks and unsafe pointer math.
543 class CastP2XNode : public Node {
544 public:
545 CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {}
546 virtual int Opcode() const;
547 virtual const Type *Value( PhaseTransform *phase ) const;
548 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
549 virtual Node *Identity( PhaseTransform *phase );
550 virtual uint ideal_reg() const { return Op_RegX; }
551 virtual const Type *bottom_type() const { return TypeX_X; }
552 // Return false to keep node from moving away from an associated card mark.
553 virtual bool depends_only_on_test() const { return false; }
554 };
556 //------------------------------ThreadLocalNode--------------------------------
557 // Ideal Node which returns the base of ThreadLocalStorage.
558 class ThreadLocalNode : public Node {
559 public:
560 ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
561 virtual int Opcode() const;
562 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
563 virtual uint ideal_reg() const { return Op_RegP; }
564 };
566 //------------------------------LoadReturnPCNode-------------------------------
567 class LoadReturnPCNode: public Node {
568 public:
569 LoadReturnPCNode(Node *c) : Node(c) { }
570 virtual int Opcode() const;
571 virtual uint ideal_reg() const { return Op_RegP; }
572 };
575 //-----------------------------RoundFloatNode----------------------------------
576 class RoundFloatNode: public Node {
577 public:
578 RoundFloatNode(Node* c, Node *in1): Node(c, in1) {}
579 virtual int Opcode() const;
580 virtual const Type *bottom_type() const { return Type::FLOAT; }
581 virtual uint ideal_reg() const { return Op_RegF; }
582 virtual Node *Identity( PhaseTransform *phase );
583 virtual const Type *Value( PhaseTransform *phase ) const;
584 };
587 //-----------------------------RoundDoubleNode---------------------------------
588 class RoundDoubleNode: public Node {
589 public:
590 RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {}
591 virtual int Opcode() const;
592 virtual const Type *bottom_type() const { return Type::DOUBLE; }
593 virtual uint ideal_reg() const { return Op_RegD; }
594 virtual Node *Identity( PhaseTransform *phase );
595 virtual const Type *Value( PhaseTransform *phase ) const;
596 };
598 //------------------------------Opaque1Node------------------------------------
599 // A node to prevent unwanted optimizations. Allows constant folding.
600 // Stops value-numbering, Ideal calls or Identity functions.
601 class Opaque1Node : public Node {
602 virtual uint hash() const ; // { return NO_HASH; }
603 virtual uint cmp( const Node &n ) const;
604 public:
605 Opaque1Node( Compile* C, Node *n ) : Node(0,n) {
606 // Put it on the Macro nodes list to removed during macro nodes expansion.
607 init_flags(Flag_is_macro);
608 C->add_macro_node(this);
609 }
610 // Special version for the pre-loop to hold the original loop limit
611 // which is consumed by range check elimination.
612 Opaque1Node( Compile* C, Node *n, Node* orig_limit ) : Node(0,n,orig_limit) {
613 // Put it on the Macro nodes list to removed during macro nodes expansion.
614 init_flags(Flag_is_macro);
615 C->add_macro_node(this);
616 }
617 Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }
618 virtual int Opcode() const;
619 virtual const Type *bottom_type() const { return TypeInt::INT; }
620 virtual Node *Identity( PhaseTransform *phase );
621 };
623 //------------------------------Opaque2Node------------------------------------
624 // A node to prevent unwanted optimizations. Allows constant folding. Stops
625 // value-numbering, most Ideal calls or Identity functions. This Node is
626 // specifically designed to prevent the pre-increment value of a loop trip
627 // counter from being live out of the bottom of the loop (hence causing the
628 // pre- and post-increment values both being live and thus requiring an extra
629 // temp register and an extra move). If we "accidentally" optimize through
630 // this kind of a Node, we'll get slightly pessimal, but correct, code. Thus
631 // it's OK to be slightly sloppy on optimizations here.
632 class Opaque2Node : public Node {
633 virtual uint hash() const ; // { return NO_HASH; }
634 virtual uint cmp( const Node &n ) const;
635 public:
636 Opaque2Node( Compile* C, Node *n ) : Node(0,n) {
637 // Put it on the Macro nodes list to removed during macro nodes expansion.
638 init_flags(Flag_is_macro);
639 C->add_macro_node(this);
640 }
641 virtual int Opcode() const;
642 virtual const Type *bottom_type() const { return TypeInt::INT; }
643 };
645 //----------------------PartialSubtypeCheckNode--------------------------------
646 // The 2nd slow-half of a subtype check. Scan the subklass's 2ndary superklass
647 // array for an instance of the superklass. Set a hidden internal cache on a
648 // hit (cache is checked with exposed code in gen_subtype_check()). Return
649 // not zero for a miss or zero for a hit.
650 class PartialSubtypeCheckNode : public Node {
651 public:
652 PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {}
653 virtual int Opcode() const;
654 virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
655 virtual uint ideal_reg() const { return Op_RegP; }
656 };
658 //
659 class MoveI2FNode : public Node {
660 public:
661 MoveI2FNode( Node *value ) : Node(0,value) {}
662 virtual int Opcode() const;
663 virtual const Type *bottom_type() const { return Type::FLOAT; }
664 virtual uint ideal_reg() const { return Op_RegF; }
665 virtual const Type* Value( PhaseTransform *phase ) const;
666 };
668 class MoveL2DNode : public Node {
669 public:
670 MoveL2DNode( Node *value ) : Node(0,value) {}
671 virtual int Opcode() const;
672 virtual const Type *bottom_type() const { return Type::DOUBLE; }
673 virtual uint ideal_reg() const { return Op_RegD; }
674 virtual const Type* Value( PhaseTransform *phase ) const;
675 };
677 class MoveF2INode : public Node {
678 public:
679 MoveF2INode( Node *value ) : Node(0,value) {}
680 virtual int Opcode() const;
681 virtual const Type *bottom_type() const { return TypeInt::INT; }
682 virtual uint ideal_reg() const { return Op_RegI; }
683 virtual const Type* Value( PhaseTransform *phase ) const;
684 };
686 class MoveD2LNode : public Node {
687 public:
688 MoveD2LNode( Node *value ) : Node(0,value) {}
689 virtual int Opcode() const;
690 virtual const Type *bottom_type() const { return TypeLong::LONG; }
691 virtual uint ideal_reg() const { return Op_RegL; }
692 virtual const Type* Value( PhaseTransform *phase ) const;
693 };
695 //---------- CountBitsNode -----------------------------------------------------
696 class CountBitsNode : public Node {
697 public:
698 CountBitsNode(Node* in1) : Node(0, in1) {}
699 const Type* bottom_type() const { return TypeInt::INT; }
700 virtual uint ideal_reg() const { return Op_RegI; }
701 };
703 //---------- CountLeadingZerosINode --------------------------------------------
704 // Count leading zeros (0-bit count starting from MSB) of an integer.
705 class CountLeadingZerosINode : public CountBitsNode {
706 public:
707 CountLeadingZerosINode(Node* in1) : CountBitsNode(in1) {}
708 virtual int Opcode() const;
709 virtual const Type* Value(PhaseTransform* phase) const;
710 };
712 //---------- CountLeadingZerosLNode --------------------------------------------
713 // Count leading zeros (0-bit count starting from MSB) of a long.
714 class CountLeadingZerosLNode : public CountBitsNode {
715 public:
716 CountLeadingZerosLNode(Node* in1) : CountBitsNode(in1) {}
717 virtual int Opcode() const;
718 virtual const Type* Value(PhaseTransform* phase) const;
719 };
721 //---------- CountTrailingZerosINode -------------------------------------------
722 // Count trailing zeros (0-bit count starting from LSB) of an integer.
723 class CountTrailingZerosINode : public CountBitsNode {
724 public:
725 CountTrailingZerosINode(Node* in1) : CountBitsNode(in1) {}
726 virtual int Opcode() const;
727 virtual const Type* Value(PhaseTransform* phase) const;
728 };
730 //---------- CountTrailingZerosLNode -------------------------------------------
731 // Count trailing zeros (0-bit count starting from LSB) of a long.
732 class CountTrailingZerosLNode : public CountBitsNode {
733 public:
734 CountTrailingZerosLNode(Node* in1) : CountBitsNode(in1) {}
735 virtual int Opcode() const;
736 virtual const Type* Value(PhaseTransform* phase) const;
737 };
739 //---------- PopCountINode -----------------------------------------------------
740 // Population count (bit count) of an integer.
741 class PopCountINode : public CountBitsNode {
742 public:
743 PopCountINode(Node* in1) : CountBitsNode(in1) {}
744 virtual int Opcode() const;
745 };
747 //---------- PopCountLNode -----------------------------------------------------
748 // Population count (bit count) of a long.
749 class PopCountLNode : public CountBitsNode {
750 public:
751 PopCountLNode(Node* in1) : CountBitsNode(in1) {}
752 virtual int Opcode() const;
753 };
755 #endif // SHARE_VM_OPTO_CONNODE_HPP