Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/opto/memnode.hpp
changeset 36316 7a83de7aabca
parent 35551 36ef3841fb34
child 36554 a7eb9ee4680c
equal deleted inserted replaced
36315:150a415079ae 36316:7a83de7aabca 
    54          ValueIn,               // Value to store
 
    54          ValueIn,               // Value to store
 
    55          OopStore               // Preceeding oop store, only in StoreCM
 
    55          OopStore               // Preceeding oop store, only in StoreCM
 
    56   };
 
    56   };
 
    57   typedef enum { unordered = 0,
 
    57   typedef enum { unordered = 0,
 
    58                  acquire,       // Load has to acquire or be succeeded by MemBarAcquire.
 
    58                  acquire,       // Load has to acquire or be succeeded by MemBarAcquire.
 
    59                  release        // Store has to release or be preceded by MemBarRelease.
 
    59                  release,       // Store has to release or be preceded by MemBarRelease.
 
       
    60                  seqcst,        // LoadStore has to have both acquire and release semantics.
 
       
    61                  unset          // The memory ordering is not set (used for testing)
 
    60   } MemOrd;
 
    62   } MemOrd;
 
    61 protected:
 
    63 protected:
 
    62   MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at )
 
    64   MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at )
 
    63     : Node(c0,c1,c2   ), _unaligned_access(false), _mismatched_access(false) {
 
    65     : Node(c0,c1,c2   ), _unaligned_access(false), _mismatched_access(false) {
 
    64     init_class_id(Class_Mem);
 
    66     init_class_id(Class_Mem);
 
   846   virtual int Opcode() const;
 
   848   virtual int Opcode() const;
 
   847   // Produces flags
 
   849   // Produces flags
 
   848   virtual uint ideal_reg() const { return Op_RegFlags; }
 
   850   virtual uint ideal_reg() const { return Op_RegFlags; }
 
   849 };
 
   851 };
 
   850 
   852 
       
   853 class CompareAndSwapNode : public LoadStoreConditionalNode {
 
       
   854 private:
 
       
   855   const MemNode::MemOrd _mem_ord;
 
       
   856 public:
 
       
   857   CompareAndSwapNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : LoadStoreConditionalNode(c, mem, adr, val, ex), _mem_ord(mem_ord) {}
 
       
   858   MemNode::MemOrd order() const {
 
       
   859     return _mem_ord;
 
       
   860   }
 
       
   861 };
 
       
   862 
       
   863 class CompareAndExchangeNode : public LoadStoreNode {
 
       
   864 private:
 
       
   865   const MemNode::MemOrd _mem_ord;
 
       
   866 public:
 
       
   867   enum {
 
       
   868     ExpectedIn = MemNode::ValueIn+1 // One more input than MemNode
 
       
   869   };
 
       
   870   CompareAndExchangeNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord, const TypePtr* at, const Type* t) :
 
       
   871     LoadStoreNode(c, mem, adr, val, at, t, 5), _mem_ord(mem_ord) {
 
       
   872      init_req(ExpectedIn, ex );
 
       
   873   }
 
       
   874 
       
   875   MemNode::MemOrd order() const {
 
       
   876     return _mem_ord;
 
       
   877   }
 
       
   878 };
 
   851 
   879 
   852 //------------------------------CompareAndSwapLNode---------------------------
 
   880 //------------------------------CompareAndSwapLNode---------------------------
 
   853 class CompareAndSwapLNode : public LoadStoreConditionalNode {
 
   881 class CompareAndSwapLNode : public CompareAndSwapNode {
 
   854 public:
 
   882 public:
 
   855   CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
 
   883   CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
   856   virtual int Opcode() const;
 
   884   virtual int Opcode() const;
 
   857 };
 
   885 };
 
   858 
   886 
   859 
   887 
   860 //------------------------------CompareAndSwapINode---------------------------
 
   888 //------------------------------CompareAndSwapINode---------------------------
 
   861 class CompareAndSwapINode : public LoadStoreConditionalNode {
 
   889 class CompareAndSwapINode : public CompareAndSwapNode {
 
   862 public:
 
   890 public:
 
   863   CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
 
   891   CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
   864   virtual int Opcode() const;
 
   892   virtual int Opcode() const;
 
   865 };
 
   893 };
 
   866 
   894 
   867 
   895 
   868 //------------------------------CompareAndSwapPNode---------------------------
 
   896 //------------------------------CompareAndSwapPNode---------------------------
 
   869 class CompareAndSwapPNode : public LoadStoreConditionalNode {
 
   897 class CompareAndSwapPNode : public CompareAndSwapNode {
 
   870 public:
 
   898 public:
 
   871   CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
 
   899   CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
   872   virtual int Opcode() const;
 
   900   virtual int Opcode() const;
 
   873 };
 
   901 };
 
   874 
   902 
   875 //------------------------------CompareAndSwapNNode---------------------------
 
   903 //------------------------------CompareAndSwapNNode---------------------------
 
   876 class CompareAndSwapNNode : public LoadStoreConditionalNode {
 
   904 class CompareAndSwapNNode : public CompareAndSwapNode {
 
   877 public:
 
   905 public:
 
   878   CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
 
   906   CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
       
   907   virtual int Opcode() const;
 
       
   908 };
 
       
   909 
       
   910 
       
   911 //------------------------------WeakCompareAndSwapLNode---------------------------
 
       
   912 class WeakCompareAndSwapLNode : public CompareAndSwapNode {
 
       
   913 public:
 
       
   914   WeakCompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
       
   915   virtual int Opcode() const;
 
       
   916 };
 
       
   917 
       
   918 
       
   919 //------------------------------WeakCompareAndSwapINode---------------------------
 
       
   920 class WeakCompareAndSwapINode : public CompareAndSwapNode {
 
       
   921 public:
 
       
   922   WeakCompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
       
   923   virtual int Opcode() const;
 
       
   924 };
 
       
   925 
       
   926 
       
   927 //------------------------------WeakCompareAndSwapPNode---------------------------
 
       
   928 class WeakCompareAndSwapPNode : public CompareAndSwapNode {
 
       
   929 public:
 
       
   930   WeakCompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
       
   931   virtual int Opcode() const;
 
       
   932 };
 
       
   933 
       
   934 //------------------------------WeakCompareAndSwapNNode---------------------------
 
       
   935 class WeakCompareAndSwapNNode : public CompareAndSwapNode {
 
       
   936 public:
 
       
   937   WeakCompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { }
 
       
   938   virtual int Opcode() const;
 
       
   939 };
 
       
   940 
       
   941 //------------------------------CompareAndExchangeLNode---------------------------
 
       
   942 class CompareAndExchangeLNode : public CompareAndExchangeNode {
 
       
   943 public:
 
       
   944   CompareAndExchangeLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeLong::LONG) { }
 
       
   945   virtual int Opcode() const;
 
       
   946 };
 
       
   947 
       
   948 
       
   949 //------------------------------CompareAndExchangeINode---------------------------
 
       
   950 class CompareAndExchangeINode : public CompareAndExchangeNode {
 
       
   951 public:
 
       
   952   CompareAndExchangeINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::INT) { }
 
       
   953   virtual int Opcode() const;
 
       
   954 };
 
       
   955 
       
   956 
       
   957 //------------------------------CompareAndExchangePNode---------------------------
 
       
   958 class CompareAndExchangePNode : public CompareAndExchangeNode {
 
       
   959 public:
 
       
   960   CompareAndExchangePNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { }
 
       
   961   virtual int Opcode() const;
 
       
   962 };
 
       
   963 
       
   964 //------------------------------CompareAndExchangeNNode---------------------------
 
       
   965 class CompareAndExchangeNNode : public CompareAndExchangeNode {
 
       
   966 public:
 
       
   967   CompareAndExchangeNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { }
 
   879   virtual int Opcode() const;
 
   968   virtual int Opcode() const;
 
   880 };
 
   969 };
 
   881 
   970 
   882 //------------------------------GetAndAddINode---------------------------
 
   971 //------------------------------GetAndAddINode---------------------------
 
   883 class GetAndAddINode : public LoadStoreNode {
 
   972 class GetAndAddINode : public LoadStoreNode {
jdk-sandbox