src/share/vm/opto/mathexactnode.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File
```*** old/src/share/vm/opto/mathexactnode.hpp	Fri Jan 31 10:27:25 2014
--- new/src/share/vm/opto/mathexactnode.hpp	Fri Jan 31 10:27:25 2014

*** 25,154 ****
--- 25,137 ----
#ifndef SHARE_VM_OPTO_MATHEXACTNODE_HPP
#define SHARE_VM_OPTO_MATHEXACTNODE_HPP

#include "opto/multnode.hpp"
#include "opto/node.hpp"
#include "opto/subnode.hpp"
#include "opto/type.hpp"

class BoolNode;
class IfNode;
class Node;

class PhaseGVN;
class PhaseTransform;

! class MathExactNode : public MultiNode {
! class OverflowNode : public CmpNode {
public:
!   MathExactNode(Node* ctrl, Node* in1);
MathExactNode(Node* ctrl, Node* in1, Node* in2);
enum {
result_proj_node = 0,
flags_proj_node = 1
};
virtual int Opcode() const;
virtual Node* Identity(PhaseTransform* phase) { return this; }
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape) { return NULL; }
virtual const Type* Value(PhaseTransform* phase) const { return bottom_type(); }
virtual uint hash() const { return NO_HASH; }
virtual bool is_CFG() const { return false; }
virtual uint ideal_reg() const { return NotAMachineReg; }
!   OverflowNode(Node* in1, Node* in2);
+   virtual uint ideal_reg() const { return Op_RegFlags; }
+   const Type* sub(const Type* t1, const Type* t2) const;

ProjNode* result_node() const { return proj_out(result_proj_node); }
ProjNode* flags_node() const { return proj_out(flags_proj_node); }
Node* control_node() const;
Node* non_throwing_branch() const;
protected:
IfNode* if_node() const;
BoolNode* bool_node() const;
Node* no_overflow(PhaseGVN *phase, Node* new_result);
};

! class MathExactINode : public MathExactNode {
public:
MathExactINode(Node* ctrl, Node* in1) : MathExactNode(ctrl, in1) {}
MathExactINode(Node* ctrl, Node* in1, Node* in2) : MathExactNode(ctrl, in1, in2) {}
virtual int Opcode() const;
virtual Node* match(const ProjNode* proj, const Matcher* m);
virtual const Type* bottom_type() const { return TypeTuple::INT_CC_PAIR; }
};

class MathExactLNode : public MathExactNode {
! class OverflowINode : public OverflowNode {
public:
MathExactLNode(Node* ctrl, Node* in1) : MathExactNode(ctrl, in1) {}
MathExactLNode(Node* ctrl, Node* in1, Node* in2) : MathExactNode(ctrl, in1, in2) {}
virtual int Opcode() const;
virtual Node* match(const ProjNode* proj, const Matcher* m);
virtual const Type* bottom_type() const { return TypeTuple::LONG_CC_PAIR; }
};
+   typedef TypeInt TypeClass;

class AddExactINode : public MathExactINode {
public:
AddExactINode(Node* ctrl, Node* in1, Node* in2) : MathExactINode(ctrl, in1, in2) {}
virtual int Opcode() const;
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
};
+   OverflowINode(Node* in1, Node* in2) : OverflowNode(in1, in2) {}
+   Node* Ideal(PhaseGVN* phase, bool can_reshape);
+   const Type* Value(PhaseTransform* phase) const;

class AddExactLNode : public MathExactLNode {
public:
AddExactLNode(Node* ctrl, Node* in1, Node* in2) : MathExactLNode(ctrl, in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+   virtual bool will_overflow(jint v1, jint v2) const = 0;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const = 0;
};

class SubExactINode : public MathExactINode {
+
+ class OverflowLNode : public OverflowNode {
public:
SubExactINode(Node* ctrl, Node* in1, Node* in2) : MathExactINode(ctrl, in1, in2) {}
virtual int Opcode() const;
+   typedef TypeLong TypeClass;
+
+   OverflowLNode(Node* in1, Node* in2) : OverflowNode(in1, in2) {}
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+   const Type* Value(PhaseTransform* phase) const;
+
+   virtual bool will_overflow(jlong v1, jlong v2) const = 0;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const = 0;
};

! class SubExactLNode : public MathExactLNode {
! class OverflowAddINode : public OverflowINode {
public:
SubExactLNode(Node* ctrl, Node* in1, Node* in2) : MathExactLNode(ctrl, in1, in2) {}
+
+   OverflowAddINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+
+   virtual bool will_overflow(jint v1, jint v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
};

! class NegExactINode : public MathExactINode {
! class OverflowSubINode : public OverflowINode {
public:
NegExactINode(Node* ctrl, Node* in1) : MathExactINode(ctrl, in1) {}
+   typedef SubINode MathOp;
+
+   OverflowSubINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+
+   virtual bool will_overflow(jint v1, jint v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
};

! class NegExactLNode : public MathExactLNode {
! class OverflowMulINode : public OverflowINode {
public:
NegExactLNode(Node* ctrl, Node* in1) : MathExactLNode(ctrl, in1) {}
+   typedef MulINode MathOp;
+
+   OverflowMulINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+
+   virtual bool will_overflow(jint v1, jint v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
};

! class MulExactINode : public MathExactINode {
! class OverflowAddLNode : public OverflowLNode {
public:
MulExactINode(Node* ctrl, Node* in1, Node* in2) : MathExactINode(ctrl, in1, in2) {}
+
+   OverflowAddLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+
+   virtual bool will_overflow(jlong v1, jlong v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
};

! class MulExactLNode : public MathExactLNode {
! class OverflowSubLNode : public OverflowLNode {
public:
MulExactLNode(Node* ctrl, Node* in1, Node* in2) : MathExactLNode(ctrl, in1, in2) {}
+   typedef SubLNode MathOp;
+
+   OverflowSubLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {}
virtual int Opcode() const;
virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
+
+   virtual bool will_overflow(jlong v1, jlong v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
};

! class FlagsProjNode : public ProjNode {
! class OverflowMulLNode : public OverflowLNode {
public:
FlagsProjNode(Node* src, uint con) : ProjNode(src, con) {
init_class_id(Class_FlagsProj);
}
+   typedef MulLNode MathOp;

+   OverflowMulLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {}
virtual int Opcode() const;
virtual bool is_CFG() const { return false; }
virtual const Type* bottom_type() const { return TypeInt::CC; }
virtual uint ideal_reg() const { return Op_RegFlags; }
};

+   virtual bool will_overflow(jlong v1, jlong v2) const;
+   virtual bool can_overflow(const Type* t1, const Type* t2) const;
+ };

#endif

```

src/share/vm/opto/mathexactnode.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File