Mercurial > jdk8-mips64-public > hotspot / file comparison
comparison: src/share/vm/opto/memnode.hpp
src/share/vm/opto/memnode.hpp
- changeset 4106
- 7eca5de9e0b6
- parent 3846
- 8b0a4867acf0
- child 4153
- b9a9ed0f8eeb
- child 4159
- 8e47bac5643a
equal
deleted
inserted
replaced
| 4105:8ae8f9dd7099 | 4106:7eca5de9e0b6 |
|---|---|
| 655 }; | 655 }; |
| 656 | 656 |
| 657 //------------------------------LoadStoreNode--------------------------- | 657 //------------------------------LoadStoreNode--------------------------- |
| 658 // Note: is_Mem() method returns 'true' for this class. | 658 // Note: is_Mem() method returns 'true' for this class. |
| 659 class LoadStoreNode : public Node { | 659 class LoadStoreNode : public Node { |
| 660 private: | |
| 661 const Type* const _type; // What kind of value is loaded? | |
| 662 const TypePtr* _adr_type; // What kind of memory is being addressed? | |
| 663 virtual uint size_of() const; // Size is bigger | |
| 664 public: | |
| 665 LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required ); | |
| 666 virtual bool depends_only_on_test() const { return false; } | |
| 667 virtual uint match_edge(uint idx) const { return idx == MemNode::Address || idx == MemNode::ValueIn; } | |
| 668 | |
| 669 virtual const Type *bottom_type() const { return _type; } | |
| 670 virtual uint ideal_reg() const; | |
| 671 virtual const class TypePtr *adr_type() const { return _adr_type; } // returns bottom_type of address | |
| 672 | |
| 673 bool result_not_used() const; | |
| 674 }; | |
| 675 | |
| 676 class LoadStoreConditionalNode : public LoadStoreNode { | |
| 660 public: | 677 public: |
| 661 enum { | 678 enum { |
| 662 ExpectedIn = MemNode::ValueIn+1 // One more input than MemNode | 679 ExpectedIn = MemNode::ValueIn+1 // One more input than MemNode |
| 663 }; | 680 }; |
| 664 LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex); | 681 LoadStoreConditionalNode(Node *c, Node *mem, Node *adr, Node *val, Node *ex); |
| 665 virtual bool depends_only_on_test() const { return false; } | |
| 666 virtual const Type *bottom_type() const { return TypeInt::BOOL; } | |
| 667 virtual uint ideal_reg() const { return Op_RegI; } | |
| 668 virtual uint match_edge(uint idx) const { return idx == MemNode::Address || idx == MemNode::ValueIn; } | |
| 669 }; | 682 }; |
| 670 | 683 |
| 671 //------------------------------StorePConditionalNode--------------------------- | 684 //------------------------------StorePConditionalNode--------------------------- |
| 672 // Conditionally store pointer to memory, if no change since prior | 685 // Conditionally store pointer to memory, if no change since prior |
| 673 // load-locked. Sets flags for success or failure of the store. | 686 // load-locked. Sets flags for success or failure of the store. |
| 674 class StorePConditionalNode : public LoadStoreNode { | 687 class StorePConditionalNode : public LoadStoreConditionalNode { |
| 675 public: | 688 public: |
| 676 StorePConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreNode(c, mem, adr, val, ll) { } | 689 StorePConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } |
| 677 virtual int Opcode() const; | 690 virtual int Opcode() const; |
| 678 // Produces flags | 691 // Produces flags |
| 679 virtual uint ideal_reg() const { return Op_RegFlags; } | 692 virtual uint ideal_reg() const { return Op_RegFlags; } |
| 680 }; | 693 }; |
| 681 | 694 |
| 682 //------------------------------StoreIConditionalNode--------------------------- | 695 //------------------------------StoreIConditionalNode--------------------------- |
| 683 // Conditionally store int to memory, if no change since prior | 696 // Conditionally store int to memory, if no change since prior |
| 684 // load-locked. Sets flags for success or failure of the store. | 697 // load-locked. Sets flags for success or failure of the store. |
| 685 class StoreIConditionalNode : public LoadStoreNode { | 698 class StoreIConditionalNode : public LoadStoreConditionalNode { |
| 686 public: | 699 public: |
| 687 StoreIConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ii ) : LoadStoreNode(c, mem, adr, val, ii) { } | 700 StoreIConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ii ) : LoadStoreConditionalNode(c, mem, adr, val, ii) { } |
| 688 virtual int Opcode() const; | 701 virtual int Opcode() const; |
| 689 // Produces flags | 702 // Produces flags |
| 690 virtual uint ideal_reg() const { return Op_RegFlags; } | 703 virtual uint ideal_reg() const { return Op_RegFlags; } |
| 691 }; | 704 }; |
| 692 | 705 |
| 693 //------------------------------StoreLConditionalNode--------------------------- | 706 //------------------------------StoreLConditionalNode--------------------------- |
| 694 // Conditionally store long to memory, if no change since prior | 707 // Conditionally store long to memory, if no change since prior |
| 695 // load-locked. Sets flags for success or failure of the store. | 708 // load-locked. Sets flags for success or failure of the store. |
| 696 class StoreLConditionalNode : public LoadStoreNode { | 709 class StoreLConditionalNode : public LoadStoreConditionalNode { |
| 697 public: | 710 public: |
| 698 StoreLConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreNode(c, mem, adr, val, ll) { } | 711 StoreLConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } |
| 699 virtual int Opcode() const; | 712 virtual int Opcode() const; |
| 700 // Produces flags | 713 // Produces flags |
| 701 virtual uint ideal_reg() const { return Op_RegFlags; } | 714 virtual uint ideal_reg() const { return Op_RegFlags; } |
| 702 }; | 715 }; |
| 703 | 716 |
| 704 | 717 |
| 705 //------------------------------CompareAndSwapLNode--------------------------- | 718 //------------------------------CompareAndSwapLNode--------------------------- |
| 706 class CompareAndSwapLNode : public LoadStoreNode { | 719 class CompareAndSwapLNode : public LoadStoreConditionalNode { |
| 707 public: | 720 public: |
| 708 CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | 721 CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { } |
| 709 virtual int Opcode() const; | 722 virtual int Opcode() const; |
| 710 }; | 723 }; |
| 711 | 724 |
| 712 | 725 |
| 713 //------------------------------CompareAndSwapINode--------------------------- | 726 //------------------------------CompareAndSwapINode--------------------------- |
| 714 class CompareAndSwapINode : public LoadStoreNode { | 727 class CompareAndSwapINode : public LoadStoreConditionalNode { |
| 715 public: | 728 public: |
| 716 CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | 729 CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { } |
| 717 virtual int Opcode() const; | 730 virtual int Opcode() const; |
| 718 }; | 731 }; |
| 719 | 732 |
| 720 | 733 |
| 721 //------------------------------CompareAndSwapPNode--------------------------- | 734 //------------------------------CompareAndSwapPNode--------------------------- |
| 722 class CompareAndSwapPNode : public LoadStoreNode { | 735 class CompareAndSwapPNode : public LoadStoreConditionalNode { |
| 723 public: | 736 public: |
| 724 CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | 737 CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { } |
| 725 virtual int Opcode() const; | 738 virtual int Opcode() const; |
| 726 }; | 739 }; |
| 727 | 740 |
| 728 //------------------------------CompareAndSwapNNode--------------------------- | 741 //------------------------------CompareAndSwapNNode--------------------------- |
| 729 class CompareAndSwapNNode : public LoadStoreNode { | 742 class CompareAndSwapNNode : public LoadStoreConditionalNode { |
| 730 public: | 743 public: |
| 731 CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | 744 CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { } |
| 745 virtual int Opcode() const; | |
| 746 }; | |
| 747 | |
| 748 //------------------------------GetAndAddINode--------------------------- | |
| 749 class GetAndAddINode : public LoadStoreNode { | |
| 750 public: | |
| 751 GetAndAddINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } | |
| 752 virtual int Opcode() const; | |
| 753 }; | |
| 754 | |
| 755 //------------------------------GetAndAddLNode--------------------------- | |
| 756 class GetAndAddLNode : public LoadStoreNode { | |
| 757 public: | |
| 758 GetAndAddLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } | |
| 759 virtual int Opcode() const; | |
| 760 }; | |
| 761 | |
| 762 | |
| 763 //------------------------------GetAndSetINode--------------------------- | |
| 764 class GetAndSetINode : public LoadStoreNode { | |
| 765 public: | |
| 766 GetAndSetINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } | |
| 767 virtual int Opcode() const; | |
| 768 }; | |
| 769 | |
| 770 //------------------------------GetAndSetINode--------------------------- | |
| 771 class GetAndSetLNode : public LoadStoreNode { | |
| 772 public: | |
| 773 GetAndSetLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } | |
| 774 virtual int Opcode() const; | |
| 775 }; | |
| 776 | |
| 777 //------------------------------GetAndSetPNode--------------------------- | |
| 778 class GetAndSetPNode : public LoadStoreNode { | |
| 779 public: | |
| 780 GetAndSetPNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } | |
| 781 virtual int Opcode() const; | |
| 782 }; | |
| 783 | |
| 784 //------------------------------GetAndSetNNode--------------------------- | |
| 785 class GetAndSetNNode : public LoadStoreNode { | |
| 786 public: | |
| 787 GetAndSetNNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } | |
| 732 virtual int Opcode() const; | 788 virtual int Opcode() const; |
| 733 }; | 789 }; |
| 734 | 790 |
| 735 //------------------------------ClearArray------------------------------------- | 791 //------------------------------ClearArray------------------------------------- |
| 736 class ClearArrayNode: public Node { | 792 class ClearArrayNode: public Node { |
