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 |