src/share/vm/opto/connode.hpp

Print this page




 122   static ConFNode* make( Compile *C, float con  ) {
 123     return new (C) ConFNode( TypeF::make(con) );
 124   }
 125 
 126 };
 127 
 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;
 134 
 135   // Factory method:
 136   static ConDNode* make( Compile *C, double con ) {
 137     return new (C) ConDNode( TypeD::make(con) );
 138   }
 139 
 140 };
 141 
 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 };
 154 
 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 };
 179 
 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 };
 187 
 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 };
 195 
 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 };
 203 
 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 };
 210 
 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 };
 217 
 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 };
 224 
 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 };
 240 
 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 };
 249 
 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 };
 259 
 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   }
 269 
 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 };
 279 
 280 
 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 };
 294 
 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 };
 309 
 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 };
 324 
 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 };
 337 
 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 };
 352 
 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 };
 367 
 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 };
 379 
 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 };
 392 
 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 };
 405 
 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 };
 418 
 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 };
 429 
 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 };
 442 
 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 };
 455 
 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 };
 466 
 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 };
 478 
 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 };
 491 
 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 };
 502 
 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 };
 513 
 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 };
 526 
 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 };
 539 
 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 };
 555 
 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 };
 565 
 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 };
 573 
 574 
 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 };
 585 
 586 
 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 };
 597 
 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 };
 622 
 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 };
 644 
 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 };
 657 
 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 };
 667 
 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 };
 676 
 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 };
 685 
 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 };
 694 
 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 };
 702 
 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 };
 711 
 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 };
 720 
 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 };
 729 
 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 };
 738 
 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 };
 746 
 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 };
 754 
 755 #endif // SHARE_VM_OPTO_CONNODE_HPP


 122   static ConFNode* make( Compile *C, float con  ) {
 123     return new (C) ConFNode( TypeF::make(con) );
 124   }
 125 
 126 };
 127 
 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;
 134 
 135   // Factory method:
 136   static ConDNode* make( Compile *C, double con ) {
 137     return new (C) ConDNode( TypeD::make(con) );
 138   }
 139 
 140 };
 141 






























































































































































































































































































































































































































 142 //------------------------------ThreadLocalNode--------------------------------
 143 // Ideal Node which returns the base of ThreadLocalStorage.
 144 class ThreadLocalNode : public Node {
 145 public:
 146     ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
 147     virtual int Opcode() const;
 148     virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
 149     virtual uint ideal_reg() const { return Op_RegP; }
 150 };
 151 








 152 



















































































































































































 153 
 154 #endif // SHARE_VM_OPTO_CONNODE_HPP