jdk8-mips64-public/hotspot: src/share/vm/opto/subnode.hpp@da862781b584

     1 /*

     2  * Copyright (c) 1997, 2012, 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  */

    25 #ifndef SHARE_VM_OPTO_SUBNODE_HPP

    26 #define SHARE_VM_OPTO_SUBNODE_HPP

    28 #include "opto/node.hpp"

    29 #include "opto/opcodes.hpp"

    30 #include "opto/type.hpp"

    32 // Portions of code courtesy of Clifford Click

    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   }

    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 );

    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;

    54   // Supplied function returns the subtractend of the inputs.

    55   // This also type-checks the inputs for sanity.  Guaranteed never to

    56   // be passed a TOP or BOTTOM type, these are filtered out by a pre-check.

    57   virtual const Type *sub( const Type *, const Type * ) const = 0;

    59   // Supplied function to return the additive identity type.

    60   // This is returned whenever the subtracts inputs are the same.

    61   virtual const Type *add_id() const = 0;

    63 };

    66 // NOTE: SubINode should be taken away and replaced by add and negate

    67 //------------------------------SubINode---------------------------------------

    68 // Subtract 2 integers

    69 class SubINode : public SubNode {

    70 public:

    71   SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}

    72   virtual int Opcode() const;

    73   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

    74   virtual const Type *sub( const Type *, const Type * ) const;

    75   const Type *add_id() const { return TypeInt::ZERO; }

    76   const Type *bottom_type() const { return TypeInt::INT; }

    77   virtual uint ideal_reg() const { return Op_RegI; }

    78 };

    80 //------------------------------SubLNode---------------------------------------

    81 // Subtract 2 integers

    82 class SubLNode : public SubNode {

    83 public:

    84   SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}

    85   virtual int Opcode() const;

    86   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

    87   virtual const Type *sub( const Type *, const Type * ) const;

    88   const Type *add_id() const { return TypeLong::ZERO; }

    89   const Type *bottom_type() const { return TypeLong::LONG; }

    90   virtual uint ideal_reg() const { return Op_RegL; }

    91 };

    93 // NOTE: SubFPNode should be taken away and replaced by add and negate

    94 //------------------------------SubFPNode--------------------------------------

    95 // Subtract 2 floats or doubles

    96 class SubFPNode : public SubNode {

    97 protected:

    98   SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}

    99 public:

   100   const Type *Value( PhaseTransform *phase ) const;

   101 };

   103 // NOTE: SubFNode should be taken away and replaced by add and negate

   104 //------------------------------SubFNode---------------------------------------

   105 // Subtract 2 doubles

   106 class SubFNode : public SubFPNode {

   107 public:

   108   SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}

   109   virtual int Opcode() const;

   110   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   111   virtual const Type *sub( const Type *, const Type * ) const;

   112   const Type   *add_id() const { return TypeF::ZERO; }

   113   const Type   *bottom_type() const { return Type::FLOAT; }

   114   virtual uint  ideal_reg() const { return Op_RegF; }

   115 };

   117 // NOTE: SubDNode should be taken away and replaced by add and negate

   118 //------------------------------SubDNode---------------------------------------

   119 // Subtract 2 doubles

   120 class SubDNode : public SubFPNode {

   121 public:

   122   SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}

   123   virtual int Opcode() const;

   124   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   125   virtual const Type *sub( const Type *, const Type * ) const;

   126   const Type   *add_id() const { return TypeD::ZERO; }

   127   const Type   *bottom_type() const { return Type::DOUBLE; }

   128   virtual uint  ideal_reg() const { return Op_RegD; }

   129 };

   131 //------------------------------CmpNode---------------------------------------

   132 // Compare 2 values, returning condition codes (-1, 0 or 1).

   133 class CmpNode : public SubNode {

   134 public:

   135   CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {

   136     init_class_id(Class_Cmp);

   137   }

   138   virtual Node *Identity( PhaseTransform *phase );

   139   const Type *add_id() const { return TypeInt::ZERO; }

   140   const Type *bottom_type() const { return TypeInt::CC; }

   141   virtual uint ideal_reg() const { return Op_RegFlags; }

   142 };

   144 //------------------------------CmpINode---------------------------------------

   145 // Compare 2 signed values, returning condition codes (-1, 0 or 1).

   146 class CmpINode : public CmpNode {

   147 public:

   148   CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   149   virtual int Opcode() const;

   150   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   151   virtual const Type *sub( const Type *, const Type * ) const;

   152 };

   154 //------------------------------CmpUNode---------------------------------------

   155 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1).

   156 class CmpUNode : public CmpNode {

   157 public:

   158   CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   159   virtual int Opcode() const;

   160   virtual const Type *sub( const Type *, const Type * ) const;

   161   bool is_index_range_check() const;

   162 };

   164 //------------------------------CmpPNode---------------------------------------

   165 // Compare 2 pointer values, returning condition codes (-1, 0 or 1).

   166 class CmpPNode : public CmpNode {

   167 public:

   168   CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   169   virtual int Opcode() const;

   170   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   171   virtual const Type *sub( const Type *, const Type * ) const;

   172 };

   174 //------------------------------CmpNNode--------------------------------------

   175 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1).

   176 class CmpNNode : public CmpNode {

   177 public:

   178   CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   179   virtual int Opcode() const;

   180   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   181   virtual const Type *sub( const Type *, const Type * ) const;

   182 };

   184 //------------------------------CmpLNode---------------------------------------

   185 // Compare 2 long values, returning condition codes (-1, 0 or 1).

   186 class CmpLNode : public CmpNode {

   187 public:

   188   CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   189   virtual int    Opcode() const;

   190   virtual const Type *sub( const Type *, const Type * ) const;

   191 };

   193 //------------------------------CmpL3Node--------------------------------------

   194 // Compare 2 long values, returning integer value (-1, 0 or 1).

   195 class CmpL3Node : public CmpLNode {

   196 public:

   197   CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) {

   198     // Since it is not consumed by Bools, it is not really a Cmp.

   199     init_class_id(Class_Sub);

   200   }

   201   virtual int    Opcode() const;

   202   virtual uint ideal_reg() const { return Op_RegI; }

   203 };

   205 //------------------------------CmpFNode---------------------------------------

   206 // Compare 2 float values, returning condition codes (-1, 0 or 1).

   207 // This implements the Java bytecode fcmpl, so unordered returns -1.

   208 // Operands may not commute.

   209 class CmpFNode : public CmpNode {

   210 public:

   211   CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   212   virtual int Opcode() const;

   213   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }

   214   const Type *Value( PhaseTransform *phase ) const;

   215 };

   217 //------------------------------CmpF3Node--------------------------------------

   218 // Compare 2 float values, returning integer value (-1, 0 or 1).

   219 // This implements the Java bytecode fcmpl, so unordered returns -1.

   220 // Operands may not commute.

   221 class CmpF3Node : public CmpFNode {

   222 public:

   223   CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) {

   224     // Since it is not consumed by Bools, it is not really a Cmp.

   225     init_class_id(Class_Sub);

   226   }

   227   virtual int Opcode() const;

   228   // Since it is not consumed by Bools, it is not really a Cmp.

   229   virtual uint ideal_reg() const { return Op_RegI; }

   230 };

   233 //------------------------------CmpDNode---------------------------------------

   234 // Compare 2 double values, returning condition codes (-1, 0 or 1).

   235 // This implements the Java bytecode dcmpl, so unordered returns -1.

   236 // Operands may not commute.

   237 class CmpDNode : public CmpNode {

   238 public:

   239   CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}

   240   virtual int Opcode() const;

   241   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }

   242   const Type *Value( PhaseTransform *phase ) const;

   243   virtual Node  *Ideal(PhaseGVN *phase, bool can_reshape);

   244 };

   246 //------------------------------CmpD3Node--------------------------------------

   247 // Compare 2 double values, returning integer value (-1, 0 or 1).

   248 // This implements the Java bytecode dcmpl, so unordered returns -1.

   249 // Operands may not commute.

   250 class CmpD3Node : public CmpDNode {

   251 public:

   252   CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) {

   253     // Since it is not consumed by Bools, it is not really a Cmp.

   254     init_class_id(Class_Sub);

   255   }

   256   virtual int Opcode() const;

   257   virtual uint ideal_reg() const { return Op_RegI; }

   258 };

   261 //------------------------------BoolTest---------------------------------------

   262 // Convert condition codes to a boolean test value (0 or -1).

   263 // We pick the values as 3 bits; the low order 2 bits we compare against the

   264 // condition codes, the high bit flips the sense of the result.

   265 struct BoolTest VALUE_OBJ_CLASS_SPEC {

   266   enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, overflow = 2, no_overflow = 6, illegal = 8 };

   267   mask _test;

   268   BoolTest( mask btm ) : _test(btm) {}

   269   const Type *cc2logical( const Type *CC ) const;

   270   // Commute the test.  I use a small table lookup.  The table is created as

   271   // a simple char array where each element is the ASCII version of a 'mask'

   272   // enum from above.

   273   mask commute( ) const { return mask("032147658"[_test]-'0'); }

   274   mask negate( ) const { return mask(_test^4); }

   275   bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le || _test == BoolTest::overflow); }

   276 #ifndef PRODUCT

   277   void dump_on(outputStream *st) const;

   278 #endif

   279 };

   281 //------------------------------BoolNode---------------------------------------

   282 // A Node to convert a Condition Codes to a Logical result.

   283 class BoolNode : public Node {

   284   virtual uint hash() const;

   285   virtual uint cmp( const Node &n ) const;

   286   virtual uint size_of() const;

   287 public:

   288   const BoolTest _test;

   289   BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) {

   290     init_class_id(Class_Bool);

   291   }

   292   // Convert an arbitrary int value to a Bool or other suitable predicate.

   293   static Node* make_predicate(Node* test_value, PhaseGVN* phase);

   294   // Convert self back to an integer value.

   295   Node* as_int_value(PhaseGVN* phase);

   296   // Invert sense of self, returning new Bool.

   297   BoolNode* negate(PhaseGVN* phase);

   298   virtual int Opcode() const;

   299   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

   300   virtual const Type *Value( PhaseTransform *phase ) const;

   301   virtual const Type *bottom_type() const { return TypeInt::BOOL; }

   302   uint match_edge(uint idx) const { return 0; }

   303   virtual uint ideal_reg() const { return Op_RegI; }

   305   bool is_counted_loop_exit_test();

   306 #ifndef PRODUCT

   307   virtual void dump_spec(outputStream *st) const;

   308 #endif

   309 };

   311 //------------------------------AbsNode----------------------------------------

   312 // Abstract class for absolute value.  Mostly used to get a handy wrapper

   313 // for finding this pattern in the graph.

   314 class AbsNode : public Node {

   315 public:

   316   AbsNode( Node *value ) : Node(0,value) {}

   317 };

   319 //------------------------------AbsINode---------------------------------------

   320 // Absolute value an integer.  Since a naive graph involves control flow, we

   321 // "match" it in the ideal world (so the control flow can be removed).

   322 class AbsINode : public AbsNode {

   323 public:

   324   AbsINode( Node *in1 ) : AbsNode(in1) {}

   325   virtual int Opcode() const;

   326   const Type *bottom_type() const { return TypeInt::INT; }

   327   virtual uint ideal_reg() const { return Op_RegI; }

   328 };

   330 //------------------------------AbsFNode---------------------------------------

   331 // Absolute value a float, a common float-point idiom with a cheap hardware

   332 // implemention on most chips.  Since a naive graph involves control flow, we

   333 // "match" it in the ideal world (so the control flow can be removed).

   334 class AbsFNode : public AbsNode {

   335 public:

   336   AbsFNode( Node *in1 ) : AbsNode(in1) {}

   337   virtual int Opcode() const;

   338   const Type *bottom_type() const { return Type::FLOAT; }

   339   virtual uint ideal_reg() const { return Op_RegF; }

   340 };

   342 //------------------------------AbsDNode---------------------------------------

   343 // Absolute value a double, a common float-point idiom with a cheap hardware

   344 // implemention on most chips.  Since a naive graph involves control flow, we

   345 // "match" it in the ideal world (so the control flow can be removed).

   346 class AbsDNode : public AbsNode {

   347 public:

   348   AbsDNode( Node *in1 ) : AbsNode(in1) {}

   349   virtual int Opcode() const;

   350   const Type *bottom_type() const { return Type::DOUBLE; }

   351   virtual uint ideal_reg() const { return Op_RegD; }

   352 };

   355 //------------------------------CmpLTMaskNode----------------------------------

   356 // If p < q, return -1 else return 0.  Nice for flow-free idioms.

   357 class CmpLTMaskNode : public Node {

   358 public:

   359   CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {}

   360   virtual int Opcode() const;

   361   const Type *bottom_type() const { return TypeInt::INT; }

   362   virtual uint ideal_reg() const { return Op_RegI; }

   363 };

   366 //------------------------------NegNode----------------------------------------

   367 class NegNode : public Node {

   368 public:

   369   NegNode( Node *in1 ) : Node(0,in1) {}

   370 };

   372 //------------------------------NegFNode---------------------------------------

   373 // Negate value a float.  Negating 0.0 returns -0.0, but subtracting from

   374 // zero returns +0.0 (per JVM spec on 'fneg' bytecode).  As subtraction

   375 // cannot be used to replace negation we have to implement negation as ideal

   376 // node; note that negation and addition can replace subtraction.

   377 class NegFNode : public NegNode {

   378 public:

   379   NegFNode( Node *in1 ) : NegNode(in1) {}

   380   virtual int Opcode() const;

   381   const Type *bottom_type() const { return Type::FLOAT; }

   382   virtual uint ideal_reg() const { return Op_RegF; }

   383 };

   385 //------------------------------NegDNode---------------------------------------

   386 // Negate value a double.  Negating 0.0 returns -0.0, but subtracting from

   387 // zero returns +0.0 (per JVM spec on 'dneg' bytecode).  As subtraction

   388 // cannot be used to replace negation we have to implement negation as ideal

   389 // node; note that negation and addition can replace subtraction.

   390 class NegDNode : public NegNode {

   391 public:

   392   NegDNode( Node *in1 ) : NegNode(in1) {}

   393   virtual int Opcode() const;

   394   const Type *bottom_type() const { return Type::DOUBLE; }

   395   virtual uint ideal_reg() const { return Op_RegD; }

   396 };

   398 //------------------------------CosDNode---------------------------------------

   399 // Cosinus of a double

   400 class CosDNode : public Node {

   401 public:

   402   CosDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   403     init_flags(Flag_is_expensive);

   404     C->add_expensive_node(this);

   405   }

   406   virtual int Opcode() const;

   407   const Type *bottom_type() const { return Type::DOUBLE; }

   408   virtual uint ideal_reg() const { return Op_RegD; }

   409   virtual const Type *Value( PhaseTransform *phase ) const;

   410 };

   412 //------------------------------CosDNode---------------------------------------

   413 // Sinus of a double

   414 class SinDNode : public Node {

   415 public:

   416   SinDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   417     init_flags(Flag_is_expensive);

   418     C->add_expensive_node(this);

   419   }

   420   virtual int Opcode() const;

   421   const Type *bottom_type() const { return Type::DOUBLE; }

   422   virtual uint ideal_reg() const { return Op_RegD; }

   423   virtual const Type *Value( PhaseTransform *phase ) const;

   424 };

   427 //------------------------------TanDNode---------------------------------------

   428 // tangens of a double

   429 class TanDNode : public Node {

   430 public:

   431   TanDNode(Compile* C, Node *c,Node *in1) : Node(c, in1) {

   432     init_flags(Flag_is_expensive);

   433     C->add_expensive_node(this);

   434   }

   435   virtual int Opcode() const;

   436   const Type *bottom_type() const { return Type::DOUBLE; }

   437   virtual uint ideal_reg() const { return Op_RegD; }

   438   virtual const Type *Value( PhaseTransform *phase ) const;

   439 };

   442 //------------------------------AtanDNode--------------------------------------

   443 // arcus tangens of a double

   444 class AtanDNode : public Node {

   445 public:

   446   AtanDNode(Node *c, Node *in1, Node *in2  ) : Node(c, in1, in2) {}

   447   virtual int Opcode() const;

   448   const Type *bottom_type() const { return Type::DOUBLE; }

   449   virtual uint ideal_reg() const { return Op_RegD; }

   450 };

   453 //------------------------------SqrtDNode--------------------------------------

   454 // square root a double

   455 class SqrtDNode : public Node {

   456 public:

   457   SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   458     init_flags(Flag_is_expensive);

   459     C->add_expensive_node(this);

   460   }

   461   virtual int Opcode() const;

   462   const Type *bottom_type() const { return Type::DOUBLE; }

   463   virtual uint ideal_reg() const { return Op_RegD; }

   464   virtual const Type *Value( PhaseTransform *phase ) const;

   465 };

   467 //------------------------------ExpDNode---------------------------------------

   468 //  Exponentiate a double

   469 class ExpDNode : public Node {

   470 public:

   471   ExpDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   472     init_flags(Flag_is_expensive);

   473     C->add_expensive_node(this);

   474   }

   475   virtual int Opcode() const;

   476   const Type *bottom_type() const { return Type::DOUBLE; }

   477   virtual uint ideal_reg() const { return Op_RegD; }

   478   virtual const Type *Value( PhaseTransform *phase ) const;

   479 };

   481 //------------------------------LogDNode---------------------------------------

   482 // Log_e of a double

   483 class LogDNode : public Node {

   484 public:

   485   LogDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   486     init_flags(Flag_is_expensive);

   487     C->add_expensive_node(this);

   488   }

   489   virtual int Opcode() const;

   490   const Type *bottom_type() const { return Type::DOUBLE; }

   491   virtual uint ideal_reg() const { return Op_RegD; }

   492   virtual const Type *Value( PhaseTransform *phase ) const;

   493 };

   495 //------------------------------Log10DNode---------------------------------------

   496 // Log_10 of a double

   497 class Log10DNode : public Node {

   498 public:

   499   Log10DNode(Compile* C, Node *c, Node *in1) : Node(c, in1) {

   500     init_flags(Flag_is_expensive);

   501     C->add_expensive_node(this);

   502   }

   503   virtual int Opcode() const;

   504   const Type *bottom_type() const { return Type::DOUBLE; }

   505   virtual uint ideal_reg() const { return Op_RegD; }

   506   virtual const Type *Value( PhaseTransform *phase ) const;

   507 };

   509 //------------------------------PowDNode---------------------------------------

   510 // Raise a double to a double power

   511 class PowDNode : public Node {

   512 public:

   513   PowDNode(Compile* C, Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {

   514     init_flags(Flag_is_expensive);

   515     C->add_expensive_node(this);

   516   }

   517   virtual int Opcode() const;

   518   const Type *bottom_type() const { return Type::DOUBLE; }

   519   virtual uint ideal_reg() const { return Op_RegD; }

   520   virtual const Type *Value( PhaseTransform *phase ) const;

   521 };

   523 //-------------------------------ReverseBytesINode--------------------------------

   524 // reverse bytes of an integer

   525 class ReverseBytesINode : public Node {

   526 public:

   527   ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {}

   528   virtual int Opcode() const;

   529   const Type *bottom_type() const { return TypeInt::INT; }

   530   virtual uint ideal_reg() const { return Op_RegI; }

   531 };

   533 //-------------------------------ReverseBytesLNode--------------------------------

   534 // reverse bytes of a long

   535 class ReverseBytesLNode : public Node {

   536 public:

   537   ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {}

   538   virtual int Opcode() const;

   539   const Type *bottom_type() const { return TypeLong::LONG; }

   540   virtual uint ideal_reg() const { return Op_RegL; }

   541 };

   543 //-------------------------------ReverseBytesUSNode--------------------------------

   544 // reverse bytes of an unsigned short / char

   545 class ReverseBytesUSNode : public Node {

   546 public:

   547   ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {}

   548   virtual int Opcode() const;

   549   const Type *bottom_type() const { return TypeInt::CHAR; }

   550   virtual uint ideal_reg() const { return Op_RegI; }

   551 };

   553 //-------------------------------ReverseBytesSNode--------------------------------

   554 // reverse bytes of a short

   555 class ReverseBytesSNode : public Node {

   556 public:

   557   ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {}

   558   virtual int Opcode() const;

   559   const Type *bottom_type() const { return TypeInt::SHORT; }

   560   virtual uint ideal_reg() const { return Op_RegI; }

   561 };

   563 #endif // SHARE_VM_OPTO_SUBNODE_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/opto/subnode.hpp@da862781b584

src/share/vm/opto/subnode.hpp