Mercurial > hg > truffle
view src/share/vm/opto/subnode.hpp @ 4445:e2a477f9791b
changed visual studio build directories to match mx build
author | Christian Haeubl <christian.haeubl@oracle.com> |
---|---|
date | Tue, 24 Jan 2012 23:47:20 -0800 |
parents | f1d6640088a1 |
children | ae9241bbce4a |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_OPTO_SUBNODE_HPP #define SHARE_VM_OPTO_SUBNODE_HPP #include "opto/node.hpp" #include "opto/opcodes.hpp" #include "opto/type.hpp" // 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; 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; 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; } }; //-------------------------------ReverseBytesUSNode-------------------------------- // reverse bytes of an unsigned short / char class ReverseBytesUSNode : public Node { public: ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} virtual int Opcode() const; const Type *bottom_type() const { return TypeInt::CHAR; } virtual uint ideal_reg() const { return Op_RegI; } }; //-------------------------------ReverseBytesSNode-------------------------------- // reverse bytes of a short class ReverseBytesSNode : public Node { public: ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} virtual int Opcode() const; const Type *bottom_type() const { return TypeInt::SHORT; } virtual uint ideal_reg() const { return Op_RegI; } }; #endif // SHARE_VM_OPTO_SUBNODE_HPP