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 { |