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 *sub( const Type *, const Type * ) const; 210 }; 211 212 //------------------------------CmpULNode--------------------------------------- 213 // Compare 2 unsigned long values, returning condition codes (-1, 0 or 1). 214 class CmpULNode : public CmpNode { 215 public: 216 CmpULNode(Node* in1, Node* in2) : CmpNode(in1, in2) { } 217 virtual int Opcode() const; 218 virtual const Type* sub(const Type*, const Type*) const; 219 }; 220 221 //------------------------------CmpL3Node-------------------------------------- 222 // Compare 2 long values, returning integer value (-1, 0 or 1). 223 class CmpL3Node : public CmpLNode { 224 public: 225 CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) { 226 // Since it is not consumed by Bools, it is not really a Cmp. 227 init_class_id(Class_Sub); 228 } 229 virtual int Opcode() const; 230 virtual uint ideal_reg() const { return Op_RegI; } 231 }; 232 233 //------------------------------CmpUL3Node------------------------------------- 234 // Compare 2 unsigned long values, returning integer value (-1, 0 or 1). 235 class CmpUL3Node : public CmpULNode { 236 public: 237 CmpUL3Node( Node *in1, Node *in2 ) : CmpULNode(in1,in2) { 238 // Since it is not consumed by Bools, it is not really a Cmp. 239 init_class_id(Class_Sub); 240 } 241 virtual int Opcode() const; 242 virtual uint ideal_reg() const { return Op_RegI; } 243 }; 244 245 //------------------------------CmpFNode--------------------------------------- 246 // Compare 2 float values, returning condition codes (-1, 0 or 1). 247 // This implements the Java bytecode fcmpl, so unordered returns -1. 248 // Operands may not commute. 249 class CmpFNode : public CmpNode { 250 public: 251 CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 252 virtual int Opcode() const; 253 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return nullptr; } 254 const Type* Value(PhaseGVN* phase) const; 255 }; 256 257 //------------------------------CmpF3Node-------------------------------------- 258 // Compare 2 float values, returning integer value (-1, 0 or 1). 259 // This implements the Java bytecode fcmpl, so unordered returns -1. 260 // Operands may not commute. 261 class CmpF3Node : public CmpFNode { 262 public: 263 CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) { 264 // Since it is not consumed by Bools, it is not really a Cmp. 265 init_class_id(Class_Sub); 266 } 267 virtual int Opcode() const; 268 // Since it is not consumed by Bools, it is not really a Cmp. 269 virtual uint ideal_reg() const { return Op_RegI; } 270 }; 271 272 273 //------------------------------CmpDNode--------------------------------------- 274 // Compare 2 double values, returning condition codes (-1, 0 or 1). 275 // This implements the Java bytecode dcmpl, so unordered returns -1. 276 // Operands may not commute. 277 class CmpDNode : public CmpNode { 278 public: 279 CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} 280 virtual int Opcode() const; 281 virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return nullptr; } 282 const Type* Value(PhaseGVN* phase) const; 283 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 284 }; 285 286 //------------------------------CmpD3Node-------------------------------------- 287 // Compare 2 double values, returning integer value (-1, 0 or 1). 288 // This implements the Java bytecode dcmpl, so unordered returns -1. 289 // Operands may not commute. 290 class CmpD3Node : public CmpDNode { 291 public: 292 CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) { 293 // Since it is not consumed by Bools, it is not really a Cmp. 294 init_class_id(Class_Sub); 295 } 296 virtual int Opcode() const; 297 virtual uint ideal_reg() const { return Op_RegI; } 298 }; 299 300 301 //------------------------------BoolTest--------------------------------------- 302 // Convert condition codes to a boolean test value (0 or -1). 303 // We pick the values as 3 bits; the low order 2 bits we compare against the 304 // condition codes, the high bit flips the sense of the result. 305 // For vector compares, additionally, the 4th bit indicates if the compare is unsigned 306 struct BoolTest { 307 enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, never = 8, illegal = 9, 308 // The following values are used with vector compares 309 // A BoolTest value should not be constructed for such values 310 unsigned_compare = 16, 311 ule = unsigned_compare | le, uge = unsigned_compare | ge, ult = unsigned_compare | lt, ugt = unsigned_compare | gt }; 312 mask _test; 313 BoolTest( mask btm ) : _test(btm) { assert((btm & unsigned_compare) == 0, "unsupported");} 314 const Type *cc2logical( const Type *CC ) const; 315 // Commute the test. I use a small table lookup. The table is created as 316 // a simple char array where each element is the ASCII version of a 'mask' 317 // enum from above. 318 mask commute( ) const { return mask("032147658"[_test]-'0'); } 319 mask negate( ) const { return mask(_test^4); } 320 bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); } 321 bool is_less( ) const { return _test == BoolTest::lt || _test == BoolTest::le; } 322 bool is_greater( ) const { return _test == BoolTest::gt || _test == BoolTest::ge; } 323 void dump_on(outputStream *st) const; 324 mask merge(BoolTest other) const; 325 }; 326 327 //------------------------------BoolNode--------------------------------------- 328 // A Node to convert a Condition Codes to a Logical result. 329 class BoolNode : public Node { 330 virtual uint hash() const; 331 virtual bool cmp( const Node &n ) const; 332 virtual uint size_of() const; 333 334 // Try to optimize signed integer comparison 335 Node* fold_cmpI(PhaseGVN* phase, SubNode* cmp, Node* cmp1, int cmp_op, 336 int cmp1_op, const TypeInt* cmp2_type); 337 public: 338 const BoolTest _test; 339 BoolNode(Node *cc, BoolTest::mask t): Node(nullptr,cc), _test(t) { 340 init_class_id(Class_Bool); 341 } 342 // Convert an arbitrary int value to a Bool or other suitable predicate. 343 static Node* make_predicate(Node* test_value, PhaseGVN* phase); 344 // Convert self back to an integer value. 345 Node* as_int_value(PhaseGVN* phase); 346 // Invert sense of self, returning new Bool. 347 BoolNode* negate(PhaseGVN* phase); 348 virtual int Opcode() const; 349 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); 350 virtual const Type* Value(PhaseGVN* phase) const; 351 virtual const Type *bottom_type() const { return TypeInt::BOOL; } 352 uint match_edge(uint idx) const { return 0; } 353 virtual uint ideal_reg() const { return Op_RegI; } 354 355 bool is_counted_loop_exit_test(); 356 #ifndef PRODUCT 357 virtual void dump_spec(outputStream *st) const; 358 #endif 359 }; 360 361 //------------------------------AbsNode---------------------------------------- 362 // Abstract class for absolute value. Mostly used to get a handy wrapper 363 // for finding this pattern in the graph. 364 class AbsNode : public Node { 365 public: 366 AbsNode( Node *value ) : Node(0,value) {} 367 virtual Node* Identity(PhaseGVN* phase); 368 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); 369 virtual const Type* Value(PhaseGVN* phase) const; 370 }; 371 372 //------------------------------AbsINode--------------------------------------- 373 // Absolute value an integer. Since a naive graph involves control flow, we 374 // "match" it in the ideal world (so the control flow can be removed). 375 class AbsINode : public AbsNode { 376 public: 377 AbsINode( Node *in1 ) : AbsNode(in1) {} 378 virtual int Opcode() const; 379 const Type *bottom_type() const { return TypeInt::INT; } 380 virtual uint ideal_reg() const { return Op_RegI; } 381 }; 382 383 //------------------------------AbsLNode--------------------------------------- 384 // Absolute value a long. Since a naive graph involves control flow, we 385 // "match" it in the ideal world (so the control flow can be removed). 386 class AbsLNode : public AbsNode { 387 public: 388 AbsLNode( Node *in1 ) : AbsNode(in1) {} 389 virtual int Opcode() const; 390 const Type *bottom_type() const { return TypeLong::LONG; } 391 virtual uint ideal_reg() const { return Op_RegL; } 392 }; 393 394 //------------------------------AbsFNode--------------------------------------- 395 // Absolute value a float, a common float-point idiom with a cheap hardware 396 // implementation on most chips. Since a naive graph involves control flow, we 397 // "match" it in the ideal world (so the control flow can be removed). 398 class AbsFNode : public AbsNode { 399 public: 400 AbsFNode( Node *in1 ) : AbsNode(in1) {} 401 virtual int Opcode() const; 402 const Type *bottom_type() const { return Type::FLOAT; } 403 virtual uint ideal_reg() const { return Op_RegF; } 404 }; 405 406 //------------------------------AbsDNode--------------------------------------- 407 // Absolute value a double, a common float-point idiom with a cheap hardware 408 // implementation on most chips. Since a naive graph involves control flow, we 409 // "match" it in the ideal world (so the control flow can be removed). 410 class AbsDNode : public AbsNode { 411 public: 412 AbsDNode( Node *in1 ) : AbsNode(in1) {} 413 virtual int Opcode() const; 414 const Type *bottom_type() const { return Type::DOUBLE; } 415 virtual uint ideal_reg() const { return Op_RegD; } 416 }; 417 418 419 //------------------------------CmpLTMaskNode---------------------------------- 420 // If p < q, return -1 else return 0. Nice for flow-free idioms. 421 class CmpLTMaskNode : public Node { 422 public: 423 CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {} 424 virtual int Opcode() const; 425 const Type *bottom_type() const { return TypeInt::INT; } 426 virtual uint ideal_reg() const { return Op_RegI; } 427 }; 428 429 430 //------------------------------NegNode---------------------------------------- 431 class NegNode : public Node { 432 public: 433 NegNode(Node* in1) : Node(0, in1) { 434 init_class_id(Class_Neg); 435 } 436 }; 437 438 //------------------------------NegINode--------------------------------------- 439 // Negate value an int. For int values, negation is the same as subtraction 440 // from zero 441 class NegINode : public NegNode { 442 public: 443 NegINode(Node *in1) : NegNode(in1) {} 444 virtual int Opcode() const; 445 const Type *bottom_type() const { return TypeInt::INT; } 446 virtual uint ideal_reg() const { return Op_RegI; } 447 }; 448 449 //------------------------------NegLNode--------------------------------------- 450 // Negate value an int. For int values, negation is the same as subtraction 451 // from zero 452 class NegLNode : public NegNode { 453 public: 454 NegLNode(Node *in1) : NegNode(in1) {} 455 virtual int Opcode() const; 456 const Type *bottom_type() const { return TypeLong::LONG; } 457 virtual uint ideal_reg() const { return Op_RegL; } 458 }; 459 460 //------------------------------NegFNode--------------------------------------- 461 // Negate value a float. Negating 0.0 returns -0.0, but subtracting from 462 // zero returns +0.0 (per JVM spec on 'fneg' bytecode). As subtraction 463 // cannot be used to replace negation we have to implement negation as ideal 464 // node; note that negation and addition can replace subtraction. 465 class NegFNode : public NegNode { 466 public: 467 NegFNode( Node *in1 ) : NegNode(in1) {} 468 virtual int Opcode() const; 469 const Type *bottom_type() const { return Type::FLOAT; } 470 virtual uint ideal_reg() const { return Op_RegF; } 471 }; 472 473 //------------------------------NegDNode--------------------------------------- 474 // Negate value a double. Negating 0.0 returns -0.0, but subtracting from 475 // zero returns +0.0 (per JVM spec on 'dneg' bytecode). As subtraction 476 // cannot be used to replace negation we have to implement negation as ideal 477 // node; note that negation and addition can replace subtraction. 478 class NegDNode : public NegNode { 479 public: 480 NegDNode( Node *in1 ) : NegNode(in1) {} 481 virtual int Opcode() const; 482 const Type *bottom_type() const { return Type::DOUBLE; } 483 virtual uint ideal_reg() const { return Op_RegD; } 484 }; 485 486 //------------------------------AtanDNode-------------------------------------- 487 // arcus tangens of a double 488 class AtanDNode : public Node { 489 public: 490 AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} 491 virtual int Opcode() const; 492 const Type *bottom_type() const { return Type::DOUBLE; } 493 virtual uint ideal_reg() const { return Op_RegD; } 494 }; 495 496 497 //------------------------------SqrtDNode-------------------------------------- 498 // square root a double 499 class SqrtDNode : public Node { 500 public: 501 SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 502 init_flags(Flag_is_expensive); 503 C->add_expensive_node(this); 504 } 505 virtual int Opcode() const; 506 const Type *bottom_type() const { return Type::DOUBLE; } 507 virtual uint ideal_reg() const { return Op_RegD; } 508 virtual const Type* Value(PhaseGVN* phase) const; 509 }; 510 511 //------------------------------SqrtFNode-------------------------------------- 512 // square root a float 513 class SqrtFNode : public Node { 514 public: 515 SqrtFNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { 516 init_flags(Flag_is_expensive); 517 if (c != nullptr) { 518 // Treat node only as expensive if a control input is set because it might 519 // be created from a SqrtDNode in ConvD2FNode::Ideal() that was found to 520 // be unique and therefore has no control input. 521 C->add_expensive_node(this); 522 } 523 } 524 virtual int Opcode() const; 525 const Type *bottom_type() const { return Type::FLOAT; } 526 virtual uint ideal_reg() const { return Op_RegF; } 527 virtual const Type* Value(PhaseGVN* phase) const; 528 }; 529 530 //-------------------------------ReverseBytesINode-------------------------------- 531 // reverse bytes of an integer 532 class ReverseBytesINode : public Node { 533 public: 534 ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} 535 virtual int Opcode() const; 536 const Type *bottom_type() const { return TypeInt::INT; } 537 virtual uint ideal_reg() const { return Op_RegI; } 538 }; 539 540 //-------------------------------ReverseBytesLNode-------------------------------- 541 // reverse bytes of a long 542 class ReverseBytesLNode : public Node { 543 public: 544 ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} 545 virtual int Opcode() const; 546 const Type *bottom_type() const { return TypeLong::LONG; } 547 virtual uint ideal_reg() const { return Op_RegL; } 548 }; 549 550 //-------------------------------ReverseBytesUSNode-------------------------------- 551 // reverse bytes of an unsigned short / char 552 class ReverseBytesUSNode : public Node { 553 public: 554 ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} 555 virtual int Opcode() const; 556 const Type *bottom_type() const { return TypeInt::CHAR; } 557 virtual uint ideal_reg() const { return Op_RegI; } 558 }; 559 560 //-------------------------------ReverseBytesSNode-------------------------------- 561 // reverse bytes of a short 562 class ReverseBytesSNode : public Node { 563 public: 564 ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} 565 virtual int Opcode() const; 566 const Type *bottom_type() const { return TypeInt::SHORT; } 567 virtual uint ideal_reg() const { return Op_RegI; } 568 }; 569 570 //-------------------------------ReverseINode-------------------------------- 571 // reverse bits of an int 572 class ReverseINode : public Node { 573 public: 574 ReverseINode(Node *c, Node *in1) : Node(c, in1) {} 575 virtual int Opcode() const; 576 const Type *bottom_type() const { return TypeInt::INT; } 577 virtual uint ideal_reg() const { return Op_RegI; } 578 virtual Node* Identity(PhaseGVN* phase); 579 virtual const Type* Value(PhaseGVN* phase) const; 580 }; 581 582 //-------------------------------ReverseLNode-------------------------------- 583 // reverse bits of a long 584 class ReverseLNode : public Node { 585 public: 586 ReverseLNode(Node *c, Node *in1) : Node(c, in1) {} 587 virtual int Opcode() const; 588 const Type *bottom_type() const { return TypeLong::LONG; } 589 virtual uint ideal_reg() const { return Op_RegL; } 590 virtual Node* Identity(PhaseGVN* phase); 591 virtual const Type* Value(PhaseGVN* phase) const; 592 }; 593 594 #endif // SHARE_OPTO_SUBNODE_HPP