1 /* 2 * Copyright (c) 1997, 2023, 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_OPTO_SUBNODE_HPP 26 #define SHARE_OPTO_SUBNODE_HPP 27 28 #include "opto/node.hpp" 29 #include "opto/opcodes.hpp" 30 #include "opto/type.hpp" 31 32 // Portions of code courtesy of Clifford Click 33 34 //------------------------------SUBNode---------------------------------------- 35 // Class SUBTRACTION functionality. This covers all the usual 'subtract' 36 // behaviors. Subtract-integer, -float, -double, binary xor, compare-integer, 37 // -float, and -double are all inherited from this class. The compare 38 // functions behave like subtract functions, except that all negative answers 39 // are compressed into -1, and all positive answers compressed to 1. 40 class SubNode : public Node { 41 public: 42 SubNode( Node *in1, Node *in2 ) : Node(0,in1,in2) { 43 init_class_id(Class_Sub); 44 } 45 46 // Handle algebraic identities here. If we have an identity, return the Node 47 // we are equivalent to. We look for "add of zero" as an identity. 48 virtual Node* Identity(PhaseGVN* phase); 49 50 // Compute a new Type for this node. Basically we just do the pre-check, 51 // then call the virtual add() to set the type. 52 virtual const Type* Value(PhaseGVN* phase) const; 53 const Type* Value_common(PhaseValues* phase) const; 54 55 // Supplied function returns the subtractend of the inputs. 56 // This also type-checks the inputs for sanity. Guaranteed never to 57 // be passed a TOP or BOTTOM type, these are filtered out by a pre-check. 58 virtual const Type *sub( const Type *, const Type * ) const = 0; 59 60 // Supplied function to return the additive identity type. 61 // This is returned whenever the subtracts inputs are the same. 62 virtual const Type *add_id() const = 0; 63 64 static SubNode* make(Node* in1, Node* in2, BasicType bt); 65 }; 66 67 68 // NOTE: SubINode should be taken away and replaced by add and negate 69 //------------------------------SubINode--------------------------------------- 70 // Subtract 2 integers 71 class SubINode : public SubNode { 72 public: 73 SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 74 virtual int Opcode() const; 75 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 76 virtual const Type *sub( const Type *, const Type * ) const; 77 const Type *add_id() const { return TypeInt::ZERO; } 78 const Type *bottom_type() const { return TypeInt::INT; } 79 virtual uint ideal_reg() const { return Op_RegI; } 80 }; 81 82 //------------------------------SubLNode--------------------------------------- 83 // Subtract 2 integers 84 class SubLNode : public SubNode { 85 public: 86 SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 87 virtual int Opcode() const; 88 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 89 virtual const Type *sub( const Type *, const Type * ) const; 90 const Type *add_id() const { return TypeLong::ZERO; } 91 const Type *bottom_type() const { return TypeLong::LONG; } 92 virtual uint ideal_reg() const { return Op_RegL; } 93 }; 94 95 // NOTE: SubFPNode should be taken away and replaced by add and negate 96 //------------------------------SubFPNode-------------------------------------- 97 // Subtract 2 floats or doubles 98 class SubFPNode : public SubNode { 99 protected: 100 SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} 101 public: 102 const Type* Value(PhaseGVN* phase) const; 103 }; 104 105 // NOTE: SubFNode should be taken away and replaced by add and negate 106 //------------------------------SubFNode--------------------------------------- 107 // Subtract 2 doubles 108 class SubFNode : public SubFPNode { 109 public: 110 SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} 111 virtual int Opcode() const; 112 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 113 virtual const Type *sub( const Type *, const Type * ) const; 114 const Type *add_id() const { return TypeF::ZERO; } 115 const Type *bottom_type() const { return Type::FLOAT; } 116 virtual uint ideal_reg() const { return Op_RegF; } 117 }; 118 119 // NOTE: SubDNode should be taken away and replaced by add and negate 120 //------------------------------SubDNode--------------------------------------- 121 // Subtract 2 doubles 122 class SubDNode : public SubFPNode { 123 public: 124 SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} 125 virtual int Opcode() const; 126 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 127 virtual const Type *sub( const Type *, const Type * ) const; 128 const Type *add_id() const { return TypeD::ZERO; } 129 const Type *bottom_type() const { return Type::DOUBLE; } 130 virtual uint ideal_reg() const { return Op_RegD; } 131 }; 132 133 //------------------------------CmpNode--------------------------------------- 134 // Compare 2 values, returning condition codes (-1, 0 or 1). 135 class CmpNode : public SubNode { 136 public: 137 CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) { 138 init_class_id(Class_Cmp); 139 } 140 virtual Node* Identity(PhaseGVN* phase); 141 const Type *add_id() const { return TypeInt::ZERO; } 142 const Type *bottom_type() const { return TypeInt::CC; } 143 virtual uint ideal_reg() const { return Op_RegFlags; } 144 145 static CmpNode *make(Node *in1, Node *in2, BasicType bt, bool unsigned_comp = false); 146 }; 147 148 //------------------------------CmpINode--------------------------------------- 149 // Compare 2 signed values, returning condition codes (-1, 0 or 1). 150 class CmpINode : public CmpNode { 151 public: 152 CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 153 virtual int Opcode() const; 154 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 155 virtual const Type *sub( const Type *, const Type * ) const; 156 virtual const Type* Value(PhaseGVN* phase) const; 157 }; 158 159 //------------------------------CmpUNode--------------------------------------- 160 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1). 161 class CmpUNode : public CmpNode { 162 public: 163 CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 164 virtual int Opcode() const; 165 virtual const Type *sub( const Type *, const Type * ) const; 166 const Type* Value(PhaseGVN* phase) const; 167 bool is_index_range_check() const; 168 }; 169 170 //------------------------------CmpU3Node-------------------------------------- 171 // Compare 2 unsigned values, returning integer value (-1, 0 or 1). 172 class CmpU3Node : public CmpUNode { 173 public: 174 CmpU3Node( Node *in1, Node *in2 ) : CmpUNode(in1,in2) { 175 // Since it is not consumed by Bools, it is not really a Cmp. 176 init_class_id(Class_Sub); 177 } 178 virtual int Opcode() const; 179 virtual uint ideal_reg() const { return Op_RegI; } 180 }; 181 182 //------------------------------CmpPNode--------------------------------------- 183 // Compare 2 pointer values, returning condition codes (-1, 0 or 1). 184 class CmpPNode : public CmpNode { 185 public: 186 CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 187 virtual int Opcode() const; 188 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 189 virtual const Type *sub( const Type *, const Type * ) const; 190 }; 191 192 //------------------------------CmpNNode-------------------------------------- 193 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1). 194 class CmpNNode : public CmpNode { 195 public: 196 CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 197 virtual int Opcode() const; 198 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 199 virtual const Type *sub( const Type *, const Type * ) const; 200 }; 201 202 //------------------------------CmpLNode--------------------------------------- 203 // Compare 2 long values, returning condition codes (-1, 0 or 1). 204 class CmpLNode : public CmpNode { 205 public: 206 CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 207 virtual int Opcode() const; 208 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); 209 virtual const Type* Value(PhaseGVN* phase) const; 210 virtual const Type *sub( const Type *, const Type * ) const; 211 bool is_double_null_check(PhaseGVN* phase, Node*& a, Node*& b) const; 212 }; 213 214 //------------------------------CmpULNode--------------------------------------- 215 // Compare 2 unsigned long values, returning condition codes (-1, 0 or 1). 216 class CmpULNode : public CmpNode { 217 public: 218 CmpULNode(Node* in1, Node* in2) : CmpNode(in1, in2) { } 219 virtual int Opcode() const; 220 virtual const Type* sub(const Type*, const Type*) const; 221 }; 222 223 //------------------------------CmpL3Node-------------------------------------- 224 // Compare 2 long values, returning integer value (-1, 0 or 1). 225 class CmpL3Node : public CmpLNode { 226 public: 227 CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) { 228 // Since it is not consumed by Bools, it is not really a Cmp. 229 init_class_id(Class_Sub); 230 } 231 virtual int Opcode() const; 232 virtual uint ideal_reg() const { return Op_RegI; } 233 }; 234 235 //------------------------------CmpUL3Node------------------------------------- 236 // Compare 2 unsigned long values, returning integer value (-1, 0 or 1). 237 class CmpUL3Node : public CmpULNode { 238 public: 239 CmpUL3Node( Node *in1, Node *in2 ) : CmpULNode(in1,in2) { 240 // Since it is not consumed by Bools, it is not really a Cmp. 241 init_class_id(Class_Sub); 242 } 243 virtual int Opcode() const; 244 virtual uint ideal_reg() const { return Op_RegI; } 245 }; 246 247 //------------------------------CmpFNode--------------------------------------- 248 // Compare 2 float values, returning condition codes (-1, 0 or 1). 249 // This implements the Java bytecode fcmpl, so unordered returns -1. 250 // Operands may not commute. 251 class CmpFNode : public CmpNode { 252 public: 253 CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 254 virtual int Opcode() const; 255 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return nullptr; } 256 const Type* Value(PhaseGVN* phase) const; 257 }; 258 259 //------------------------------CmpF3Node-------------------------------------- 260 // Compare 2 float values, returning integer value (-1, 0 or 1). 261 // This implements the Java bytecode fcmpl, so unordered returns -1. 262 // Operands may not commute. 263 class CmpF3Node : public CmpFNode { 264 public: 265 CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) { 266 // Since it is not consumed by Bools, it is not really a Cmp. 267 init_class_id(Class_Sub); 268 } 269 virtual int Opcode() const; 270 // Since it is not consumed by Bools, it is not really a Cmp. 271 virtual uint ideal_reg() const { return Op_RegI; } 272 }; 273 274 275 //------------------------------CmpDNode--------------------------------------- 276 // Compare 2 double values, returning condition codes (-1, 0 or 1). 277 // This implements the Java bytecode dcmpl, so unordered returns -1. 278 // Operands may not commute. 279 class CmpDNode : public CmpNode { 280 public: 281 CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 282 virtual int Opcode() const; 283 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return nullptr; } 284 const Type* Value(PhaseGVN* phase) const; 285 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 286 }; 287 288 //------------------------------CmpD3Node-------------------------------------- 289 // Compare 2 double values, returning integer value (-1, 0 or 1). 290 // This implements the Java bytecode dcmpl, so unordered returns -1. 291 // Operands may not commute. 292 class CmpD3Node : public CmpDNode { 293 public: 294 CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) { 295 // Since it is not consumed by Bools, it is not really a Cmp. 296 init_class_id(Class_Sub); 297 } 298 virtual int Opcode() const; 299 virtual uint ideal_reg() const { return Op_RegI; } 300 }; 301 302 //--------------------------FlatArrayCheckNode--------------------------------- 303 // Returns true if one of the input array objects or array klass ptrs (there 304 // can be multiple) is flat. 305 class FlatArrayCheckNode : public CmpNode { 306 public: 307 enum { 308 Control, 309 Memory, 310 ArrayOrKlass 311 }; 312 FlatArrayCheckNode(Compile* C, Node* mem, Node* array_or_klass) : CmpNode(mem, array_or_klass) { 313 init_class_id(Class_FlatArrayCheck); 314 init_flags(Flag_is_macro); 315 C->add_macro_node(this); 316 } 317 virtual int Opcode() const; 318 virtual const Type* sub(const Type*, const Type*) const { ShouldNotReachHere(); return nullptr; } 319 const Type* Value(PhaseGVN* phase) const; 320 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); 321 }; 322 323 //------------------------------BoolTest--------------------------------------- 324 // Convert condition codes to a boolean test value (0 or -1). 325 // We pick the values as 3 bits; the low order 2 bits we compare against the 326 // condition codes, the high bit flips the sense of the result. 327 // For vector compares, additionally, the 4th bit indicates if the compare is unsigned 328 struct BoolTest { 329 enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, never = 8, illegal = 9, 330 // The following values are used with vector compares 331 // A BoolTest value should not be constructed for such values 332 unsigned_compare = 16, 333 ule = unsigned_compare | le, uge = unsigned_compare | ge, ult = unsigned_compare | lt, ugt = unsigned_compare | gt }; 334 mask _test; 335 BoolTest( mask btm ) : _test(btm) { assert((btm & unsigned_compare) == 0, "unsupported");} 336 const Type *cc2logical( const Type *CC ) const; 337 // Commute the test. I use a small table lookup. The table is created as 338 // a simple char array where each element is the ASCII version of a 'mask' 339 // enum from above. 340 mask commute( ) const { return mask("032147658"[_test]-'0'); } 341 mask negate( ) const { return mask(_test^4); } 342 bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); } 343 bool is_less( ) const { return _test == BoolTest::lt || _test == BoolTest::le; } 344 bool is_greater( ) const { return _test == BoolTest::gt || _test == BoolTest::ge; } 345 void dump_on(outputStream *st) const; 346 mask merge(BoolTest other) const; 347 }; 348 349 //------------------------------BoolNode--------------------------------------- 350 // A Node to convert a Condition Codes to a Logical result. 351 class BoolNode : public Node { 352 virtual uint hash() const; 353 virtual bool cmp( const Node &n ) const; 354 virtual uint size_of() const; 355 356 // Try to optimize signed integer comparison 357 Node* fold_cmpI(PhaseGVN* phase, SubNode* cmp, Node* cmp1, int cmp_op, 358 int cmp1_op, const TypeInt* cmp2_type); 359 public: 360 const BoolTest _test; 361 BoolNode(Node *cc, BoolTest::mask t): Node(nullptr,cc), _test(t) { 362 init_class_id(Class_Bool); 363 } 364 // Convert an arbitrary int value to a Bool or other suitable predicate. 365 static Node* make_predicate(Node* test_value, PhaseGVN* phase); 366 // Convert self back to an integer value. 367 Node* as_int_value(PhaseGVN* phase); 368 // Invert sense of self, returning new Bool. 369 BoolNode* negate(PhaseGVN* phase); 370 virtual int Opcode() const; 371 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 372 virtual const Type* Value(PhaseGVN* phase) const; 373 virtual const Type *bottom_type() const { return TypeInt::BOOL; } 374 uint match_edge(uint idx) const { return 0; } 375 virtual uint ideal_reg() const { return Op_RegI; } 376 377 bool is_counted_loop_exit_test(); 378 #ifndef PRODUCT 379 virtual void dump_spec(outputStream *st) const; 380 #endif 381 }; 382 383 //------------------------------AbsNode---------------------------------------- 384 // Abstract class for absolute value. Mostly used to get a handy wrapper 385 // for finding this pattern in the graph. 386 class AbsNode : public Node { 387 public: 388 AbsNode( Node *value ) : Node(0,value) {} 389 virtual Node* Identity(PhaseGVN* phase); 390 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); 391 virtual const Type* Value(PhaseGVN* phase) const; 392 }; 393 394 //------------------------------AbsINode--------------------------------------- 395 // Absolute value an integer. Since a naive graph involves control flow, we 396 // "match" it in the ideal world (so the control flow can be removed). 397 class AbsINode : public AbsNode { 398 public: 399 AbsINode( Node *in1 ) : AbsNode(in1) {} 400 virtual int Opcode() const; 401 const Type *bottom_type() const { return TypeInt::INT; } 402 virtual uint ideal_reg() const { return Op_RegI; } 403 }; 404 405 //------------------------------AbsLNode--------------------------------------- 406 // Absolute value a long. Since a naive graph involves control flow, we 407 // "match" it in the ideal world (so the control flow can be removed). 408 class AbsLNode : public AbsNode { 409 public: 410 AbsLNode( Node *in1 ) : AbsNode(in1) {} 411 virtual int Opcode() const; 412 const Type *bottom_type() const { return TypeLong::LONG; } 413 virtual uint ideal_reg() const { return Op_RegL; } 414 }; 415 416 //------------------------------AbsFNode--------------------------------------- 417 // Absolute value a float, a common float-point idiom with a cheap hardware 418 // implementation on most chips. Since a naive graph involves control flow, we 419 // "match" it in the ideal world (so the control flow can be removed). 420 class AbsFNode : public AbsNode { 421 public: 422 AbsFNode( Node *in1 ) : AbsNode(in1) {} 423 virtual int Opcode() const; 424 const Type *bottom_type() const { return Type::FLOAT; } 425 virtual uint ideal_reg() const { return Op_RegF; } 426 }; 427 428 //------------------------------AbsDNode--------------------------------------- 429 // Absolute value a double, a common float-point idiom with a cheap hardware 430 // implementation on most chips. Since a naive graph involves control flow, we 431 // "match" it in the ideal world (so the control flow can be removed). 432 class AbsDNode : public AbsNode { 433 public: 434 AbsDNode( Node *in1 ) : AbsNode(in1) {} 435 virtual int Opcode() const; 436 const Type *bottom_type() const { return Type::DOUBLE; } 437 virtual uint ideal_reg() const { return Op_RegD; } 438 }; 439 440 441 //------------------------------CmpLTMaskNode---------------------------------- 442 // If p < q, return -1 else return 0. Nice for flow-free idioms. 443 class CmpLTMaskNode : public Node { 444 public: 445 CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {} 446 virtual int Opcode() const; 447 const Type *bottom_type() const { return TypeInt::INT; } 448 virtual uint ideal_reg() const { return Op_RegI; } 449 }; 450 451 452 //------------------------------NegNode---------------------------------------- 453 class NegNode : public Node { 454 public: 455 NegNode(Node* in1) : Node(0, in1) { 456 init_class_id(Class_Neg); 457 } 458 }; 459 460 //------------------------------NegINode--------------------------------------- 461 // Negate value an int. For int values, negation is the same as subtraction 462 // from zero 463 class NegINode : public NegNode { 464 public: 465 NegINode(Node *in1) : NegNode(in1) {} 466 virtual int Opcode() const; 467 const Type *bottom_type() const { return TypeInt::INT; } 468 virtual uint ideal_reg() const { return Op_RegI; } 469 }; 470 471 //------------------------------NegLNode--------------------------------------- 472 // Negate value an int. For int values, negation is the same as subtraction 473 // from zero 474 class NegLNode : public NegNode { 475 public: 476 NegLNode(Node *in1) : NegNode(in1) {} 477 virtual int Opcode() const; 478 const Type *bottom_type() const { return TypeLong::LONG; } 479 virtual uint ideal_reg() const { return Op_RegL; } 480 }; 481 482 //------------------------------NegFNode--------------------------------------- 483 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from 484 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction 485 // cannot be used to replace negation we have to implement negation as ideal 486 // node; note that negation and addition can replace subtraction. 487 class NegFNode : public NegNode { 488 public: 489 NegFNode( Node *in1 ) : NegNode(in1) {} 490 virtual int Opcode() const; 491 const Type *bottom_type() const { return Type::FLOAT; } 492 virtual uint ideal_reg() const { return Op_RegF; } 493 }; 494 495 //------------------------------NegDNode--------------------------------------- 496 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from 497 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction 498 // cannot be used to replace negation we have to implement negation as ideal 499 // node; note that negation and addition can replace subtraction. 500 class NegDNode : public NegNode { 501 public: 502 NegDNode( Node *in1 ) : NegNode(in1) {} 503 virtual int Opcode() const; 504 const Type *bottom_type() const { return Type::DOUBLE; } 505 virtual uint ideal_reg() const { return Op_RegD; } 506 }; 507 508 //------------------------------AtanDNode-------------------------------------- 509 // arcus tangens of a double 510 class AtanDNode : public Node { 511 public: 512 AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} 513 virtual int Opcode() const; 514 const Type *bottom_type() const { return Type::DOUBLE; } 515 virtual uint ideal_reg() const { return Op_RegD; } 516 }; 517 518 519 //------------------------------SqrtDNode-------------------------------------- 520 // square root a double 521 class SqrtDNode : public Node { 522 public: 523 SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 524 init_flags(Flag_is_expensive); 525 C->add_expensive_node(this); 526 } 527 virtual int Opcode() const; 528 const Type *bottom_type() const { return Type::DOUBLE; } 529 virtual uint ideal_reg() const { return Op_RegD; } 530 virtual const Type* Value(PhaseGVN* phase) const; 531 }; 532 533 //------------------------------SqrtFNode-------------------------------------- 534 // square root a float 535 class SqrtFNode : public Node { 536 public: 537 SqrtFNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 538 init_flags(Flag_is_expensive); 539 if (c != nullptr) { 540 // Treat node only as expensive if a control input is set because it might 541 // be created from a SqrtDNode in ConvD2FNode::Ideal() that was found to 542 // be unique and therefore has no control input. 543 C->add_expensive_node(this); 544 } 545 } 546 virtual int Opcode() const; 547 const Type *bottom_type() const { return Type::FLOAT; } 548 virtual uint ideal_reg() const { return Op_RegF; } 549 virtual const Type* Value(PhaseGVN* phase) const; 550 }; 551 552 //-------------------------------ReverseBytesINode-------------------------------- 553 // reverse bytes of an integer 554 class ReverseBytesINode : public Node { 555 public: 556 ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} 557 virtual int Opcode() const; 558 const Type *bottom_type() const { return TypeInt::INT; } 559 virtual uint ideal_reg() const { return Op_RegI; } 560 }; 561 562 //-------------------------------ReverseBytesLNode-------------------------------- 563 // reverse bytes of a long 564 class ReverseBytesLNode : public Node { 565 public: 566 ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} 567 virtual int Opcode() const; 568 const Type *bottom_type() const { return TypeLong::LONG; } 569 virtual uint ideal_reg() const { return Op_RegL; } 570 }; 571 572 //-------------------------------ReverseBytesUSNode-------------------------------- 573 // reverse bytes of an unsigned short / char 574 class ReverseBytesUSNode : public Node { 575 public: 576 ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} 577 virtual int Opcode() const; 578 const Type *bottom_type() const { return TypeInt::CHAR; } 579 virtual uint ideal_reg() const { return Op_RegI; } 580 }; 581 582 //-------------------------------ReverseBytesSNode-------------------------------- 583 // reverse bytes of a short 584 class ReverseBytesSNode : public Node { 585 public: 586 ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} 587 virtual int Opcode() const; 588 const Type *bottom_type() const { return TypeInt::SHORT; } 589 virtual uint ideal_reg() const { return Op_RegI; } 590 }; 591 592 //-------------------------------ReverseINode-------------------------------- 593 // reverse bits of an int 594 class ReverseINode : public Node { 595 public: 596 ReverseINode(Node *c, Node *in1) : Node(c, in1) {} 597 virtual int Opcode() const; 598 const Type *bottom_type() const { return TypeInt::INT; } 599 virtual uint ideal_reg() const { return Op_RegI; } 600 virtual Node* Identity(PhaseGVN* phase); 601 virtual const Type* Value(PhaseGVN* phase) const; 602 }; 603 604 //-------------------------------ReverseLNode-------------------------------- 605 // reverse bits of a long 606 class ReverseLNode : public Node { 607 public: 608 ReverseLNode(Node *c, Node *in1) : Node(c, in1) {} 609 virtual int Opcode() const; 610 const Type *bottom_type() const { return TypeLong::LONG; } 611 virtual uint ideal_reg() const { return Op_RegL; } 612 virtual Node* Identity(PhaseGVN* phase); 613 virtual const Type* Value(PhaseGVN* phase) const; 614 }; 615 616 #endif // SHARE_OPTO_SUBNODE_HPP