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