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

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/
changeset: 6782:28b50d07f6f8
tag: jdk8u25-b17

     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  */

    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;

    53   const Type* Value_common( PhaseTransform *phase ) const;

    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;

    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;

    64 };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   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 public:

   290   const BoolTest _test;

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

   292     init_class_id(Class_Bool);

   293   }

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

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

   296   // Convert self back to an integer value.

   297   Node* as_int_value(PhaseGVN* phase);

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

   299   BoolNode* negate(PhaseGVN* phase);

   300   virtual int Opcode() const;

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

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

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

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

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

   307   bool is_counted_loop_exit_test();

   308 #ifndef PRODUCT

   309   virtual void dump_spec(outputStream *st) const;

   310 #endif

   311 };

   313 //------------------------------AbsNode----------------------------------------

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

   315 // for finding this pattern in the graph.

   316 class AbsNode : public Node {

   317 public:

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

   319 };

   321 //------------------------------AbsINode---------------------------------------

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

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

   324 class AbsINode : public AbsNode {

   325 public:

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

   327   virtual int Opcode() const;

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

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

   330 };

   332 //------------------------------AbsFNode---------------------------------------

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

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

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

   336 class AbsFNode : public AbsNode {

   337 public:

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

   339   virtual int Opcode() const;

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

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

   342 };

   344 //------------------------------AbsDNode---------------------------------------

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

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

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

   348 class AbsDNode : public AbsNode {

   349 public:

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

   351   virtual int Opcode() const;

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

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

   354 };

   357 //------------------------------CmpLTMaskNode----------------------------------

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

   359 class CmpLTMaskNode : public Node {

   360 public:

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

   362   virtual int Opcode() const;

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

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

   365 };

   368 //------------------------------NegNode----------------------------------------

   369 class NegNode : public Node {

   370 public:

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

   372 };

   374 //------------------------------NegFNode---------------------------------------

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

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

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

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

   379 class NegFNode : public NegNode {

   380 public:

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

   382   virtual int Opcode() const;

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

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

   385 };

   387 //------------------------------NegDNode---------------------------------------

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

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

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

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

   392 class NegDNode : public NegNode {

   393 public:

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

   395   virtual int Opcode() const;

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

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

   398 };

   400 //------------------------------CosDNode---------------------------------------

   401 // Cosinus of a double

   402 class CosDNode : public Node {

   403 public:

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

   405     init_flags(Flag_is_expensive);

   406     C->add_expensive_node(this);

   407   }

   408   virtual int Opcode() const;

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

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

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

   412 };

   414 //------------------------------CosDNode---------------------------------------

   415 // Sinus of a double

   416 class SinDNode : public Node {

   417 public:

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

   419     init_flags(Flag_is_expensive);

   420     C->add_expensive_node(this);

   421   }

   422   virtual int Opcode() const;

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

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

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

   426 };

   429 //------------------------------TanDNode---------------------------------------

   430 // tangens of a double

   431 class TanDNode : public Node {

   432 public:

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

   434     init_flags(Flag_is_expensive);

   435     C->add_expensive_node(this);

   436   }

   437   virtual int Opcode() const;

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

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

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

   441 };

   444 //------------------------------AtanDNode--------------------------------------

   445 // arcus tangens of a double

   446 class AtanDNode : public Node {

   447 public:

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

   449   virtual int Opcode() const;

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

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

   452 };

   455 //------------------------------SqrtDNode--------------------------------------

   456 // square root a double

   457 class SqrtDNode : public Node {

   458 public:

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

   460     init_flags(Flag_is_expensive);

   461     C->add_expensive_node(this);

   462   }

   463   virtual int Opcode() const;

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

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

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

   467 };

   469 //------------------------------ExpDNode---------------------------------------

   470 //  Exponentiate a double

   471 class ExpDNode : public Node {

   472 public:

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

   474     init_flags(Flag_is_expensive);

   475     C->add_expensive_node(this);

   476   }

   477   virtual int Opcode() const;

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

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

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

   481 };

   483 //------------------------------LogDNode---------------------------------------

   484 // Log_e of a double

   485 class LogDNode : public Node {

   486 public:

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

   488     init_flags(Flag_is_expensive);

   489     C->add_expensive_node(this);

   490   }

   491   virtual int Opcode() const;

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

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

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

   495 };

   497 //------------------------------Log10DNode---------------------------------------

   498 // Log_10 of a double

   499 class Log10DNode : public Node {

   500 public:

   501   Log10DNode(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( PhaseTransform *phase ) const;

   509 };

   511 //------------------------------PowDNode---------------------------------------

   512 // Raise a double to a double power

   513 class PowDNode : public Node {

   514 public:

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

   516     init_flags(Flag_is_expensive);

   517     C->add_expensive_node(this);

   518   }

   519   virtual int Opcode() const;

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

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

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

   523 };

   525 //-------------------------------ReverseBytesINode--------------------------------

   526 // reverse bytes of an integer

   527 class ReverseBytesINode : public Node {

   528 public:

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

   530   virtual int Opcode() const;

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

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

   533 };

   535 //-------------------------------ReverseBytesLNode--------------------------------

   536 // reverse bytes of a long

   537 class ReverseBytesLNode : public Node {

   538 public:

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

   540   virtual int Opcode() const;

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

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

   543 };

   545 //-------------------------------ReverseBytesUSNode--------------------------------

   546 // reverse bytes of an unsigned short / char

   547 class ReverseBytesUSNode : public Node {

   548 public:

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

   550   virtual int Opcode() const;

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

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

   553 };

   555 //-------------------------------ReverseBytesSNode--------------------------------

   556 // reverse bytes of a short

   557 class ReverseBytesSNode : public Node {

   558 public:

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

   560   virtual int Opcode() const;

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

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

   563 };

   565 #endif // SHARE_VM_OPTO_SUBNODE_HPP

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

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

src/share/vm/opto/subnode.hpp