1 /*
   2  * Copyright (c) 1997, 2013, 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_SUBNODE_HPP
  26 #define SHARE_VM_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( PhaseTransform *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( PhaseTransform *phase ) const;
  53   const Type* Value_common( PhaseTransform *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 };
  65 
  66 
  67 // NOTE: SubINode should be taken away and replaced by add and negate
  68 //------------------------------SubINode---------------------------------------
  69 // Subtract 2 integers
  70 class SubINode : public SubNode {
  71 public:
  72   SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
  73   virtual int Opcode() const;
  74   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
  75   virtual const Type *sub( const Type *, const Type * ) const;
  76   const Type *add_id() const { return TypeInt::ZERO; }
  77   const Type *bottom_type() const { return TypeInt::INT; }
  78   virtual uint ideal_reg() const { return Op_RegI; }
  79 };
  80 
  81 //------------------------------SubLNode---------------------------------------
  82 // Subtract 2 integers
  83 class SubLNode : public SubNode {
  84 public:
  85   SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
  86   virtual int Opcode() const;
  87   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
  88   virtual const Type *sub( const Type *, const Type * ) const;
  89   const Type *add_id() const { return TypeLong::ZERO; }
  90   const Type *bottom_type() const { return TypeLong::LONG; }
  91   virtual uint ideal_reg() const { return Op_RegL; }
  92 };
  93 
  94 // NOTE: SubFPNode should be taken away and replaced by add and negate
  95 //------------------------------SubFPNode--------------------------------------
  96 // Subtract 2 floats or doubles
  97 class SubFPNode : public SubNode {
  98 protected:
  99   SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
 100 public:
 101   const Type *Value( PhaseTransform *phase ) const;
 102 };
 103 
 104 // NOTE: SubFNode should be taken away and replaced by add and negate
 105 //------------------------------SubFNode---------------------------------------
 106 // Subtract 2 doubles
 107 class SubFNode : public SubFPNode {
 108 public:
 109   SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}
 110   virtual int Opcode() const;
 111   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 112   virtual const Type *sub( const Type *, const Type * ) const;
 113   const Type   *add_id() const { return TypeF::ZERO; }
 114   const Type   *bottom_type() const { return Type::FLOAT; }
 115   virtual uint  ideal_reg() const { return Op_RegF; }
 116 };
 117 
 118 // NOTE: SubDNode should be taken away and replaced by add and negate
 119 //------------------------------SubDNode---------------------------------------
 120 // Subtract 2 doubles
 121 class SubDNode : public SubFPNode {
 122 public:
 123   SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}
 124   virtual int Opcode() const;
 125   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 126   virtual const Type *sub( const Type *, const Type * ) const;
 127   const Type   *add_id() const { return TypeD::ZERO; }
 128   const Type   *bottom_type() const { return Type::DOUBLE; }
 129   virtual uint  ideal_reg() const { return Op_RegD; }
 130 };
 131 
 132 //------------------------------CmpNode---------------------------------------
 133 // Compare 2 values, returning condition codes (-1, 0 or 1).
 134 class CmpNode : public SubNode {
 135 public:
 136   CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {
 137     init_class_id(Class_Cmp);
 138   }
 139   virtual Node *Identity( PhaseTransform *phase );
 140   const Type *add_id() const { return TypeInt::ZERO; }
 141   const Type *bottom_type() const { return TypeInt::CC; }
 142   virtual uint ideal_reg() const { return Op_RegFlags; }
 143 };
 144 
 145 //------------------------------CmpINode---------------------------------------
 146 // Compare 2 signed values, returning condition codes (-1, 0 or 1).
 147 class CmpINode : public CmpNode {
 148 public:
 149   CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 150   virtual int Opcode() const;
 151   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 152   virtual const Type *sub( const Type *, const Type * ) const;
 153 };
 154 
 155 //------------------------------CmpUNode---------------------------------------
 156 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1).
 157 class CmpUNode : public CmpNode {
 158 public:
 159   CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 160   virtual int Opcode() const;
 161   virtual const Type *sub( const Type *, const Type * ) const;
 162   const Type *Value( PhaseTransform *phase ) const;
 163   bool is_index_range_check() const;
 164 };
 165 
 166 //------------------------------CmpPNode---------------------------------------
 167 // Compare 2 pointer values, returning condition codes (-1, 0 or 1).
 168 class CmpPNode : public CmpNode {
 169 public:
 170   CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 171   virtual int Opcode() const;
 172   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 173   virtual const Type *sub( const Type *, const Type * ) const;
 174 };
 175 
 176 //------------------------------CmpNNode--------------------------------------
 177 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1).
 178 class CmpNNode : public CmpNode {
 179 public:
 180   CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 181   virtual int Opcode() const;
 182   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 183   virtual const Type *sub( const Type *, const Type * ) const;
 184 };
 185 
 186 //------------------------------CmpLNode---------------------------------------
 187 // Compare 2 long values, returning condition codes (-1, 0 or 1).
 188 class CmpLNode : public CmpNode {
 189 public:
 190   CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 191   virtual int    Opcode() const;
 192   virtual const Type *sub( const Type *, const Type * ) const;
 193 };
 194 
 195 //------------------------------CmpL3Node--------------------------------------
 196 // Compare 2 long values, returning integer value (-1, 0 or 1).
 197 class CmpL3Node : public CmpLNode {
 198 public:
 199   CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) {
 200     // Since it is not consumed by Bools, it is not really a Cmp.
 201     init_class_id(Class_Sub);
 202   }
 203   virtual int    Opcode() const;
 204   virtual uint ideal_reg() const { return Op_RegI; }
 205 };
 206 
 207 //------------------------------CmpFNode---------------------------------------
 208 // Compare 2 float values, returning condition codes (-1, 0 or 1).
 209 // This implements the Java bytecode fcmpl, so unordered returns -1.
 210 // Operands may not commute.
 211 class CmpFNode : public CmpNode {
 212 public:
 213   CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 214   virtual int Opcode() const;
 215   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
 216   const Type *Value( PhaseTransform *phase ) const;
 217 };
 218 
 219 //------------------------------CmpF3Node--------------------------------------
 220 // Compare 2 float values, returning integer value (-1, 0 or 1).
 221 // This implements the Java bytecode fcmpl, so unordered returns -1.
 222 // Operands may not commute.
 223 class CmpF3Node : public CmpFNode {
 224 public:
 225   CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(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   // Since it is not consumed by Bools, it is not really a Cmp.
 231   virtual uint ideal_reg() const { return Op_RegI; }
 232 };
 233 
 234 
 235 //------------------------------CmpDNode---------------------------------------
 236 // Compare 2 double values, returning condition codes (-1, 0 or 1).
 237 // This implements the Java bytecode dcmpl, so unordered returns -1.
 238 // Operands may not commute.
 239 class CmpDNode : public CmpNode {
 240 public:
 241   CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
 242   virtual int Opcode() const;
 243   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
 244   const Type *Value( PhaseTransform *phase ) const;
 245   virtual Node  *Ideal(PhaseGVN *phase, bool can_reshape);
 246 };
 247 
 248 //------------------------------CmpD3Node--------------------------------------
 249 // Compare 2 double values, returning integer value (-1, 0 or 1).
 250 // This implements the Java bytecode dcmpl, so unordered returns -1.
 251 // Operands may not commute.
 252 class CmpD3Node : public CmpDNode {
 253 public:
 254   CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) {
 255     // Since it is not consumed by Bools, it is not really a Cmp.
 256     init_class_id(Class_Sub);
 257   }
 258   virtual int Opcode() const;
 259   virtual uint ideal_reg() const { return Op_RegI; }
 260 };
 261 
 262 
 263 //------------------------------BoolTest---------------------------------------
 264 // Convert condition codes to a boolean test value (0 or -1).
 265 // We pick the values as 3 bits; the low order 2 bits we compare against the
 266 // condition codes, the high bit flips the sense of the result.
 267 struct BoolTest VALUE_OBJ_CLASS_SPEC {
 268   enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, illegal = 8 };
 269   mask _test;
 270   BoolTest( mask btm ) : _test(btm) {}
 271   const Type *cc2logical( const Type *CC ) const;
 272   // Commute the test.  I use a small table lookup.  The table is created as
 273   // a simple char array where each element is the ASCII version of a 'mask'
 274   // enum from above.
 275   mask commute( ) const { return mask("032147658"[_test]-'0'); }
 276   mask negate( ) const { return mask(_test^4); }
 277   bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); }
 278 #ifndef PRODUCT
 279   void dump_on(outputStream *st) const;
 280 #endif
 281 };
 282 
 283 //------------------------------BoolNode---------------------------------------
 284 // A Node to convert a Condition Codes to a Logical result.
 285 class BoolNode : public Node {
 286   virtual uint hash() const;
 287   virtual uint cmp( const Node &n ) const;
 288   virtual uint size_of() const;
 289 
 290   // Try to optimize signed integer comparison
 291   Node* fold_cmpI(PhaseGVN* phase, Node* cmp, Node* cmp1, Node* cmp2,
 292                   int cmp_op, int cmp1_op, const TypeInt* cmp2_type);
 293 public:
 294   const BoolTest _test;
 295   BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) {
 296     init_class_id(Class_Bool);
 297   }
 298   // Convert an arbitrary int value to a Bool or other suitable predicate.
 299   static Node* make_predicate(Node* test_value, PhaseGVN* phase);
 300   // Convert self back to an integer value.
 301   Node* as_int_value(PhaseGVN* phase);
 302   // Invert sense of self, returning new Bool.
 303   BoolNode* negate(PhaseGVN* phase);
 304   virtual int Opcode() const;
 305   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 306   virtual const Type *Value( PhaseTransform *phase ) const;
 307   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
 308   uint match_edge(uint idx) const { return 0; }
 309   virtual uint ideal_reg() const { return Op_RegI; }
 310 
 311   bool is_counted_loop_exit_test();
 312 #ifndef PRODUCT
 313   virtual void dump_spec(outputStream *st) const;
 314 #endif
 315 };
 316 
 317 //------------------------------AbsNode----------------------------------------
 318 // Abstract class for absolute value.  Mostly used to get a handy wrapper
 319 // for finding this pattern in the graph.
 320 class AbsNode : public Node {
 321 public:
 322   AbsNode( Node *value ) : Node(0,value) {}
 323 };
 324 
 325 //------------------------------AbsINode---------------------------------------
 326 // Absolute value an integer.  Since a naive graph involves control flow, we
 327 // "match" it in the ideal world (so the control flow can be removed).
 328 class AbsINode : public AbsNode {
 329 public:
 330   AbsINode( Node *in1 ) : AbsNode(in1) {}
 331   virtual int Opcode() const;
 332   const Type *bottom_type() const { return TypeInt::INT; }
 333   virtual uint ideal_reg() const { return Op_RegI; }
 334 };
 335 
 336 //------------------------------AbsFNode---------------------------------------
 337 // Absolute value a float, a common float-point idiom with a cheap hardware
 338 // implemention on most chips.  Since a naive graph involves control flow, we
 339 // "match" it in the ideal world (so the control flow can be removed).
 340 class AbsFNode : public AbsNode {
 341 public:
 342   AbsFNode( Node *in1 ) : AbsNode(in1) {}
 343   virtual int Opcode() const;
 344   const Type *bottom_type() const { return Type::FLOAT; }
 345   virtual uint ideal_reg() const { return Op_RegF; }
 346 };
 347 
 348 //------------------------------AbsDNode---------------------------------------
 349 // Absolute value a double, a common float-point idiom with a cheap hardware
 350 // implemention on most chips.  Since a naive graph involves control flow, we
 351 // "match" it in the ideal world (so the control flow can be removed).
 352 class AbsDNode : public AbsNode {
 353 public:
 354   AbsDNode( Node *in1 ) : AbsNode(in1) {}
 355   virtual int Opcode() const;
 356   const Type *bottom_type() const { return Type::DOUBLE; }
 357   virtual uint ideal_reg() const { return Op_RegD; }
 358 };
 359 
 360 
 361 //------------------------------CmpLTMaskNode----------------------------------
 362 // If p < q, return -1 else return 0.  Nice for flow-free idioms.
 363 class CmpLTMaskNode : public Node {
 364 public:
 365   CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {}
 366   virtual int Opcode() const;
 367   const Type *bottom_type() const { return TypeInt::INT; }
 368   virtual uint ideal_reg() const { return Op_RegI; }
 369 };
 370 
 371 
 372 //------------------------------NegNode----------------------------------------
 373 class NegNode : public Node {
 374 public:
 375   NegNode( Node *in1 ) : Node(0,in1) {}
 376 };
 377 
 378 //------------------------------NegFNode---------------------------------------
 379 // Negate value a float.  Negating 0.0 returns -0.0, but subtracting from
 380 // zero returns +0.0 (per JVM spec on 'fneg' bytecode).  As subtraction
 381 // cannot be used to replace negation we have to implement negation as ideal
 382 // node; note that negation and addition can replace subtraction.
 383 class NegFNode : public NegNode {
 384 public:
 385   NegFNode( Node *in1 ) : NegNode(in1) {}
 386   virtual int Opcode() const;
 387   const Type *bottom_type() const { return Type::FLOAT; }
 388   virtual uint ideal_reg() const { return Op_RegF; }
 389 };
 390 
 391 //------------------------------NegDNode---------------------------------------
 392 // Negate value a double.  Negating 0.0 returns -0.0, but subtracting from
 393 // zero returns +0.0 (per JVM spec on 'dneg' bytecode).  As subtraction
 394 // cannot be used to replace negation we have to implement negation as ideal
 395 // node; note that negation and addition can replace subtraction.
 396 class NegDNode : public NegNode {
 397 public:
 398   NegDNode( Node *in1 ) : NegNode(in1) {}
 399   virtual int Opcode() const;
 400   const Type *bottom_type() const { return Type::DOUBLE; }
 401   virtual uint ideal_reg() const { return Op_RegD; }
 402 };
 403 
 404 //------------------------------CosDNode---------------------------------------
 405 // Cosinus of a double
 406 class CosDNode : public Node {
 407 public:
 408   CosDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 409     init_flags(Flag_is_expensive);
 410     C->add_expensive_node(this);
 411   }
 412   virtual int Opcode() const;
 413   const Type *bottom_type() const { return Type::DOUBLE; }
 414   virtual uint ideal_reg() const { return Op_RegD; }
 415   virtual const Type *Value( PhaseTransform *phase ) const;
 416 };
 417 
 418 //------------------------------CosDNode---------------------------------------
 419 // Sinus of a double
 420 class SinDNode : public Node {
 421 public:
 422   SinDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 423     init_flags(Flag_is_expensive);
 424     C->add_expensive_node(this);
 425   }
 426   virtual int Opcode() const;
 427   const Type *bottom_type() const { return Type::DOUBLE; }
 428   virtual uint ideal_reg() const { return Op_RegD; }
 429   virtual const Type *Value( PhaseTransform *phase ) const;
 430 };
 431 
 432 
 433 //------------------------------TanDNode---------------------------------------
 434 // tangens of a double
 435 class TanDNode : public Node {
 436 public:
 437   TanDNode(Compile* C, Node *c,Node *in1) : Node(c, in1) {
 438     init_flags(Flag_is_expensive);
 439     C->add_expensive_node(this);
 440   }
 441   virtual int Opcode() const;
 442   const Type *bottom_type() const { return Type::DOUBLE; }
 443   virtual uint ideal_reg() const { return Op_RegD; }
 444   virtual const Type *Value( PhaseTransform *phase ) const;
 445 };
 446 
 447 
 448 //------------------------------AtanDNode--------------------------------------
 449 // arcus tangens of a double
 450 class AtanDNode : public Node {
 451 public:
 452   AtanDNode(Node *c, Node *in1, Node *in2  ) : Node(c, in1, in2) {}
 453   virtual int Opcode() const;
 454   const Type *bottom_type() const { return Type::DOUBLE; }
 455   virtual uint ideal_reg() const { return Op_RegD; }
 456 };
 457 
 458 
 459 //------------------------------SqrtDNode--------------------------------------
 460 // square root a double
 461 class SqrtDNode : public Node {
 462 public:
 463   SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 464     init_flags(Flag_is_expensive);
 465     C->add_expensive_node(this);
 466   }
 467   virtual int Opcode() const;
 468   const Type *bottom_type() const { return Type::DOUBLE; }
 469   virtual uint ideal_reg() const { return Op_RegD; }
 470   virtual const Type *Value( PhaseTransform *phase ) const;
 471 };
 472 
 473 //------------------------------ExpDNode---------------------------------------
 474 //  Exponentiate a double
 475 class ExpDNode : public Node {
 476 public:
 477   ExpDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 478     init_flags(Flag_is_expensive);
 479     C->add_expensive_node(this);
 480   }
 481   virtual int Opcode() const;
 482   const Type *bottom_type() const { return Type::DOUBLE; }
 483   virtual uint ideal_reg() const { return Op_RegD; }
 484   virtual const Type *Value( PhaseTransform *phase ) const;
 485 };
 486 
 487 //------------------------------LogDNode---------------------------------------
 488 // Log_e of a double
 489 class LogDNode : public Node {
 490 public:
 491   LogDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 492     init_flags(Flag_is_expensive);
 493     C->add_expensive_node(this);
 494   }
 495   virtual int Opcode() const;
 496   const Type *bottom_type() const { return Type::DOUBLE; }
 497   virtual uint ideal_reg() const { return Op_RegD; }
 498   virtual const Type *Value( PhaseTransform *phase ) const;
 499 };
 500 
 501 //------------------------------Log10DNode---------------------------------------
 502 // Log_10 of a double
 503 class Log10DNode : public Node {
 504 public:
 505   Log10DNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {
 506     init_flags(Flag_is_expensive);
 507     C->add_expensive_node(this);
 508   }
 509   virtual int Opcode() const;
 510   const Type *bottom_type() const { return Type::DOUBLE; }
 511   virtual uint ideal_reg() const { return Op_RegD; }
 512   virtual const Type *Value( PhaseTransform *phase ) const;
 513 };
 514 
 515 //------------------------------PowDNode---------------------------------------
 516 // Raise a double to a double power
 517 class PowDNode : public Node {
 518 public:
 519   PowDNode(Compile* C, Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {
 520     init_flags(Flag_is_expensive);
 521     C->add_expensive_node(this);
 522   }
 523   virtual int Opcode() const;
 524   const Type *bottom_type() const { return Type::DOUBLE; }
 525   virtual uint ideal_reg() const { return Op_RegD; }
 526   virtual const Type *Value( PhaseTransform *phase ) const;
 527 };
 528 
 529 //-------------------------------ReverseBytesINode--------------------------------
 530 // reverse bytes of an integer
 531 class ReverseBytesINode : public Node {
 532 public:
 533   ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {}
 534   virtual int Opcode() const;
 535   const Type *bottom_type() const { return TypeInt::INT; }
 536   virtual uint ideal_reg() const { return Op_RegI; }
 537 };
 538 
 539 //-------------------------------ReverseBytesLNode--------------------------------
 540 // reverse bytes of a long
 541 class ReverseBytesLNode : public Node {
 542 public:
 543   ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {}
 544   virtual int Opcode() const;
 545   const Type *bottom_type() const { return TypeLong::LONG; }
 546   virtual uint ideal_reg() const { return Op_RegL; }
 547 };
 548 
 549 //-------------------------------ReverseBytesUSNode--------------------------------
 550 // reverse bytes of an unsigned short / char
 551 class ReverseBytesUSNode : public Node {
 552 public:
 553   ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {}
 554   virtual int Opcode() const;
 555   const Type *bottom_type() const { return TypeInt::CHAR; }
 556   virtual uint ideal_reg() const { return Op_RegI; }
 557 };
 558 
 559 //-------------------------------ReverseBytesSNode--------------------------------
 560 // reverse bytes of a short
 561 class ReverseBytesSNode : public Node {
 562 public:
 563   ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {}
 564   virtual int Opcode() const;
 565   const Type *bottom_type() const { return TypeInt::SHORT; }
 566   virtual uint ideal_reg() const { return Op_RegI; }
 567 };
 568 
 569 #endif // SHARE_VM_OPTO_SUBNODE_HPP