connode.hpp revision 3724:8e47bac5643a
1/* 2 * Copyright (c) 1997, 2010, 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 32class PhaseTransform; 33class MachNode; 34 35//------------------------------ConNode---------------------------------------- 36// Simple constants 37class ConNode : public TypeNode { 38public: 39 ConNode( const Type *t ) : TypeNode(t,1) { 40 init_req(0, (Node*)Compile::current()->root()); 41 init_flags(Flag_is_Con); 42 } 43 virtual int Opcode() const; 44 virtual uint hash() const; 45 virtual const RegMask &out_RegMask() const { return RegMask::Empty; } 46 virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; } 47 48 // Polymorphic factory method: 49 static ConNode* make( Compile* C, const Type *t ); 50}; 51 52//------------------------------ConINode--------------------------------------- 53// Simple integer constants 54class ConINode : public ConNode { 55public: 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 68class ConPNode : public ConNode { 69public: 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 85class ConNNode : public ConNode { 86public: 87 ConNNode( const TypeNarrowOop *t ) : ConNode(t) {} 88 virtual int Opcode() const; 89}; 90 91//------------------------------ConNKlassNode--------------------------------- 92// Simple narrow klass constants 93class ConNKlassNode : public ConNode { 94public: 95 ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {} 96 virtual int Opcode() const; 97}; 98 99 100//------------------------------ConLNode--------------------------------------- 101// Simple long constants 102class ConLNode : public ConNode { 103public: 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 116class ConFNode : public ConNode { 117public: 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 130class ConDNode : public ConNode { 131public: 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)) 148class BinaryNode : public Node { 149public: 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 157class CMoveNode : public TypeNode { 158public: 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------------------------------------- 181class CMoveDNode : public CMoveNode { 182public: 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------------------------------------- 189class CMoveFNode : public CMoveNode { 190public: 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------------------------------------- 197class CMoveINode : public CMoveNode { 198public: 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------------------------------------- 205class CMoveLNode : public CMoveNode { 206public: 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------------------------------------- 212class CMovePNode : public CMoveNode { 213public: 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------------------------------------- 219class CMoveNNode : public CMoveNode { 220public: 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 227class ConstraintCastNode: public TypeNode { 228public: 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) 243class CastIINode: public ConstraintCastNode { 244public: 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) 252class CastPPNode: public ConstraintCastNode { 253public: 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, 262class CheckCastPPNode: public TypeNode { 263public: 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-------------------------------- 282class 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. 299class 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. 314class 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-------------------------------- 326class 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. 342class 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. 357class 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. 370class Conv2BNode : public Node { 371public: 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 383class ConvD2FNode : public Node { 384public: 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 395class ConvD2INode : public Node { 396public: 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 408class ConvD2LNode : public Node { 409public: 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. 421class ConvF2DNode : public Node { 422public: 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 432class ConvF2INode : public Node { 433public: 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 445class ConvF2LNode : public Node { 446public: 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 458class ConvI2DNode : public Node { 459public: 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 469class ConvI2FNode : public Node { 470public: 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 481class ConvI2LNode : public TypeNode { 482public: 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 494class ConvL2DNode : public Node { 495public: 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 505class ConvL2FNode : public Node { 506public: 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 516class ConvL2INode : public Node { 517public: 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 529class CastX2PNode : public Node { 530public: 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. 543class CastP2XNode : public Node { 544public: 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. 558class ThreadLocalNode : public Node { 559public: 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------------------------------- 567class LoadReturnPCNode: public Node { 568public: 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---------------------------------- 576class RoundFloatNode: public Node { 577public: 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--------------------------------- 588class RoundDoubleNode: public Node { 589public: 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. 601class Opaque1Node : public Node { 602 virtual uint hash() const ; // { return NO_HASH; } 603 virtual uint cmp( const Node &n ) const; 604public: 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. 632class Opaque2Node : public Node { 633 virtual uint hash() const ; // { return NO_HASH; } 634 virtual uint cmp( const Node &n ) const; 635public: 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. 650class PartialSubtypeCheckNode : public Node { 651public: 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// 659class 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 668class 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 677class 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 686class 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 ----------------------------------------------------- 696class CountBitsNode : public Node { 697public: 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. 705class CountLeadingZerosINode : public CountBitsNode { 706public: 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. 714class CountLeadingZerosLNode : public CountBitsNode { 715public: 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. 723class CountTrailingZerosINode : public CountBitsNode { 724public: 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. 732class CountTrailingZerosLNode : public CountBitsNode { 733public: 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. 741class PopCountINode : public CountBitsNode { 742public: 743 PopCountINode(Node* in1) : CountBitsNode(in1) {} 744 virtual int Opcode() const; 745}; 746 747//---------- PopCountLNode ----------------------------------------------------- 748// Population count (bit count) of a long. 749class PopCountLNode : public CountBitsNode { 750public: 751 PopCountLNode(Node* in1) : CountBitsNode(in1) {} 752 virtual int Opcode() const; 753}; 754 755#endif // SHARE_VM_OPTO_CONNODE_HPP 756