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