jdk8-mips64-public/hotspot: src/share/vm/opto/subnode.hpp@bd441136a5ce (annotated)

src/share/vm/opto/subnode.hpp@bd441136a5ce (annotated)

src/share/vm/opto/subnode.hpp

Thu, 19 Mar 2009 09:13:24 -0700

author: kvn
date: Thu, 19 Mar 2009 09:13:24 -0700
changeset 1082: bd441136a5ce
parent 631: d1605aabd0a1
child 1831: d7f654633cfe
permissions: -rw-r--r--

Merge

 /*
  * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  *
  */
 // Portions of code courtesy of Clifford Click
 //------------------------------SUBNode----------------------------------------
 // Class SUBTRACTION functionality.  This covers all the usual 'subtract'
 // behaviors.  Subtract-integer, -float, -double, binary xor, compare-integer,
 // -float, and -double are all inherited from this class.  The compare
 // functions behave like subtract functions, except that all negative answers
 // are compressed into -1, and all positive answers compressed to 1.
 class SubNode : public Node {
 public:
   SubNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {
     init_class_id(Class_Sub);
   }
   // Handle algebraic identities here.  If we have an identity, return the Node
   // we are equivalent to.  We look for "add of zero" as an identity.
   virtual Node *Identity( PhaseTransform *phase );
   // Compute a new Type for this node.  Basically we just do the pre-check,
   // then call the virtual add() to set the type.
   virtual const Type *Value( PhaseTransform *phase ) const;
   // Supplied function returns the subtractend of the inputs.
   // This also type-checks the inputs for sanity.  Guaranteed never to
   // be passed a TOP or BOTTOM type, these are filtered out by a pre-check.
   virtual const Type *sub( const Type *, const Type * ) const = 0;
   // Supplied function to return the additive identity type.
   // This is returned whenever the subtracts inputs are the same.
   virtual const Type *add_id() const = 0;
 };
 // NOTE: SubINode should be taken away and replaced by add and negate
 //------------------------------SubINode---------------------------------------
 // Subtract 2 integers
 class SubINode : public SubNode {
 public:
   SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
   const Type *add_id() const { return TypeInt::ZERO; }
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------SubLNode---------------------------------------
 // Subtract 2 integers
 class SubLNode : public SubNode {
 public:
   SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
   const Type *add_id() const { return TypeLong::ZERO; }
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 // NOTE: SubFPNode should be taken away and replaced by add and negate
 //------------------------------SubFPNode--------------------------------------
 // Subtract 2 floats or doubles
 class SubFPNode : public SubNode {
 protected:
   SubFPNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {}
 public:
   const Type *Value( PhaseTransform *phase ) const;
 };
 // NOTE: SubFNode should be taken away and replaced by add and negate
 //------------------------------SubFNode---------------------------------------
 // Subtract 2 doubles
 class SubFNode : public SubFPNode {
 public:
   SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
   const Type   *add_id() const { return TypeF::ZERO; }
   const Type   *bottom_type() const { return Type::FLOAT; }
   virtual uint  ideal_reg() const { return Op_RegF; }
 };
 // NOTE: SubDNode should be taken away and replaced by add and negate
 //------------------------------SubDNode---------------------------------------
 // Subtract 2 doubles
 class SubDNode : public SubFPNode {
 public:
   SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
   const Type   *add_id() const { return TypeD::ZERO; }
   const Type   *bottom_type() const { return Type::DOUBLE; }
   virtual uint  ideal_reg() const { return Op_RegD; }
 };
 //------------------------------CmpNode---------------------------------------
 // Compare 2 values, returning condition codes (-1, 0 or 1).
 class CmpNode : public SubNode {
 public:
   CmpNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {
     init_class_id(Class_Cmp);
   }
   virtual Node *Identity( PhaseTransform *phase );
   const Type *add_id() const { return TypeInt::ZERO; }
   const Type *bottom_type() const { return TypeInt::CC; }
   virtual uint ideal_reg() const { return Op_RegFlags; }
 };
 //------------------------------CmpINode---------------------------------------
 // Compare 2 signed values, returning condition codes (-1, 0 or 1).
 class CmpINode : public CmpNode {
 public:
   CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
 };
 //------------------------------CmpUNode---------------------------------------
 // Compare 2 unsigned values (integer or pointer), returning condition codes (-1, 0 or 1).
 class CmpUNode : public CmpNode {
 public:
   CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const;
 };
 //------------------------------CmpPNode---------------------------------------
 // Compare 2 pointer values, returning condition codes (-1, 0 or 1).
 class CmpPNode : public CmpNode {
 public:
   CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
 };
 //------------------------------CmpNNode--------------------------------------
 // Compare 2 narrow oop values, returning condition codes (-1, 0 or 1).
 class CmpNNode : public CmpNode {
 public:
   CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *sub( const Type *, const Type * ) const;
 };
 //------------------------------CmpLNode---------------------------------------
 // Compare 2 long values, returning condition codes (-1, 0 or 1).
 class CmpLNode : public CmpNode {
 public:
   CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int    Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const;
 };
 //------------------------------CmpL3Node--------------------------------------
 // Compare 2 long values, returning integer value (-1, 0 or 1).
 class CmpL3Node : public CmpLNode {
 public:
   CmpL3Node( Node *in1, Node *in2 ) : CmpLNode(in1,in2) {
     // Since it is not consumed by Bools, it is not really a Cmp.
     init_class_id(Class_Sub);
   }
   virtual int    Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------CmpFNode---------------------------------------
 // Compare 2 float values, returning condition codes (-1, 0 or 1).
 // This implements the Java bytecode fcmpl, so unordered returns -1.
 // Operands may not commute.
 class CmpFNode : public CmpNode {
 public:
   CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
   const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------CmpF3Node--------------------------------------
 // Compare 2 float values, returning integer value (-1, 0 or 1).
 // This implements the Java bytecode fcmpl, so unordered returns -1.
 // Operands may not commute.
 class CmpF3Node : public CmpFNode {
 public:
   CmpF3Node( Node *in1, Node *in2 ) : CmpFNode(in1,in2) {
     // Since it is not consumed by Bools, it is not really a Cmp.
     init_class_id(Class_Sub);
   }
   virtual int Opcode() const;
   // Since it is not consumed by Bools, it is not really a Cmp.
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------CmpDNode---------------------------------------
 // Compare 2 double values, returning condition codes (-1, 0 or 1).
 // This implements the Java bytecode dcmpl, so unordered returns -1.
 // Operands may not commute.
 class CmpDNode : public CmpNode {
 public:
   CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {}
   virtual int Opcode() const;
   virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; }
   const Type *Value( PhaseTransform *phase ) const;
   virtual Node  *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 //------------------------------CmpD3Node--------------------------------------
 // Compare 2 double values, returning integer value (-1, 0 or 1).
 // This implements the Java bytecode dcmpl, so unordered returns -1.
 // Operands may not commute.
 class CmpD3Node : public CmpDNode {
 public:
   CmpD3Node( Node *in1, Node *in2 ) : CmpDNode(in1,in2) {
     // Since it is not consumed by Bools, it is not really a Cmp.
     init_class_id(Class_Sub);
   }
   virtual int Opcode() const;
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------BoolTest---------------------------------------
 // Convert condition codes to a boolean test value (0 or -1).
 // We pick the values as 3 bits; the low order 2 bits we compare against the
 // condition codes, the high bit flips the sense of the result.
 struct BoolTest VALUE_OBJ_CLASS_SPEC {
   enum mask { eq = 0, ne = 4, le = 5, ge = 7, lt = 3, gt = 1, illegal = 8 };
   mask _test;
   BoolTest( mask btm ) : _test(btm) {}
   const Type *cc2logical( const Type *CC ) const;
   // Commute the test.  I use a small table lookup.  The table is created as
   // a simple char array where each element is the ASCII version of a 'mask'
   // enum from above.
   mask commute( ) const { return mask("038147858"[_test]-'0'); }
   mask negate( ) const { return mask(_test^4); }
   bool is_canonical( ) const { return (_test == BoolTest::ne || _test == BoolTest::lt || _test == BoolTest::le); }
 #ifndef PRODUCT
   void dump_on(outputStream *st) const;
 #endif
 };
 //------------------------------BoolNode---------------------------------------
 // A Node to convert a Condition Codes to a Logical result.
 class BoolNode : public Node {
   virtual uint hash() const;
   virtual uint cmp( const Node &n ) const;
   virtual uint size_of() const;
 public:
   const BoolTest _test;
   BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) {
     init_class_id(Class_Bool);
   }
   // Convert an arbitrary int value to a Bool or other suitable predicate.
   static Node* make_predicate(Node* test_value, PhaseGVN* phase);
   // Convert self back to an integer value.
   Node* as_int_value(PhaseGVN* phase);
   // Invert sense of self, returning new Bool.
   BoolNode* negate(PhaseGVN* phase);
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *Value( PhaseTransform *phase ) const;
   virtual const Type *bottom_type() const { return TypeInt::BOOL; }
   uint match_edge(uint idx) const { return 0; }
   virtual uint ideal_reg() const { return Op_RegI; }
   bool is_counted_loop_exit_test();
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const;
 #endif
 };
 //------------------------------AbsNode----------------------------------------
 // Abstract class for absolute value.  Mostly used to get a handy wrapper
 // for finding this pattern in the graph.
 class AbsNode : public Node {
 public:
   AbsNode( Node *value ) : Node(0,value) {}
 };
 //------------------------------AbsINode---------------------------------------
 // Absolute value an integer.  Since a naive graph involves control flow, we
 // "match" it in the ideal world (so the control flow can be removed).
 class AbsINode : public AbsNode {
 public:
   AbsINode( Node *in1 ) : AbsNode(in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------AbsFNode---------------------------------------
 // Absolute value a float, a common float-point idiom with a cheap hardware
 // implemention on most chips.  Since a naive graph involves control flow, we
 // "match" it in the ideal world (so the control flow can be removed).
 class AbsFNode : public AbsNode {
 public:
   AbsFNode( Node *in1 ) : AbsNode(in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint ideal_reg() const { return Op_RegF; }
 };
 //------------------------------AbsDNode---------------------------------------
 // Absolute value a double, a common float-point idiom with a cheap hardware
 // implemention on most chips.  Since a naive graph involves control flow, we
 // "match" it in the ideal world (so the control flow can be removed).
 class AbsDNode : public AbsNode {
 public:
   AbsDNode( Node *in1 ) : AbsNode(in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 //------------------------------CmpLTMaskNode----------------------------------
 // If p < q, return -1 else return 0.  Nice for flow-free idioms.
 class CmpLTMaskNode : public Node {
 public:
   CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //------------------------------NegNode----------------------------------------
 class NegNode : public Node {
 public:
   NegNode( Node *in1 ) : Node(0,in1) {}
 };
 //------------------------------NegFNode---------------------------------------
 // Negate value a float.  Negating 0.0 returns -0.0, but subtracting from
 // zero returns +0.0 (per JVM spec on 'fneg' bytecode).  As subtraction
 // cannot be used to replace negation we have to implement negation as ideal
 // node; note that negation and addition can replace subtraction.
 class NegFNode : public NegNode {
 public:
   NegFNode( Node *in1 ) : NegNode(in1) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   const Type *bottom_type() const { return Type::FLOAT; }
   virtual uint ideal_reg() const { return Op_RegF; }
 };
 //------------------------------NegDNode---------------------------------------
 // Negate value a double.  Negating 0.0 returns -0.0, but subtracting from
 // zero returns +0.0 (per JVM spec on 'dneg' bytecode).  As subtraction
 // cannot be used to replace negation we have to implement negation as ideal
 // node; note that negation and addition can replace subtraction.
 class NegDNode : public NegNode {
 public:
   NegDNode( Node *in1 ) : NegNode(in1) {}
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 //------------------------------CosDNode---------------------------------------
 // Cosinus of a double
 class CosDNode : public Node {
 public:
   CosDNode( Node *in1  ) : Node(0, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------CosDNode---------------------------------------
 // Sinus of a double
 class SinDNode : public Node {
 public:
   SinDNode( Node *in1  ) : Node(0, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------TanDNode---------------------------------------
 // tangens of a double
 class TanDNode : public Node {
 public:
   TanDNode(Node *in1  ) : Node(0, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------AtanDNode--------------------------------------
 // arcus tangens of a double
 class AtanDNode : public Node {
 public:
   AtanDNode(Node *c, Node *in1, Node *in2  ) : Node(c, in1, in2) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
 };
 //------------------------------SqrtDNode--------------------------------------
 // square root a double
 class SqrtDNode : public Node {
 public:
   SqrtDNode(Node *c, Node *in1  ) : Node(c, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------ExpDNode---------------------------------------
 //  Exponentiate a double
 class ExpDNode : public Node {
 public:
   ExpDNode( Node *c, Node *in1 ) : Node(c, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------LogDNode---------------------------------------
 // Log_e of a double
 class LogDNode : public Node {
 public:
   LogDNode( Node *in1 ) : Node(0, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------Log10DNode---------------------------------------
 // Log_10 of a double
 class Log10DNode : public Node {
 public:
   Log10DNode( Node *in1 ) : Node(0, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //------------------------------PowDNode---------------------------------------
 // Raise a double to a double power
 class PowDNode : public Node {
 public:
   PowDNode(Node *c, Node *in1, Node *in2  ) : Node(c, in1, in2) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return Type::DOUBLE; }
   virtual uint ideal_reg() const { return Op_RegD; }
   virtual const Type *Value( PhaseTransform *phase ) const;
 };
 //-------------------------------ReverseBytesINode--------------------------------
 // reverse bytes of an integer
 class ReverseBytesINode : public Node {
 public:
   ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 //-------------------------------ReverseBytesLNode--------------------------------
 // reverse bytes of a long
 class ReverseBytesLNode : public Node {
 public:
   ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {}
   virtual int Opcode() const;
   const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
 };

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/opto/subnode.hpp@bd441136a5ce (annotated)

src/share/vm/opto/subnode.hpp