< prev index next >

src/share/vm/opto/subnode.hpp

Print this page

        

*** 67,95 **** //------------------------------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 --- 67,95 ---- //------------------------------SubINode--------------------------------------- // Subtract 2 integers class SubINode : public SubNode { public: SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} ! virtual Opcodes 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 Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; //------------------------------SubLNode--------------------------------------- // Subtract 2 integers class SubLNode : public SubNode { public: SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} ! virtual Opcodes 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 Opcodes ideal_reg() const { return Opcodes::Op_RegL; } }; // NOTE: SubFPNode should be taken away and replaced by add and negate //------------------------------SubFPNode-------------------------------------- // Subtract 2 floats or doubles
*** 104,133 **** //------------------------------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 { --- 104,133 ---- //------------------------------SubFNode--------------------------------------- // Subtract 2 doubles class SubFNode : public SubFPNode { public: SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} ! virtual Opcodes 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 Opcodes ideal_reg() const { return Opcodes::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 Opcodes 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 Opcodes ideal_reg() const { return Opcodes::Op_RegD; } }; //------------------------------CmpNode--------------------------------------- // Compare 2 values, returning condition codes (-1, 0 or 1). class CmpNode : public SubNode {
*** 136,146 **** init_class_id(Class_Cmp); } virtual Node* Identity(PhaseGVN* 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; } #ifndef PRODUCT // CmpNode and subclasses include all data inputs (until hitting a control // boundary) in their related node set, as well as all outputs until and // including eventual control nodes and their projections. --- 136,146 ---- init_class_id(Class_Cmp); } virtual Node* Identity(PhaseGVN* phase); const Type *add_id() const { return TypeInt::ZERO; } const Type *bottom_type() const { return TypeInt::CC; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegFlags; } #ifndef PRODUCT // CmpNode and subclasses include all data inputs (until hitting a control // boundary) in their related node set, as well as all outputs until and // including eventual control nodes and their projections.
*** 151,202 **** //------------------------------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; const Type* Value(PhaseGVN* phase) const; bool is_index_range_check() 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). --- 151,202 ---- //------------------------------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 Opcodes 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 Opcodes Opcode() const; virtual const Type *sub( const Type *, const Type * ) const; const Type* Value(PhaseGVN* phase) const; bool is_index_range_check() 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 Opcodes 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 Opcodes 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 Opcodes Opcode() const; virtual const Type *sub( const Type *, const Type * ) const; }; //------------------------------CmpL3Node-------------------------------------- // Compare 2 long values, returning integer value (-1, 0 or 1).
*** 204,225 **** 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(PhaseGVN* phase) const; }; //------------------------------CmpF3Node-------------------------------------- --- 204,225 ---- 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 Opcodes Opcode() const; ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } const Type* Value(PhaseGVN* phase) const; }; //------------------------------CmpF3Node--------------------------------------
*** 230,253 **** 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(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); }; --- 230,253 ---- 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 Opcodes Opcode() const; // Since it is not consumed by Bools, it is not really a Cmp. ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); };
*** 259,270 **** 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). --- 259,270 ---- 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 Opcodes Opcode() const; ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; //------------------------------BoolTest--------------------------------------- // Convert condition codes to a boolean test value (0 or -1).
*** 292,303 **** virtual uint hash() const; virtual uint cmp( const Node &n ) const; virtual uint size_of() const; // Try to optimize signed integer comparison ! Node* fold_cmpI(PhaseGVN* phase, SubNode* cmp, Node* cmp1, int cmp_op, ! int cmp1_op, const TypeInt* cmp2_type); public: const BoolTest _test; BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) { init_class_id(Class_Bool); } --- 292,303 ---- virtual uint hash() const; virtual uint cmp( const Node &n ) const; virtual uint size_of() const; // Try to optimize signed integer comparison ! Node* fold_cmpI(PhaseGVN* phase, SubNode* cmp, Node* cmp1, Opcodes cmp_op, ! Opcodes cmp1_op, const TypeInt* cmp2_type); public: const BoolTest _test; BoolNode( Node *cc, BoolTest::mask t): _test(t), Node(0,cc) { init_class_id(Class_Bool); }
*** 305,320 **** 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(PhaseGVN* 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; virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const; --- 305,320 ---- 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 Opcodes Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; virtual const Type *bottom_type() const { return TypeInt::BOOL; } uint match_edge(uint idx) const { return 0; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } bool is_counted_loop_exit_test(); #ifndef PRODUCT virtual void dump_spec(outputStream *st) const; virtual void related(GrowableArray<Node*> *in_rel, GrowableArray<Node*> *out_rel, bool compact) const;
*** 333,380 **** // 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 { --- 333,380 ---- // 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 Opcodes Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; const Type *bottom_type() const { return Type::FLOAT; } ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; //------------------------------NegNode---------------------------------------- class NegNode : public Node {
*** 388,423 **** // 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; } }; //------------------------------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 --- 388,423 ---- // 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 Opcodes Opcode() const; const Type *bottom_type() const { return Type::FLOAT; } ! virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; } }; //------------------------------AtanDNode-------------------------------------- // arcus tangens of a double class AtanDNode : public Node { public: AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; } }; //------------------------------SqrtDNode-------------------------------------- // square root a double
*** 425,476 **** public: SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { init_flags(Flag_is_expensive); C->add_expensive_node(this); } ! virtual int Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } ! virtual uint ideal_reg() const { return Op_RegD; } virtual const Type* Value(PhaseGVN* 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 --- 425,476 ---- public: SqrtDNode(Compile* C, Node *c, Node *in1) : Node(c, in1) { init_flags(Flag_is_expensive); C->add_expensive_node(this); } ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; } virtual const Type* Value(PhaseGVN* phase) const; }; //-------------------------------ReverseBytesINode-------------------------------- // reverse bytes of an integer class ReverseBytesINode : public Node { public: ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; //-------------------------------ReverseBytesLNode-------------------------------- // reverse bytes of a long class ReverseBytesLNode : public Node { public: ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return TypeLong::LONG; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegL; } }; //-------------------------------ReverseBytesUSNode-------------------------------- // reverse bytes of an unsigned short / char class ReverseBytesUSNode : public Node { public: ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return TypeInt::CHAR; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; //-------------------------------ReverseBytesSNode-------------------------------- // reverse bytes of a short class ReverseBytesSNode : public Node { public: ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} ! virtual Opcodes Opcode() const; const Type *bottom_type() const { return TypeInt::SHORT; } ! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; } }; #endif // SHARE_VM_OPTO_SUBNODE_HPP
< prev index next >