< prev index next >
src/share/vm/opto/divnode.hpp
Print this page
*** 41,141 ****
// On processors which don't naturally support this special case (e.g., x86),
// the matcher or runtime system must take care of this.
class DivINode : public Node {
public:
DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
! virtual int Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return TypeInt::INT; }
! virtual uint ideal_reg() const { return Op_RegI; }
};
//------------------------------DivLNode---------------------------------------
// Long division
class DivLNode : public Node {
public:
DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
! virtual int Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return TypeLong::LONG; }
! virtual uint ideal_reg() const { return Op_RegL; }
};
//------------------------------DivFNode---------------------------------------
// Float division
class DivFNode : public Node {
public:
DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {}
! virtual int Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::FLOAT; }
! virtual uint ideal_reg() const { return Op_RegF; }
};
//------------------------------DivDNode---------------------------------------
// Double division
class DivDNode : public Node {
public:
DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {}
! virtual int Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::DOUBLE; }
! virtual uint ideal_reg() const { return Op_RegD; }
};
//------------------------------ModINode---------------------------------------
// Integer modulus
class ModINode : public Node {
public:
ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual int Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type *bottom_type() const { return TypeInt::INT; }
! virtual uint ideal_reg() const { return Op_RegI; }
};
//------------------------------ModLNode---------------------------------------
// Long modulus
class ModLNode : public Node {
public:
ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual int Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type *bottom_type() const { return TypeLong::LONG; }
! virtual uint ideal_reg() const { return Op_RegL; }
};
//------------------------------ModFNode---------------------------------------
// Float Modulus
class ModFNode : public Node {
public:
ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual int Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::FLOAT; }
! virtual uint ideal_reg() const { return Op_RegF; }
};
//------------------------------ModDNode---------------------------------------
// Double Modulus
class ModDNode : public Node {
public:
ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {}
! virtual int Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::DOUBLE; }
! virtual uint ideal_reg() const { return Op_RegD; }
};
//------------------------------DivModNode---------------------------------------
// Division with remainder result.
class DivModNode : public MultiNode {
--- 41,141 ----
// On processors which don't naturally support this special case (e.g., x86),
// the matcher or runtime system must take care of this.
class DivINode : public Node {
public:
DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
! virtual Opcodes Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return TypeInt::INT; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; }
};
//------------------------------DivLNode---------------------------------------
// Long division
class DivLNode : public Node {
public:
DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {}
! virtual Opcodes Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return TypeLong::LONG; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegL; }
};
//------------------------------DivFNode---------------------------------------
// Float division
class DivFNode : public Node {
public:
DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {}
! virtual Opcodes Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::FLOAT; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegF; }
};
//------------------------------DivDNode---------------------------------------
// Double division
class DivDNode : public Node {
public:
DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {}
! virtual Opcodes Opcode() const;
virtual Node* Identity(PhaseGVN* phase);
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::DOUBLE; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; }
};
//------------------------------ModINode---------------------------------------
// Integer modulus
class ModINode : public Node {
public:
ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual Opcodes Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type *bottom_type() const { return TypeInt::INT; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; }
};
//------------------------------ModLNode---------------------------------------
// Long modulus
class ModLNode : public Node {
public:
ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual Opcodes Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
virtual const Type *bottom_type() const { return TypeLong::LONG; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegL; }
};
//------------------------------ModFNode---------------------------------------
// Float Modulus
class ModFNode : public Node {
public:
ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {}
! virtual Opcodes Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::FLOAT; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegF; }
};
//------------------------------ModDNode---------------------------------------
// Double Modulus
class ModDNode : public Node {
public:
ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {}
! virtual Opcodes Opcode() const;
virtual const Type* Value(PhaseGVN* phase) const;
virtual const Type *bottom_type() const { return Type::DOUBLE; }
! virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; }
};
//------------------------------DivModNode---------------------------------------
// Division with remainder result.
class DivModNode : public MultiNode {
*** 144,171 ****
public:
enum {
div_proj_num = 0, // quotient
mod_proj_num = 1 // remainder
};
! virtual int Opcode() const;
virtual Node* Identity(PhaseGVN* phase) { return this; }
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; }
virtual const Type* Value(PhaseGVN* phase) const { return bottom_type(); }
virtual uint hash() const { return Node::hash(); }
virtual bool is_CFG() const { return false; }
! virtual uint ideal_reg() const { return NotAMachineReg; }
ProjNode* div_proj() { return proj_out(div_proj_num); }
ProjNode* mod_proj() { return proj_out(mod_proj_num); }
};
//------------------------------DivModINode---------------------------------------
// Integer division with remainder result.
class DivModINode : public DivModNode {
public:
DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
! virtual int Opcode() const;
virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; }
virtual Node *match( const ProjNode *proj, const Matcher *m );
// Make a divmod and associated projections from a div or mod.
static DivModINode* make(Node* div_or_mod);
--- 144,171 ----
public:
enum {
div_proj_num = 0, // quotient
mod_proj_num = 1 // remainder
};
! virtual Opcodes Opcode() const;
virtual Node* Identity(PhaseGVN* phase) { return this; }
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; }
virtual const Type* Value(PhaseGVN* phase) const { return bottom_type(); }
virtual uint hash() const { return Node::hash(); }
virtual bool is_CFG() const { return false; }
! virtual Opcodes ideal_reg() const { return Opcodes::NotAMachineReg; }
ProjNode* div_proj() { return proj_out(div_proj_num); }
ProjNode* mod_proj() { return proj_out(mod_proj_num); }
};
//------------------------------DivModINode---------------------------------------
// Integer division with remainder result.
class DivModINode : public DivModNode {
public:
DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
! virtual Opcodes Opcode() const;
virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; }
virtual Node *match( const ProjNode *proj, const Matcher *m );
// Make a divmod and associated projections from a div or mod.
static DivModINode* make(Node* div_or_mod);
*** 174,184 ****
//------------------------------DivModLNode---------------------------------------
// Long division with remainder result.
class DivModLNode : public DivModNode {
public:
DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
! virtual int Opcode() const;
virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; }
virtual Node *match( const ProjNode *proj, const Matcher *m );
// Make a divmod and associated projections from a div or mod.
static DivModLNode* make(Node* div_or_mod);
--- 174,184 ----
//------------------------------DivModLNode---------------------------------------
// Long division with remainder result.
class DivModLNode : public DivModNode {
public:
DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {}
! virtual Opcodes Opcode() const;
virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; }
virtual Node *match( const ProjNode *proj, const Matcher *m );
// Make a divmod and associated projections from a div or mod.
static DivModLNode* make(Node* div_or_mod);
< prev index next >