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  */
  24 
  25 #ifndef SHARE_VM_OPTO_CONNODE_HPP
  26 #define SHARE_VM_OPTO_CONNODE_HPP
  27 
  28 #include "opto/node.hpp"
  29 #include "opto/opcodes.hpp"
  30 #include "opto/type.hpp"
  31 
  32 class PhaseTransform;
  33 class MachNode;
  34 
  35 //------------------------------ConNode----------------------------------------
  36 // Simple constants
  37 class ConNode : public TypeNode {
  38 public:
  39   ConNode( const Type *t ) : TypeNode(t->remove_speculative(),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; }
  47 
  48   // Polymorphic factory method:
  49   static ConNode* make( Compile* C, const Type *t );
  50 };
  51 
  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;
  58 
  59   // Factory method:
  60   static ConINode* make( Compile* C, int con ) {
  61     return new (C) ConINode( TypeInt::make(con) );
  62   }
  63 
  64 };
  65 
  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;
  72 
  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 };
  81 
  82 
  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 };
  90 
  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 };
  98 
  99 
 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;
 106 
 107   // Factory method:
 108   static ConLNode* make( Compile *C ,jlong con ) {
 109     return new (C) ConLNode( TypeLong::make(con) );
 110   }
 111 
 112 };
 113 
 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;
 120 
 121   // Factory method:
 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   private:
 245   // Can this node be removed post CCP or does it carry a required dependency?
 246   const bool _carry_dependency;
 247   // Is this node dependent on a range check?
 248   const bool _range_check_dependency;
 249 
 250   protected:
 251   virtual uint cmp( const Node &n ) const;
 252   virtual uint size_of() const;
 253 
 254 public:
 255   CastIINode(Node *n, const Type *t, bool carry_dependency = false, bool range_check_dependency = false)
 256     : ConstraintCastNode(n,t), _carry_dependency(carry_dependency), _range_check_dependency(range_check_dependency) {
 257     init_class_id(Class_CastII);
 258   }
 259   virtual int Opcode() const;
 260   virtual uint ideal_reg() const { return Op_RegI; }
 261   virtual Node *Identity( PhaseTransform *phase );
 262   virtual const Type *Value( PhaseTransform *phase ) const;
 263   virtual Node *Ideal_DU_postCCP( PhaseCCP * );
 264   const bool has_range_check() {
 265  #ifdef _LP64
 266      return _range_check_dependency;
 267  #else
 268      assert(!_range_check_dependency, "Should not have range check dependency");
 269      return false;
 270  #endif
 271    }
 272 #ifndef PRODUCT
 273   virtual void dump_spec(outputStream *st) const;
 274 #endif
 275 };
 276 
 277 //------------------------------CastPPNode-------------------------------------
 278 // cast pointer to pointer (different type)
 279 class CastPPNode: public ConstraintCastNode {
 280 public:
 281   CastPPNode (Node *n, const Type *t ): ConstraintCastNode(n, t) {}
 282   virtual int Opcode() const;
 283   virtual uint ideal_reg() const { return Op_RegP; }
 284   virtual Node *Ideal_DU_postCCP( PhaseCCP * );
 285 };
 286 
 287 //------------------------------CheckCastPPNode--------------------------------
 288 // for _checkcast, cast pointer to pointer (different type), without JOIN,
 289 class CheckCastPPNode: public TypeNode {
 290 public:
 291   CheckCastPPNode( Node *c, Node *n, const Type *t ) : TypeNode(t,2) {
 292     init_class_id(Class_CheckCastPP);
 293     init_req(0, c);
 294     init_req(1, n);
 295   }
 296 
 297   virtual Node *Identity( PhaseTransform *phase );
 298   virtual const Type *Value( PhaseTransform *phase ) const;
 299   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 300   virtual int   Opcode() const;
 301   virtual uint  ideal_reg() const { return Op_RegP; }
 302   // No longer remove CheckCast after CCP as it gives me a place to hang
 303   // the proper address type - which is required to compute anti-deps.
 304   //virtual Node *Ideal_DU_postCCP( PhaseCCP * );
 305 };
 306 
 307 
 308 //------------------------------EncodeNarrowPtr--------------------------------
 309 class EncodeNarrowPtrNode : public TypeNode {
 310  protected:
 311   EncodeNarrowPtrNode(Node* value, const Type* type):
 312     TypeNode(type, 2) {
 313     init_class_id(Class_EncodeNarrowPtr);
 314     init_req(0, NULL);
 315     init_req(1, value);
 316   }
 317  public:
 318   virtual uint  ideal_reg() const { return Op_RegN; }
 319   virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
 320 };
 321 
 322 //------------------------------EncodeP--------------------------------
 323 // Encodes an oop pointers into its compressed form
 324 // Takes an extra argument which is the real heap base as a long which
 325 // may be useful for code generation in the backend.
 326 class EncodePNode : public EncodeNarrowPtrNode {
 327  public:
 328   EncodePNode(Node* value, const Type* type):
 329     EncodeNarrowPtrNode(value, type) {
 330     init_class_id(Class_EncodeP);
 331   }
 332   virtual int Opcode() const;
 333   virtual Node *Identity( PhaseTransform *phase );
 334   virtual const Type *Value( PhaseTransform *phase ) const;
 335 };
 336 
 337 //------------------------------EncodePKlass--------------------------------
 338 // Encodes a klass pointer into its compressed form
 339 // Takes an extra argument which is the real heap base as a long which
 340 // may be useful for code generation in the backend.
 341 class EncodePKlassNode : public EncodeNarrowPtrNode {
 342  public:
 343   EncodePKlassNode(Node* value, const Type* type):
 344     EncodeNarrowPtrNode(value, type) {
 345     init_class_id(Class_EncodePKlass);
 346   }
 347   virtual int Opcode() const;
 348   virtual Node *Identity( PhaseTransform *phase );
 349   virtual const Type *Value( PhaseTransform *phase ) const;
 350 };
 351 
 352 //------------------------------DecodeNarrowPtr--------------------------------
 353 class DecodeNarrowPtrNode : public TypeNode {
 354  protected:
 355   DecodeNarrowPtrNode(Node* value, const Type* type):
 356     TypeNode(type, 2) {
 357     init_class_id(Class_DecodeNarrowPtr);
 358     init_req(0, NULL);
 359     init_req(1, value);
 360   }
 361  public:
 362   virtual uint  ideal_reg() const { return Op_RegP; }
 363 };
 364 
 365 //------------------------------DecodeN--------------------------------
 366 // Converts a narrow oop into a real oop ptr.
 367 // Takes an extra argument which is the real heap base as a long which
 368 // may be useful for code generation in the backend.
 369 class DecodeNNode : public DecodeNarrowPtrNode {
 370  public:
 371   DecodeNNode(Node* value, const Type* type):
 372     DecodeNarrowPtrNode(value, type) {
 373     init_class_id(Class_DecodeN);
 374   }
 375   virtual int Opcode() const;
 376   virtual const Type *Value( PhaseTransform *phase ) const;
 377   virtual Node *Identity( PhaseTransform *phase );
 378 };
 379 
 380 //------------------------------DecodeNKlass--------------------------------
 381 // Converts a narrow klass pointer into a real klass ptr.
 382 // Takes an extra argument which is the real heap base as a long which
 383 // may be useful for code generation in the backend.
 384 class DecodeNKlassNode : public DecodeNarrowPtrNode {
 385  public:
 386   DecodeNKlassNode(Node* value, const Type* type):
 387     DecodeNarrowPtrNode(value, type) {
 388     init_class_id(Class_DecodeNKlass);
 389   }
 390   virtual int Opcode() const;
 391   virtual const Type *Value( PhaseTransform *phase ) const;
 392   virtual Node *Identity( PhaseTransform *phase );
 393 };
 394 
 395 //------------------------------Conv2BNode-------------------------------------
 396 // Convert int/pointer to a Boolean.  Map zero to zero, all else to 1.
 397 class Conv2BNode : public Node {
 398 public:
 399   Conv2BNode( Node *i ) : Node(0,i) {}
 400   virtual int Opcode() const;
 401   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
 402   virtual Node *Identity( PhaseTransform *phase );
 403   virtual const Type *Value( PhaseTransform *phase ) const;
 404   virtual uint  ideal_reg() const { return Op_RegI; }
 405 };
 406 
 407 // The conversions operations are all Alpha sorted.  Please keep it that way!
 408 //------------------------------ConvD2FNode------------------------------------
 409 // Convert double to float
 410 class ConvD2FNode : public Node {
 411 public:
 412   ConvD2FNode( Node *in1 ) : Node(0,in1) {}
 413   virtual int Opcode() const;
 414   virtual const Type *bottom_type() const { return Type::FLOAT; }
 415   virtual const Type *Value( PhaseTransform *phase ) const;
 416   virtual Node *Identity( PhaseTransform *phase );
 417   virtual uint  ideal_reg() const { return Op_RegF; }
 418 };
 419 
 420 //------------------------------ConvD2INode------------------------------------
 421 // Convert Double to Integer
 422 class ConvD2INode : public Node {
 423 public:
 424   ConvD2INode( Node *in1 ) : Node(0,in1) {}
 425   virtual int Opcode() const;
 426   virtual const Type *bottom_type() const { return TypeInt::INT; }
 427   virtual const Type *Value( PhaseTransform *phase ) const;
 428   virtual Node *Identity( PhaseTransform *phase );
 429   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 430   virtual uint  ideal_reg() const { return Op_RegI; }
 431 };
 432 
 433 //------------------------------ConvD2LNode------------------------------------
 434 // Convert Double to Long
 435 class ConvD2LNode : public Node {
 436 public:
 437   ConvD2LNode( Node *dbl ) : Node(0,dbl) {}
 438   virtual int Opcode() const;
 439   virtual const Type *bottom_type() const { return TypeLong::LONG; }
 440   virtual const Type *Value( PhaseTransform *phase ) const;
 441   virtual Node *Identity( PhaseTransform *phase );
 442   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 443   virtual uint ideal_reg() const { return Op_RegL; }
 444 };
 445 
 446 //------------------------------ConvF2DNode------------------------------------
 447 // Convert Float to a Double.
 448 class ConvF2DNode : public Node {
 449 public:
 450   ConvF2DNode( Node *in1 ) : Node(0,in1) {}
 451   virtual int Opcode() const;
 452   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 453   virtual const Type *Value( PhaseTransform *phase ) const;
 454   virtual uint  ideal_reg() const { return Op_RegD; }
 455 };
 456 
 457 //------------------------------ConvF2INode------------------------------------
 458 // Convert float to integer
 459 class ConvF2INode : public Node {
 460 public:
 461   ConvF2INode( Node *in1 ) : Node(0,in1) {}
 462   virtual int Opcode() const;
 463   virtual const Type *bottom_type() const { return TypeInt::INT; }
 464   virtual const Type *Value( PhaseTransform *phase ) const;
 465   virtual Node *Identity( PhaseTransform *phase );
 466   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 467   virtual uint  ideal_reg() const { return Op_RegI; }
 468 };
 469 
 470 //------------------------------ConvF2LNode------------------------------------
 471 // Convert float to long
 472 class ConvF2LNode : public Node {
 473 public:
 474   ConvF2LNode( Node *in1 ) : Node(0,in1) {}
 475   virtual int Opcode() const;
 476   virtual const Type *bottom_type() const { return TypeLong::LONG; }
 477   virtual const Type *Value( PhaseTransform *phase ) const;
 478   virtual Node *Identity( PhaseTransform *phase );
 479   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 480   virtual uint  ideal_reg() const { return Op_RegL; }
 481 };
 482 
 483 //------------------------------ConvI2DNode------------------------------------
 484 // Convert Integer to Double
 485 class ConvI2DNode : public Node {
 486 public:
 487   ConvI2DNode( Node *in1 ) : Node(0,in1) {}
 488   virtual int Opcode() const;
 489   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 490   virtual const Type *Value( PhaseTransform *phase ) const;
 491   virtual uint  ideal_reg() const { return Op_RegD; }
 492 };
 493 
 494 //------------------------------ConvI2FNode------------------------------------
 495 // Convert Integer to Float
 496 class ConvI2FNode : public Node {
 497 public:
 498   ConvI2FNode( Node *in1 ) : Node(0,in1) {}
 499   virtual int Opcode() const;
 500   virtual const Type *bottom_type() const { return Type::FLOAT; }
 501   virtual const Type *Value( PhaseTransform *phase ) const;
 502   virtual Node *Identity( PhaseTransform *phase );
 503   virtual uint  ideal_reg() const { return Op_RegF; }
 504 };
 505 
 506 //------------------------------ConvI2LNode------------------------------------
 507 // Convert integer to long
 508 class ConvI2LNode : public TypeNode {
 509 public:
 510   ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT)
 511     : TypeNode(t, 2)
 512   { init_req(1, in1); }
 513   virtual int Opcode() const;
 514   virtual const Type *Value( PhaseTransform *phase ) const;
 515   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 516   virtual uint  ideal_reg() const { return Op_RegL; }
 517 };
 518 
 519 //------------------------------ConvL2DNode------------------------------------
 520 // Convert Long to Double
 521 class ConvL2DNode : public Node {
 522 public:
 523   ConvL2DNode( Node *in1 ) : Node(0,in1) {}
 524   virtual int Opcode() const;
 525   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 526   virtual const Type *Value( PhaseTransform *phase ) const;
 527   virtual uint ideal_reg() const { return Op_RegD; }
 528 };
 529 
 530 //------------------------------ConvL2FNode------------------------------------
 531 // Convert Long to Float
 532 class ConvL2FNode : public Node {
 533 public:
 534   ConvL2FNode( Node *in1 ) : Node(0,in1) {}
 535   virtual int Opcode() const;
 536   virtual const Type *bottom_type() const { return Type::FLOAT; }
 537   virtual const Type *Value( PhaseTransform *phase ) const;
 538   virtual uint  ideal_reg() const { return Op_RegF; }
 539 };
 540 
 541 //------------------------------ConvL2INode------------------------------------
 542 // Convert long to integer
 543 class ConvL2INode : public Node {
 544 public:
 545   ConvL2INode( Node *in1 ) : Node(0,in1) {}
 546   virtual int Opcode() const;
 547   virtual const Type *bottom_type() const { return TypeInt::INT; }
 548   virtual Node *Identity( PhaseTransform *phase );
 549   virtual const Type *Value( PhaseTransform *phase ) const;
 550   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 551   virtual uint  ideal_reg() const { return Op_RegI; }
 552 };
 553 
 554 //------------------------------CastX2PNode-------------------------------------
 555 // convert a machine-pointer-sized integer to a raw pointer
 556 class CastX2PNode : public Node {
 557 public:
 558   CastX2PNode( Node *n ) : Node(NULL, n) {}
 559   virtual int Opcode() const;
 560   virtual const Type *Value( PhaseTransform *phase ) const;
 561   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 562   virtual Node *Identity( PhaseTransform *phase );
 563   virtual uint ideal_reg() const { return Op_RegP; }
 564   virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
 565 };
 566 
 567 //------------------------------CastP2XNode-------------------------------------
 568 // Used in both 32-bit and 64-bit land.
 569 // Used for card-marks and unsafe pointer math.
 570 class CastP2XNode : public Node {
 571 public:
 572   CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {}
 573   virtual int Opcode() const;
 574   virtual const Type *Value( PhaseTransform *phase ) const;
 575   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 576   virtual Node *Identity( PhaseTransform *phase );
 577   virtual uint ideal_reg() const { return Op_RegX; }
 578   virtual const Type *bottom_type() const { return TypeX_X; }
 579   // Return false to keep node from moving away from an associated card mark.
 580   virtual bool depends_only_on_test() const { return false; }
 581 };
 582 
 583 //------------------------------ThreadLocalNode--------------------------------
 584 // Ideal Node which returns the base of ThreadLocalStorage.
 585 class ThreadLocalNode : public Node {
 586 public:
 587   ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
 588   virtual int Opcode() const;
 589   virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
 590   virtual uint ideal_reg() const { return Op_RegP; }
 591 };
 592 
 593 //------------------------------LoadReturnPCNode-------------------------------
 594 class LoadReturnPCNode: public Node {
 595 public:
 596   LoadReturnPCNode(Node *c) : Node(c) { }
 597   virtual int Opcode() const;
 598   virtual uint ideal_reg() const { return Op_RegP; }
 599 };
 600 
 601 
 602 //-----------------------------RoundFloatNode----------------------------------
 603 class RoundFloatNode: public Node {
 604 public:
 605   RoundFloatNode(Node* c, Node *in1): Node(c, in1) {}
 606   virtual int   Opcode() const;
 607   virtual const Type *bottom_type() const { return Type::FLOAT; }
 608   virtual uint  ideal_reg() const { return Op_RegF; }
 609   virtual Node *Identity( PhaseTransform *phase );
 610   virtual const Type *Value( PhaseTransform *phase ) const;
 611 };
 612 
 613 
 614 //-----------------------------RoundDoubleNode---------------------------------
 615 class RoundDoubleNode: public Node {
 616 public:
 617   RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {}
 618   virtual int   Opcode() const;
 619   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 620   virtual uint  ideal_reg() const { return Op_RegD; }
 621   virtual Node *Identity( PhaseTransform *phase );
 622   virtual const Type *Value( PhaseTransform *phase ) const;
 623 };
 624 
 625 //------------------------------Opaque1Node------------------------------------
 626 // A node to prevent unwanted optimizations.  Allows constant folding.
 627 // Stops value-numbering, Ideal calls or Identity functions.
 628 class Opaque1Node : public Node {
 629   virtual uint hash() const ;                  // { return NO_HASH; }
 630   virtual uint cmp( const Node &n ) const;
 631 public:
 632   Opaque1Node( Compile* C, Node *n ) : Node(0,n) {
 633     // Put it on the Macro nodes list to removed during macro nodes expansion.
 634     init_flags(Flag_is_macro);
 635     C->add_macro_node(this);
 636   }
 637   // Special version for the pre-loop to hold the original loop limit
 638   // which is consumed by range check elimination.
 639   Opaque1Node( Compile* C, Node *n, Node* orig_limit ) : Node(0,n,orig_limit) {
 640     // Put it on the Macro nodes list to removed during macro nodes expansion.
 641     init_flags(Flag_is_macro);
 642     C->add_macro_node(this);
 643   }
 644   Node* original_loop_limit() { return req()==3 ? in(2) : NULL; }
 645   virtual int Opcode() const;
 646   virtual const Type *bottom_type() const { return TypeInt::INT; }
 647   virtual Node *Identity( PhaseTransform *phase );
 648 };
 649 
 650 //------------------------------Opaque2Node------------------------------------
 651 // A node to prevent unwanted optimizations.  Allows constant folding.  Stops
 652 // value-numbering, most Ideal calls or Identity functions.  This Node is
 653 // specifically designed to prevent the pre-increment value of a loop trip
 654 // counter from being live out of the bottom of the loop (hence causing the
 655 // pre- and post-increment values both being live and thus requiring an extra
 656 // temp register and an extra move).  If we "accidentally" optimize through
 657 // this kind of a Node, we'll get slightly pessimal, but correct, code.  Thus
 658 // it's OK to be slightly sloppy on optimizations here.
 659 class Opaque2Node : public Node {
 660   virtual uint hash() const ;                  // { return NO_HASH; }
 661   virtual uint cmp( const Node &n ) const;
 662 public:
 663   Opaque2Node( Compile* C, Node *n ) : Node(0,n) {
 664     // Put it on the Macro nodes list to removed during macro nodes expansion.
 665     init_flags(Flag_is_macro);
 666     C->add_macro_node(this);
 667   }
 668   virtual int Opcode() const;
 669   virtual const Type *bottom_type() const { return TypeInt::INT; }
 670 };
 671 
 672 //------------------------------Opaque3Node------------------------------------
 673 // A node to prevent unwanted optimizations. Will be optimized only during
 674 // macro nodes expansion.
 675 class Opaque3Node : public Opaque2Node {
 676   int _opt; // what optimization it was used for
 677 public:
 678   enum { RTM_OPT };
 679   Opaque3Node(Compile* C, Node *n, int opt) : Opaque2Node(C, n), _opt(opt) {}
 680   virtual int Opcode() const;
 681   bool rtm_opt() const { return (_opt == RTM_OPT); }
 682 };
 683 
 684 //------------------------------ProfileBooleanNode-------------------------------
 685 // A node represents value profile for a boolean during parsing.
 686 // Once parsing is over, the node goes away (during IGVN).
 687 // It is used to override branch frequencies from MDO (see has_injected_profile in parse2.cpp).
 688 class ProfileBooleanNode : public Node {
 689   uint _false_cnt;
 690   uint _true_cnt;
 691   bool _consumed;
 692   bool _delay_removal;
 693   virtual uint hash() const ;                  // { return NO_HASH; }
 694   virtual uint cmp( const Node &n ) const;
 695   public:
 696   ProfileBooleanNode(Node *n, uint false_cnt, uint true_cnt) : Node(0, n),
 697           _false_cnt(false_cnt), _true_cnt(true_cnt), _delay_removal(true), _consumed(false) {}
 698 
 699   uint false_count() const { return _false_cnt; }
 700   uint  true_count() const { return  _true_cnt; }
 701 
 702   void consume() { _consumed = true;  }
 703 
 704   virtual int Opcode() const;
 705   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 706   virtual Node *Identity(PhaseTransform *phase);
 707   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
 708 };
 709 
 710 //----------------------PartialSubtypeCheckNode--------------------------------
 711 // The 2nd slow-half of a subtype check.  Scan the subklass's 2ndary superklass
 712 // array for an instance of the superklass.  Set a hidden internal cache on a
 713 // hit (cache is checked with exposed code in gen_subtype_check()).  Return
 714 // not zero for a miss or zero for a hit.
 715 class PartialSubtypeCheckNode : public Node {
 716 public:
 717   PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {}
 718   virtual int Opcode() const;
 719   virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM; }
 720   virtual uint ideal_reg() const { return Op_RegP; }
 721 };
 722 
 723 //
 724 class MoveI2FNode : public Node {
 725  public:
 726   MoveI2FNode( Node *value ) : Node(0,value) {}
 727   virtual int Opcode() const;
 728   virtual const Type *bottom_type() const { return Type::FLOAT; }
 729   virtual uint ideal_reg() const { return Op_RegF; }
 730   virtual const Type* Value( PhaseTransform *phase ) const;
 731 };
 732 
 733 class MoveL2DNode : public Node {
 734  public:
 735   MoveL2DNode( Node *value ) : Node(0,value) {}
 736   virtual int Opcode() const;
 737   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 738   virtual uint ideal_reg() const { return Op_RegD; }
 739   virtual const Type* Value( PhaseTransform *phase ) const;
 740 };
 741 
 742 class MoveF2INode : public Node {
 743  public:
 744   MoveF2INode( Node *value ) : Node(0,value) {}
 745   virtual int Opcode() const;
 746   virtual const Type *bottom_type() const { return TypeInt::INT; }
 747   virtual uint ideal_reg() const { return Op_RegI; }
 748   virtual const Type* Value( PhaseTransform *phase ) const;
 749 };
 750 
 751 class MoveD2LNode : public Node {
 752  public:
 753   MoveD2LNode( Node *value ) : Node(0,value) {}
 754   virtual int Opcode() const;
 755   virtual const Type *bottom_type() const { return TypeLong::LONG; }
 756   virtual uint ideal_reg() const { return Op_RegL; }
 757   virtual const Type* Value( PhaseTransform *phase ) const;
 758 };
 759 
 760 //---------- CountBitsNode -----------------------------------------------------
 761 class CountBitsNode : public Node {
 762 public:
 763   CountBitsNode(Node* in1) : Node(0, in1) {}
 764   const Type* bottom_type() const { return TypeInt::INT; }
 765   virtual uint ideal_reg() const { return Op_RegI; }
 766 };
 767 
 768 //---------- CountLeadingZerosINode --------------------------------------------
 769 // Count leading zeros (0-bit count starting from MSB) of an integer.
 770 class CountLeadingZerosINode : public CountBitsNode {
 771 public:
 772   CountLeadingZerosINode(Node* in1) : CountBitsNode(in1) {}
 773   virtual int Opcode() const;
 774   virtual const Type* Value(PhaseTransform* phase) const;
 775 };
 776 
 777 //---------- CountLeadingZerosLNode --------------------------------------------
 778 // Count leading zeros (0-bit count starting from MSB) of a long.
 779 class CountLeadingZerosLNode : public CountBitsNode {
 780 public:
 781   CountLeadingZerosLNode(Node* in1) : CountBitsNode(in1) {}
 782   virtual int Opcode() const;
 783   virtual const Type* Value(PhaseTransform* phase) const;
 784 };
 785 
 786 //---------- CountTrailingZerosINode -------------------------------------------
 787 // Count trailing zeros (0-bit count starting from LSB) of an integer.
 788 class CountTrailingZerosINode : public CountBitsNode {
 789 public:
 790   CountTrailingZerosINode(Node* in1) : CountBitsNode(in1) {}
 791   virtual int Opcode() const;
 792   virtual const Type* Value(PhaseTransform* phase) const;
 793 };
 794 
 795 //---------- CountTrailingZerosLNode -------------------------------------------
 796 // Count trailing zeros (0-bit count starting from LSB) of a long.
 797 class CountTrailingZerosLNode : public CountBitsNode {
 798 public:
 799   CountTrailingZerosLNode(Node* in1) : CountBitsNode(in1) {}
 800   virtual int Opcode() const;
 801   virtual const Type* Value(PhaseTransform* phase) const;
 802 };
 803 
 804 //---------- PopCountINode -----------------------------------------------------
 805 // Population count (bit count) of an integer.
 806 class PopCountINode : public CountBitsNode {
 807 public:
 808   PopCountINode(Node* in1) : CountBitsNode(in1) {}
 809   virtual int Opcode() const;
 810 };
 811 
 812 //---------- PopCountLNode -----------------------------------------------------
 813 // Population count (bit count) of a long.
 814 class PopCountLNode : public CountBitsNode {
 815 public:
 816   PopCountLNode(Node* in1) : CountBitsNode(in1) {}
 817   virtual int Opcode() const;
 818 };
 819 
 820 #endif // SHARE_VM_OPTO_CONNODE_HPP
--- EOF ---