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 }; 457 458 //------------------------------NegINode--------------------------------------- 459 // Negate value an int. For int values, negation is the same as subtraction 460 // from zero 461 class NegINode : public NegNode { 462 public: 463 NegINode(Node *in1) : NegNode(in1) {} 464 virtual int Opcode() const; 465 const Type *bottom_type() const { return TypeInt::INT; } 466 virtual uint ideal_reg() const { return Op_RegI; } 467 }; 468 469 //------------------------------NegLNode--------------------------------------- 470 // Negate value an int. For int values, negation is the same as subtraction 471 // from zero 472 class NegLNode : public NegNode { 473 public: 474 NegLNode(Node *in1) : NegNode(in1) {} 475 virtual int Opcode() const; 476 const Type *bottom_type() const { return TypeLong::LONG; } 477 virtual uint ideal_reg() const { return Op_RegL; } 478 }; 479 480 //------------------------------NegFNode--------------------------------------- 481 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from 482 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction 483 // cannot be used to replace negation we have to implement negation as ideal 484 // node; note that negation and addition can replace subtraction. 485 class NegFNode : public NegNode { 486 public: 487 NegFNode( Node *in1 ) : NegNode(in1) {} 488 virtual int Opcode() const; 489 const Type *bottom_type() const { return Type::FLOAT; } 490 virtual uint ideal_reg() const { return Op_RegF; } 491 }; 492 493 //------------------------------NegDNode--------------------------------------- 494 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from 495 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction 496 // cannot be used to replace negation we have to implement negation as ideal 497 // node; note that negation and addition can replace subtraction. 498 class NegDNode : public NegNode { 499 public: 500 NegDNode( Node *in1 ) : NegNode(in1) {} 501 virtual int Opcode() const; 502 const Type *bottom_type() const { return Type::DOUBLE; } 503 virtual uint ideal_reg() const { return Op_RegD; } 504 }; 505 506 //------------------------------AtanDNode-------------------------------------- 507 // arcus tangens of a double 508 class AtanDNode : public Node { 509 public: 510 AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} 511 virtual int Opcode() const; 512 const Type *bottom_type() const { return Type::DOUBLE; } 513 virtual uint ideal_reg() const { return Op_RegD; } 514 }; 515 516 517 //------------------------------SqrtDNode-------------------------------------- 518 // square root a double 519 class SqrtDNode : public Node { 520 public: 521 SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 522 init_flags(Flag_is_expensive); 523 C->add_expensive_node(this); 524 } 525 virtual int Opcode() const; 526 const Type *bottom_type() const { return Type::DOUBLE; } 527 virtual uint ideal_reg() const { return Op_RegD; } 528 virtual const Type* Value(PhaseGVN* phase) const; 529 }; 530 531 //------------------------------SqrtFNode-------------------------------------- 532 // square root a float 533 class SqrtFNode : public Node { 534 public: 535 SqrtFNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 536 init_flags(Flag_is_expensive); 537 if (c != nullptr) { 538 // Treat node only as expensive if a control input is set because it might 539 // be created from a SqrtDNode in ConvD2FNode::Ideal() that was found to 540 // be unique and therefore has no control input. 541 C->add_expensive_node(this); 542 } 543 } 544 virtual int Opcode() const; 545 const Type *bottom_type() const { return Type::FLOAT; } 546 virtual uint ideal_reg() const { return Op_RegF; } 547 virtual const Type* Value(PhaseGVN* phase) const; 548 }; 549 550 //-------------------------------ReverseBytesINode-------------------------------- 551 // reverse bytes of an integer 552 class ReverseBytesINode : public Node { 553 public: 554 ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} 555 virtual int Opcode() const; 556 const Type *bottom_type() const { return TypeInt::INT; } 557 virtual uint ideal_reg() const { return Op_RegI; } 558 }; 559 560 //-------------------------------ReverseBytesLNode-------------------------------- 561 // reverse bytes of a long 562 class ReverseBytesLNode : public Node { 563 public: 564 ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} 565 virtual int Opcode() const; 566 const Type *bottom_type() const { return TypeLong::LONG; } 567 virtual uint ideal_reg() const { return Op_RegL; } 568 }; 569 570 //-------------------------------ReverseBytesUSNode-------------------------------- 571 // reverse bytes of an unsigned short / char 572 class ReverseBytesUSNode : public Node { 573 public: 574 ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} 575 virtual int Opcode() const; 576 const Type *bottom_type() const { return TypeInt::CHAR; } 577 virtual uint ideal_reg() const { return Op_RegI; } 578 }; 579 580 //-------------------------------ReverseBytesSNode-------------------------------- 581 // reverse bytes of a short 582 class ReverseBytesSNode : public Node { 583 public: 584 ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} 585 virtual int Opcode() const; 586 const Type *bottom_type() const { return TypeInt::SHORT; } 587 virtual uint ideal_reg() const { return Op_RegI; } 588 }; 589 590 //-------------------------------ReverseINode-------------------------------- 591 // reverse bits of an int 592 class ReverseINode : public Node { 593 public: 594 ReverseINode(Node *c, Node *in1) : Node(c, in1) {} 595 virtual int Opcode() const; 596 const Type *bottom_type() const { return TypeInt::INT; } 597 virtual uint ideal_reg() const { return Op_RegI; } 598 virtual Node* Identity(PhaseGVN* phase); 599 virtual const Type* Value(PhaseGVN* phase) const; 600 }; 601 602 //-------------------------------ReverseLNode-------------------------------- 603 // reverse bits of a long 604 class ReverseLNode : public Node { 605 public: 606 ReverseLNode(Node *c, Node *in1) : Node(c, in1) {} 607 virtual int Opcode() const; 608 const Type *bottom_type() const { return TypeLong::LONG; } 609 virtual uint ideal_reg() const { return Op_RegL; } 610 virtual Node* Identity(PhaseGVN* phase); 611 virtual const Type* Value(PhaseGVN* phase) const; 612 }; 613 614 #endif // SHARE_OPTO_SUBNODE_HPP