68 // Node layout (parallels PhiNode): 69 enum { Region, // Generally points to self. 70 Control // Control arcs are [1..len) 71 }; 72 73 RegionNode( uint required ) : Node(required) { 74 init_class_id(Class_Region); 75 init_req(0,this); 76 } 77 78 Node* is_copy() const { 79 const Node* r = _in[Region]; 80 if (r == NULL) 81 return nonnull_req(); 82 return NULL; // not a copy! 83 } 84 PhiNode* has_phi() const; // returns an arbitrary phi user, or NULL 85 PhiNode* has_unique_phi() const; // returns the unique phi user, or NULL 86 // Is this region node unreachable from root? 87 bool is_unreachable_region(PhaseGVN *phase) const; 88 virtual int Opcode() const; 89 virtual bool pinned() const { return (const Node *)in(0) == this; } 90 virtual bool is_CFG () const { return true; } 91 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 92 virtual bool depends_only_on_test() const { return false; } 93 virtual const Type *bottom_type() const { return Type::CONTROL; } 94 virtual const Type* Value(PhaseGVN* phase) const; 95 virtual Node* Identity(PhaseGVN* phase); 96 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 97 virtual const RegMask &out_RegMask() const; 98 bool try_clean_mem_phi(PhaseGVN *phase); 99 }; 100 101 //------------------------------JProjNode-------------------------------------- 102 // jump projection for node that produces multiple control-flow paths 103 class JProjNode : public ProjNode { 104 public: 105 JProjNode( Node* ctrl, uint idx ) : ProjNode(ctrl,idx) {} 106 virtual int Opcode() const; 107 virtual bool is_CFG() const { return true; } 108 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 109 virtual const Node* is_block_proj() const { return in(0); } 110 virtual const RegMask& out_RegMask() const; 111 virtual uint ideal_reg() const { return 0; } 112 }; 113 114 //------------------------------PhiNode---------------------------------------- 115 // PhiNodes merge values from different Control paths. Slot 0 points to the 116 // controlling RegionNode. Other slots map 1-for-1 with incoming control flow 117 // paths to the RegionNode. For speed reasons (to avoid another pass) we 118 // can turn PhiNodes into copys in-place by NULL'ing out their RegionNode 119 // input in slot 0. 120 class PhiNode : public TypeNode { 121 const TypePtr* const _adr_type; // non-null only for Type::MEMORY nodes. 122 const int _inst_id; // Instance id of the memory slice. 123 const int _inst_index; // Alias index of the instance memory slice. 124 // Array elements references have the same alias_idx but different offset. 125 const int _inst_offset; // Offset of the instance memory slice. 126 // Size is bigger to hold the _adr_type field. 173 174 bool is_tripcount() const; 175 176 // Determine a unique non-trivial input, if any. 177 // Ignore casts if it helps. Return NULL on failure. 178 Node* unique_input(PhaseTransform *phase, bool uncast); 179 Node* unique_input(PhaseTransform *phase) { 180 Node* uin = unique_input(phase, false); 181 if (uin == NULL) { 182 uin = unique_input(phase, true); 183 } 184 return uin; 185 } 186 187 // Check for a simple dead loop. 188 enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; 189 LoopSafety simple_data_loop_check(Node *in) const; 190 // Is it unsafe data loop? It becomes a dead loop if this phi node removed. 191 bool is_unsafe_data_reference(Node *in) const; 192 int is_diamond_phi(bool check_control_only = false) const; 193 virtual int Opcode() const; 194 virtual bool pinned() const { return in(0) != 0; } 195 virtual const TypePtr *adr_type() const { verify_adr_type(true); return _adr_type; } 196 197 const int inst_id() const { return _inst_id; } 198 const int inst_index() const { return _inst_index; } 199 const int inst_offset() const { return _inst_offset; } 200 bool is_same_inst_field(const Type* tp, int id, int index, int offset) { 201 return type()->basic_type() == tp->basic_type() && 202 inst_id() == id && 203 inst_index() == index && 204 inst_offset() == offset && 205 type()->higher_equal(tp); 206 } 207 208 virtual const Type* Value(PhaseGVN* phase) const; 209 virtual Node* Identity(PhaseGVN* phase); 210 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 211 virtual const RegMask &out_RegMask() const; 212 virtual const RegMask &in_RegMask(uint) const; 213 #ifndef PRODUCT 214 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 215 virtual void dump_spec(outputStream *st) const; 216 #endif 217 #ifdef ASSERT 218 void verify_adr_type(VectorSet& visited, const TypePtr* at) const; 219 void verify_adr_type(bool recursive = false) const; 220 #else //ASSERT 221 void verify_adr_type(bool recursive = false) const {} 222 #endif //ASSERT 223 }; 224 225 //------------------------------GotoNode--------------------------------------- 226 // GotoNodes perform direct branches. 227 class GotoNode : public Node { 228 public: 229 GotoNode( Node *control ) : Node(control) {} 230 virtual int Opcode() const; 231 virtual bool pinned() const { return true; } 232 virtual bool is_CFG() const { return true; } 233 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 234 virtual const Node *is_block_proj() const { return this; } 235 virtual bool depends_only_on_test() const { return false; } 236 virtual const Type *bottom_type() const { return Type::CONTROL; } 237 virtual const Type* Value(PhaseGVN* phase) const; 238 virtual Node* Identity(PhaseGVN* phase); 239 virtual const RegMask &out_RegMask() const; 240 241 #ifndef PRODUCT 242 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 243 #endif 244 }; 245 246 //------------------------------CProjNode-------------------------------------- 247 // control projection for node that produces multiple control-flow paths 248 class CProjNode : public ProjNode { 249 public: 250 CProjNode( Node *ctrl, uint idx ) : ProjNode(ctrl,idx) {} 251 virtual int Opcode() const; 252 virtual bool is_CFG() const { return true; } 253 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 254 virtual const Node *is_block_proj() const { return in(0); } 255 virtual const RegMask &out_RegMask() const; 256 virtual uint ideal_reg() const { return 0; } 257 }; 258 259 //---------------------------MultiBranchNode----------------------------------- 260 // This class defines a MultiBranchNode, a MultiNode which yields multiple 261 // control values. These are distinguished from other types of MultiNodes 262 // which yield multiple values, but control is always and only projection #0. 263 class MultiBranchNode : public MultiNode { 264 public: 265 MultiBranchNode( uint required ) : MultiNode(required) { 266 init_class_id(Class_MultiBranch); 267 } 268 // returns required number of users to be well formed. 269 virtual int required_outcnt() const = 0; 270 }; 271 356 // likelihood of needing a gc if eden top moves during an allocation 357 // likelihood of a predicted call failure 358 // 359 // 1 in 100,000 probabilities (magnitude 5): 360 // threshold for ignoring counts when estimating path frequency 361 // likelihood of FP clipping failure 362 // likelihood of catching an exception from a try block 363 // likelihood of null check failure if a null has NOT been seen before 364 // 365 // Magic manifest probabilities such as 0.83, 0.7, ... can be found in 366 // gen_subtype_check() and catch_inline_exceptions(). 367 368 float _prob; // Probability of true path being taken. 369 float _fcnt; // Frequency counter 370 IfNode( Node *control, Node *b, float p, float fcnt ) 371 : MultiBranchNode(2), _prob(p), _fcnt(fcnt) { 372 init_class_id(Class_If); 373 init_req(0,control); 374 init_req(1,b); 375 } 376 virtual int Opcode() const; 377 virtual bool pinned() const { return true; } 378 virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } 379 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 380 virtual const Type* Value(PhaseGVN* phase) const; 381 virtual int required_outcnt() const { return 2; } 382 virtual const RegMask &out_RegMask() const; 383 Node* fold_compares(PhaseIterGVN* phase); 384 static Node* up_one_dom(Node* curr, bool linear_only = false); 385 386 // Takes the type of val and filters it through the test represented 387 // by if_proj and returns a more refined type if one is produced. 388 // Returns NULL is it couldn't improve the type. 389 static const TypeInt* filtered_int_type(PhaseGVN* phase, Node* val, Node* if_proj); 390 391 #ifndef PRODUCT 392 virtual void dump_spec(outputStream *st) const; 393 virtual void related(GrowableArray <Node *> *in_rel, GrowableArray <Node *> *out_rel, bool compact) const; 394 #endif 395 }; 396 397 class RangeCheckNode : public IfNode { 398 private: 399 int is_range_check(Node* &range, Node* &index, jint &offset); 400 401 public: 402 RangeCheckNode(Node* control, Node *b, float p, float fcnt) 403 : IfNode(control, b, p, fcnt) { 404 init_class_id(Class_RangeCheck); 405 } 406 407 virtual int Opcode() const; 408 virtual Node* Ideal(PhaseGVN *phase, bool can_reshape); 409 }; 410 411 class IfProjNode : public CProjNode { 412 public: 413 IfProjNode(IfNode *ifnode, uint idx) : CProjNode(ifnode,idx) {} 414 virtual Node* Identity(PhaseGVN* phase); 415 416 protected: 417 // Type of If input when this branch is always taken 418 virtual bool always_taken(const TypeTuple* t) const = 0; 419 420 #ifndef PRODUCT 421 public: 422 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 423 #endif 424 }; 425 426 class IfTrueNode : public IfProjNode { 427 public: 428 IfTrueNode( IfNode *ifnode ) : IfProjNode(ifnode,1) { 429 init_class_id(Class_IfTrue); 430 } 431 virtual int Opcode() const; 432 433 protected: 434 virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFTRUE; } 435 }; 436 437 class IfFalseNode : public IfProjNode { 438 public: 439 IfFalseNode( IfNode *ifnode ) : IfProjNode(ifnode,0) { 440 init_class_id(Class_IfFalse); 441 } 442 virtual int Opcode() const; 443 444 protected: 445 virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFFALSE; } 446 }; 447 448 449 //------------------------------PCTableNode------------------------------------ 450 // Build an indirect branch table. Given a control and a table index, 451 // control is passed to the Projection matching the table index. Used to 452 // implement switch statements and exception-handling capabilities. 453 // Undefined behavior if passed-in index is not inside the table. 454 class PCTableNode : public MultiBranchNode { 455 virtual uint hash() const; // Target count; table size 456 virtual uint cmp( const Node &n ) const; 457 virtual uint size_of() const { return sizeof(*this); } 458 459 public: 460 const uint _size; // Number of targets 461 462 PCTableNode( Node *ctrl, Node *idx, uint size ) : MultiBranchNode(2), _size(size) { 463 init_class_id(Class_PCTable); 464 init_req(0, ctrl); 465 init_req(1, idx); 466 } 467 virtual int Opcode() const; 468 virtual const Type* Value(PhaseGVN* phase) const; 469 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 470 virtual const Type *bottom_type() const; 471 virtual bool pinned() const { return true; } 472 virtual int required_outcnt() const { return _size; } 473 }; 474 475 //------------------------------JumpNode--------------------------------------- 476 // Indirect branch. Uses PCTable above to implement a switch statement. 477 // It emits as a table load and local branch. 478 class JumpNode : public PCTableNode { 479 public: 480 JumpNode( Node* control, Node* switch_val, uint size) : PCTableNode(control, switch_val, size) { 481 init_class_id(Class_Jump); 482 } 483 virtual int Opcode() const; 484 virtual const RegMask& out_RegMask() const; 485 virtual const Node* is_block_proj() const { return this; } 486 #ifndef PRODUCT 487 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 488 #endif 489 }; 490 491 class JumpProjNode : public JProjNode { 492 virtual uint hash() const; 493 virtual uint cmp( const Node &n ) const; 494 virtual uint size_of() const { return sizeof(*this); } 495 496 private: 497 const int _dest_bci; 498 const uint _proj_no; 499 const int _switch_val; 500 public: 501 JumpProjNode(Node* jumpnode, uint proj_no, int dest_bci, int switch_val) 502 : JProjNode(jumpnode, proj_no), _dest_bci(dest_bci), _proj_no(proj_no), _switch_val(switch_val) { 503 init_class_id(Class_JumpProj); 504 } 505 506 virtual int Opcode() const; 507 virtual const Type* bottom_type() const { return Type::CONTROL; } 508 int dest_bci() const { return _dest_bci; } 509 int switch_val() const { return _switch_val; } 510 uint proj_no() const { return _proj_no; } 511 #ifndef PRODUCT 512 virtual void dump_spec(outputStream *st) const; 513 virtual void dump_compact_spec(outputStream *st) const; 514 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 515 #endif 516 }; 517 518 //------------------------------CatchNode-------------------------------------- 519 // Helper node to fork exceptions. "Catch" catches any exceptions thrown by 520 // a just-prior call. Looks like a PCTableNode but emits no code - just the 521 // table. The table lookup and branch is implemented by RethrowNode. 522 class CatchNode : public PCTableNode { 523 public: 524 CatchNode( Node *ctrl, Node *idx, uint size ) : PCTableNode(ctrl,idx,size){ 525 init_class_id(Class_Catch); 526 } 527 virtual int Opcode() const; 528 virtual const Type* Value(PhaseGVN* phase) const; 529 }; 530 531 // CatchProjNode controls which exception handler is targetted after a call. 532 // It is passed in the bci of the target handler, or no_handler_bci in case 533 // the projection doesn't lead to an exception handler. 534 class CatchProjNode : public CProjNode { 535 virtual uint hash() const; 536 virtual uint cmp( const Node &n ) const; 537 virtual uint size_of() const { return sizeof(*this); } 538 539 private: 540 const int _handler_bci; 541 542 public: 543 enum { 544 fall_through_index = 0, // the fall through projection index 545 catch_all_index = 1, // the projection index for catch-alls 546 no_handler_bci = -1 // the bci for fall through or catch-all projs 547 }; 548 549 CatchProjNode(Node* catchnode, uint proj_no, int handler_bci) 550 : CProjNode(catchnode, proj_no), _handler_bci(handler_bci) { 551 init_class_id(Class_CatchProj); 552 assert(proj_no != fall_through_index || handler_bci < 0, "fall through case must have bci < 0"); 553 } 554 555 virtual int Opcode() const; 556 virtual Node* Identity(PhaseGVN* phase); 557 virtual const Type *bottom_type() const { return Type::CONTROL; } 558 int handler_bci() const { return _handler_bci; } 559 bool is_handler_proj() const { return _handler_bci >= 0; } 560 #ifndef PRODUCT 561 virtual void dump_spec(outputStream *st) const; 562 #endif 563 }; 564 565 566 //---------------------------------CreateExNode-------------------------------- 567 // Helper node to create the exception coming back from a call 568 class CreateExNode : public TypeNode { 569 public: 570 CreateExNode(const Type* t, Node* control, Node* i_o) : TypeNode(t, 2) { 571 init_req(0, control); 572 init_req(1, i_o); 573 } 574 virtual int Opcode() const; 575 virtual Node* Identity(PhaseGVN* phase); 576 virtual bool pinned() const { return true; } 577 uint match_edge(uint idx) const { return 0; } 578 virtual uint ideal_reg() const { return Op_RegP; } 579 }; 580 581 //------------------------------NeverBranchNode------------------------------- 582 // The never-taken branch. Used to give the appearance of exiting infinite 583 // loops to those algorithms that like all paths to be reachable. Encodes 584 // empty. 585 class NeverBranchNode : public MultiBranchNode { 586 public: 587 NeverBranchNode( Node *ctrl ) : MultiBranchNode(1) { init_req(0,ctrl); } 588 virtual int Opcode() const; 589 virtual bool pinned() const { return true; }; 590 virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } 591 virtual const Type* Value(PhaseGVN* phase) const; 592 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 593 virtual int required_outcnt() const { return 2; } 594 virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { } 595 virtual uint size(PhaseRegAlloc *ra_) const { return 0; } 596 #ifndef PRODUCT 597 virtual void format( PhaseRegAlloc *, outputStream *st ) const; 598 #endif 599 }; 600 601 #endif // SHARE_VM_OPTO_CFGNODE_HPP | 68 // Node layout (parallels PhiNode): 69 enum { Region, // Generally points to self. 70 Control // Control arcs are [1..len) 71 }; 72 73 RegionNode( uint required ) : Node(required) { 74 init_class_id(Class_Region); 75 init_req(0,this); 76 } 77 78 Node* is_copy() const { 79 const Node* r = _in[Region]; 80 if (r == NULL) 81 return nonnull_req(); 82 return NULL; // not a copy! 83 } 84 PhiNode* has_phi() const; // returns an arbitrary phi user, or NULL 85 PhiNode* has_unique_phi() const; // returns the unique phi user, or NULL 86 // Is this region node unreachable from root? 87 bool is_unreachable_region(PhaseGVN *phase) const; 88 virtual uint Opcode() const; 89 virtual bool pinned() const { return (const Node *)in(0) == this; } 90 virtual bool is_CFG () const { return true; } 91 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 92 virtual bool depends_only_on_test() const { return false; } 93 virtual const Type *bottom_type() const { return Type::CONTROL; } 94 virtual const Type* Value(PhaseGVN* phase) const; 95 virtual Node* Identity(PhaseGVN* phase); 96 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 97 virtual const RegMask &out_RegMask() const; 98 bool try_clean_mem_phi(PhaseGVN *phase); 99 }; 100 101 //------------------------------JProjNode-------------------------------------- 102 // jump projection for node that produces multiple control-flow paths 103 class JProjNode : public ProjNode { 104 public: 105 JProjNode( Node* ctrl, uint idx ) : ProjNode(ctrl,idx) {} 106 virtual uint Opcode() const; 107 virtual bool is_CFG() const { return true; } 108 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 109 virtual const Node* is_block_proj() const { return in(0); } 110 virtual const RegMask& out_RegMask() const; 111 virtual uint ideal_reg() const { return 0; } 112 }; 113 114 //------------------------------PhiNode---------------------------------------- 115 // PhiNodes merge values from different Control paths. Slot 0 points to the 116 // controlling RegionNode. Other slots map 1-for-1 with incoming control flow 117 // paths to the RegionNode. For speed reasons (to avoid another pass) we 118 // can turn PhiNodes into copys in-place by NULL'ing out their RegionNode 119 // input in slot 0. 120 class PhiNode : public TypeNode { 121 const TypePtr* const _adr_type; // non-null only for Type::MEMORY nodes. 122 const int _inst_id; // Instance id of the memory slice. 123 const int _inst_index; // Alias index of the instance memory slice. 124 // Array elements references have the same alias_idx but different offset. 125 const int _inst_offset; // Offset of the instance memory slice. 126 // Size is bigger to hold the _adr_type field. 173 174 bool is_tripcount() const; 175 176 // Determine a unique non-trivial input, if any. 177 // Ignore casts if it helps. Return NULL on failure. 178 Node* unique_input(PhaseTransform *phase, bool uncast); 179 Node* unique_input(PhaseTransform *phase) { 180 Node* uin = unique_input(phase, false); 181 if (uin == NULL) { 182 uin = unique_input(phase, true); 183 } 184 return uin; 185 } 186 187 // Check for a simple dead loop. 188 enum LoopSafety { Safe = 0, Unsafe, UnsafeLoop }; 189 LoopSafety simple_data_loop_check(Node *in) const; 190 // Is it unsafe data loop? It becomes a dead loop if this phi node removed. 191 bool is_unsafe_data_reference(Node *in) const; 192 int is_diamond_phi(bool check_control_only = false) const; 193 virtual uint Opcode() const; 194 virtual bool pinned() const { return in(0) != 0; } 195 virtual const TypePtr *adr_type() const { verify_adr_type(true); return _adr_type; } 196 197 const int inst_id() const { return _inst_id; } 198 const int inst_index() const { return _inst_index; } 199 const int inst_offset() const { return _inst_offset; } 200 bool is_same_inst_field(const Type* tp, int id, int index, int offset) { 201 return type()->basic_type() == tp->basic_type() && 202 inst_id() == id && 203 inst_index() == index && 204 inst_offset() == offset && 205 type()->higher_equal(tp); 206 } 207 208 virtual const Type* Value(PhaseGVN* phase) const; 209 virtual Node* Identity(PhaseGVN* phase); 210 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 211 virtual const RegMask &out_RegMask() const; 212 virtual const RegMask &in_RegMask(uint) const; 213 #ifndef PRODUCT 214 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 215 virtual void dump_spec(outputStream *st) const; 216 #endif 217 #ifdef ASSERT 218 void verify_adr_type(VectorSet& visited, const TypePtr* at) const; 219 void verify_adr_type(bool recursive = false) const; 220 #else //ASSERT 221 void verify_adr_type(bool recursive = false) const {} 222 #endif //ASSERT 223 }; 224 225 //------------------------------GotoNode--------------------------------------- 226 // GotoNodes perform direct branches. 227 class GotoNode : public Node { 228 public: 229 GotoNode( Node *control ) : Node(control) {} 230 virtual uint Opcode() const; 231 virtual bool pinned() const { return true; } 232 virtual bool is_CFG() const { return true; } 233 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 234 virtual const Node *is_block_proj() const { return this; } 235 virtual bool depends_only_on_test() const { return false; } 236 virtual const Type *bottom_type() const { return Type::CONTROL; } 237 virtual const Type* Value(PhaseGVN* phase) const; 238 virtual Node* Identity(PhaseGVN* phase); 239 virtual const RegMask &out_RegMask() const; 240 241 #ifndef PRODUCT 242 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 243 #endif 244 }; 245 246 //------------------------------CProjNode-------------------------------------- 247 // control projection for node that produces multiple control-flow paths 248 class CProjNode : public ProjNode { 249 public: 250 CProjNode( Node *ctrl, uint idx ) : ProjNode(ctrl,idx) {} 251 virtual uint Opcode() const; 252 virtual bool is_CFG() const { return true; } 253 virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash 254 virtual const Node *is_block_proj() const { return in(0); } 255 virtual const RegMask &out_RegMask() const; 256 virtual uint ideal_reg() const { return 0; } 257 }; 258 259 //---------------------------MultiBranchNode----------------------------------- 260 // This class defines a MultiBranchNode, a MultiNode which yields multiple 261 // control values. These are distinguished from other types of MultiNodes 262 // which yield multiple values, but control is always and only projection #0. 263 class MultiBranchNode : public MultiNode { 264 public: 265 MultiBranchNode( uint required ) : MultiNode(required) { 266 init_class_id(Class_MultiBranch); 267 } 268 // returns required number of users to be well formed. 269 virtual int required_outcnt() const = 0; 270 }; 271 356 // likelihood of needing a gc if eden top moves during an allocation 357 // likelihood of a predicted call failure 358 // 359 // 1 in 100,000 probabilities (magnitude 5): 360 // threshold for ignoring counts when estimating path frequency 361 // likelihood of FP clipping failure 362 // likelihood of catching an exception from a try block 363 // likelihood of null check failure if a null has NOT been seen before 364 // 365 // Magic manifest probabilities such as 0.83, 0.7, ... can be found in 366 // gen_subtype_check() and catch_inline_exceptions(). 367 368 float _prob; // Probability of true path being taken. 369 float _fcnt; // Frequency counter 370 IfNode( Node *control, Node *b, float p, float fcnt ) 371 : MultiBranchNode(2), _prob(p), _fcnt(fcnt) { 372 init_class_id(Class_If); 373 init_req(0,control); 374 init_req(1,b); 375 } 376 virtual uint Opcode() const; 377 virtual bool pinned() const { return true; } 378 virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } 379 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 380 virtual const Type* Value(PhaseGVN* phase) const; 381 virtual int required_outcnt() const { return 2; } 382 virtual const RegMask &out_RegMask() const; 383 Node* fold_compares(PhaseIterGVN* phase); 384 static Node* up_one_dom(Node* curr, bool linear_only = false); 385 386 // Takes the type of val and filters it through the test represented 387 // by if_proj and returns a more refined type if one is produced. 388 // Returns NULL is it couldn't improve the type. 389 static const TypeInt* filtered_int_type(PhaseGVN* phase, Node* val, Node* if_proj); 390 391 #ifndef PRODUCT 392 virtual void dump_spec(outputStream *st) const; 393 virtual void related(GrowableArray <Node *> *in_rel, GrowableArray <Node *> *out_rel, bool compact) const; 394 #endif 395 }; 396 397 class RangeCheckNode : public IfNode { 398 private: 399 int is_range_check(Node* &range, Node* &index, jint &offset); 400 401 public: 402 RangeCheckNode(Node* control, Node *b, float p, float fcnt) 403 : IfNode(control, b, p, fcnt) { 404 init_class_id(Class_RangeCheck); 405 } 406 407 virtual uint Opcode() const; 408 virtual Node* Ideal(PhaseGVN *phase, bool can_reshape); 409 }; 410 411 class IfProjNode : public CProjNode { 412 public: 413 IfProjNode(IfNode *ifnode, uint idx) : CProjNode(ifnode,idx) {} 414 virtual Node* Identity(PhaseGVN* phase); 415 416 protected: 417 // Type of If input when this branch is always taken 418 virtual bool always_taken(const TypeTuple* t) const = 0; 419 420 #ifndef PRODUCT 421 public: 422 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 423 #endif 424 }; 425 426 class IfTrueNode : public IfProjNode { 427 public: 428 IfTrueNode( IfNode *ifnode ) : IfProjNode(ifnode,1) { 429 init_class_id(Class_IfTrue); 430 } 431 virtual uint Opcode() const; 432 433 protected: 434 virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFTRUE; } 435 }; 436 437 class IfFalseNode : public IfProjNode { 438 public: 439 IfFalseNode( IfNode *ifnode ) : IfProjNode(ifnode,0) { 440 init_class_id(Class_IfFalse); 441 } 442 virtual uint Opcode() const; 443 444 protected: 445 virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFFALSE; } 446 }; 447 448 449 //------------------------------PCTableNode------------------------------------ 450 // Build an indirect branch table. Given a control and a table index, 451 // control is passed to the Projection matching the table index. Used to 452 // implement switch statements and exception-handling capabilities. 453 // Undefined behavior if passed-in index is not inside the table. 454 class PCTableNode : public MultiBranchNode { 455 virtual uint hash() const; // Target count; table size 456 virtual uint cmp( const Node &n ) const; 457 virtual uint size_of() const { return sizeof(*this); } 458 459 public: 460 const uint _size; // Number of targets 461 462 PCTableNode( Node *ctrl, Node *idx, uint size ) : MultiBranchNode(2), _size(size) { 463 init_class_id(Class_PCTable); 464 init_req(0, ctrl); 465 init_req(1, idx); 466 } 467 virtual uint Opcode() const; 468 virtual const Type* Value(PhaseGVN* phase) const; 469 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 470 virtual const Type *bottom_type() const; 471 virtual bool pinned() const { return true; } 472 virtual int required_outcnt() const { return _size; } 473 }; 474 475 //------------------------------JumpNode--------------------------------------- 476 // Indirect branch. Uses PCTable above to implement a switch statement. 477 // It emits as a table load and local branch. 478 class JumpNode : public PCTableNode { 479 public: 480 JumpNode( Node* control, Node* switch_val, uint size) : PCTableNode(control, switch_val, size) { 481 init_class_id(Class_Jump); 482 } 483 virtual uint Opcode() const; 484 virtual const RegMask& out_RegMask() const; 485 virtual const Node* is_block_proj() const { return this; } 486 #ifndef PRODUCT 487 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 488 #endif 489 }; 490 491 class JumpProjNode : public JProjNode { 492 virtual uint hash() const; 493 virtual uint cmp( const Node &n ) const; 494 virtual uint size_of() const { return sizeof(*this); } 495 496 private: 497 const int _dest_bci; 498 const uint _proj_no; 499 const int _switch_val; 500 public: 501 JumpProjNode(Node* jumpnode, uint proj_no, int dest_bci, int switch_val) 502 : JProjNode(jumpnode, proj_no), _dest_bci(dest_bci), _proj_no(proj_no), _switch_val(switch_val) { 503 init_class_id(Class_JumpProj); 504 } 505 506 virtual uint Opcode() const; 507 virtual const Type* bottom_type() const { return Type::CONTROL; } 508 int dest_bci() const { return _dest_bci; } 509 int switch_val() const { return _switch_val; } 510 uint proj_no() const { return _proj_no; } 511 #ifndef PRODUCT 512 virtual void dump_spec(outputStream *st) const; 513 virtual void dump_compact_spec(outputStream *st) const; 514 virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; 515 #endif 516 }; 517 518 //------------------------------CatchNode-------------------------------------- 519 // Helper node to fork exceptions. "Catch" catches any exceptions thrown by 520 // a just-prior call. Looks like a PCTableNode but emits no code - just the 521 // table. The table lookup and branch is implemented by RethrowNode. 522 class CatchNode : public PCTableNode { 523 public: 524 CatchNode( Node *ctrl, Node *idx, uint size ) : PCTableNode(ctrl,idx,size){ 525 init_class_id(Class_Catch); 526 } 527 virtual uint Opcode() const; 528 virtual const Type* Value(PhaseGVN* phase) const; 529 }; 530 531 // CatchProjNode controls which exception handler is targetted after a call. 532 // It is passed in the bci of the target handler, or no_handler_bci in case 533 // the projection doesn't lead to an exception handler. 534 class CatchProjNode : public CProjNode { 535 virtual uint hash() const; 536 virtual uint cmp( const Node &n ) const; 537 virtual uint size_of() const { return sizeof(*this); } 538 539 private: 540 const int _handler_bci; 541 542 public: 543 enum { 544 fall_through_index = 0, // the fall through projection index 545 catch_all_index = 1, // the projection index for catch-alls 546 no_handler_bci = -1 // the bci for fall through or catch-all projs 547 }; 548 549 CatchProjNode(Node* catchnode, uint proj_no, int handler_bci) 550 : CProjNode(catchnode, proj_no), _handler_bci(handler_bci) { 551 init_class_id(Class_CatchProj); 552 assert(proj_no != fall_through_index || handler_bci < 0, "fall through case must have bci < 0"); 553 } 554 555 virtual uint Opcode() const; 556 virtual Node* Identity(PhaseGVN* phase); 557 virtual const Type *bottom_type() const { return Type::CONTROL; } 558 int handler_bci() const { return _handler_bci; } 559 bool is_handler_proj() const { return _handler_bci >= 0; } 560 #ifndef PRODUCT 561 virtual void dump_spec(outputStream *st) const; 562 #endif 563 }; 564 565 566 //---------------------------------CreateExNode-------------------------------- 567 // Helper node to create the exception coming back from a call 568 class CreateExNode : public TypeNode { 569 public: 570 CreateExNode(const Type* t, Node* control, Node* i_o) : TypeNode(t, 2) { 571 init_req(0, control); 572 init_req(1, i_o); 573 } 574 virtual uint Opcode() const; 575 virtual Node* Identity(PhaseGVN* phase); 576 virtual bool pinned() const { return true; } 577 uint match_edge(uint idx) const { return 0; } 578 virtual uint ideal_reg() const { return Op_RegP; } 579 }; 580 581 //------------------------------NeverBranchNode------------------------------- 582 // The never-taken branch. Used to give the appearance of exiting infinite 583 // loops to those algorithms that like all paths to be reachable. Encodes 584 // empty. 585 class NeverBranchNode : public MultiBranchNode { 586 public: 587 NeverBranchNode( Node *ctrl ) : MultiBranchNode(1) { init_req(0,ctrl); } 588 virtual uint Opcode() const; 589 virtual bool pinned() const { return true; }; 590 virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } 591 virtual const Type* Value(PhaseGVN* phase) const; 592 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 593 virtual int required_outcnt() const { return 2; } 594 virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const { } 595 virtual uint size(PhaseRegAlloc *ra_) const { return 0; } 596 #ifndef PRODUCT 597 virtual void format( PhaseRegAlloc *, outputStream *st ) const; 598 #endif 599 }; 600 601 #endif // SHARE_VM_OPTO_CFGNODE_HPP |