# HG changeset patch
# User shade
# Date 1458909343 -10800
# Node ID bfcdf736a9986b157a0cea3bdc86b9bb6e29b3b6
# Parent  9a10a2c4dc133af582a825be66a0d76aff3d18c3
8152698: Remove obsolete Unsafe.putOrdered{X} methods, usages, runtime and compiler support
Reviewed-by: kvn, psandoz, dl

diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/CompletableFuture.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/CompletableFuture.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/CompletableFuture.java	Fri Mar 25 15:35:43 2016 +0300
@@ -480,7 +480,7 @@
     }
 
     static void lazySetNext(Completion c, Completion next) {
-        U.putOrderedObject(c, NEXT, next);
+        U.putObjectRelease(c, NEXT, next);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java	Fri Mar 25 15:35:43 2016 +0300
@@ -309,7 +309,7 @@
         }
 
         void lazySetNext(Node<E> val) {
-            U.putOrderedObject(this, NEXT, val);
+            U.putObjectRelease(this, NEXT, val);
         }
 
         boolean casNext(Node<E> cmp, Node<E> val) {
@@ -317,7 +317,7 @@
         }
 
         void lazySetPrev(Node<E> val) {
-            U.putOrderedObject(this, PREV, val);
+            U.putObjectRelease(this, PREV, val);
         }
 
         boolean casPrev(Node<E> cmp, Node<E> val) {
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedQueue.java	Fri Mar 25 15:35:43 2016 +0300
@@ -198,7 +198,7 @@
     }
 
     static <E> void lazySetNext(Node<E> node, Node<E> val) {
-        U.putOrderedObject(node, NEXT, val);
+        U.putObjectRelease(node, NEXT, val);
     }
 
     static <E> boolean casNext(Node<E> node, Node<E> cmp, Node<E> val) {
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/Exchanger.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/Exchanger.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/Exchanger.java	Fri Mar 25 15:35:43 2016 +0300
@@ -239,7 +239,7 @@
      * not to be as readily inlined by dynamic compilers when they are
      * hidden behind other methods that would more nicely name and
      * encapsulate the intended effects). This includes the use of
-     * putOrderedX to clear fields of the per-thread Nodes between
+     * putXRelease to clear fields of the per-thread Nodes between
      * uses. Note that field Node.item is not declared as volatile
      * even though it is read by releasing threads, because they only
      * do so after CAS operations that must precede access, and all
@@ -376,7 +376,7 @@
                     for (int h = p.hash, spins = SPINS;;) {
                         Object v = p.match;
                         if (v != null) {
-                            U.putOrderedObject(p, MATCH, null);
+                            U.putObjectRelease(p, MATCH, null);
                             p.item = null;             // clear for next use
                             p.hash = h;
                             return v;
@@ -507,7 +507,7 @@
                 break;
             }
         }
-        U.putOrderedObject(p, MATCH, null);
+        U.putObjectRelease(p, MATCH, null);
         p.item = null;
         p.hash = h;
         return v;
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinPool.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinPool.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinPool.java	Fri Mar 25 15:35:43 2016 +0300
@@ -289,7 +289,7 @@
      * on to try or create other queues -- they block only when
      * creating and registering new queues. Because it is used only as
      * a spinlock, unlocking requires only a "releasing" store (using
-     * putOrderedInt).  The qlock is also used during termination
+     * putIntRelease).  The qlock is also used during termination
      * detection, in which case it is forced to a negative
      * non-lockable value.
      *
@@ -1071,7 +1071,7 @@
                         popped = true;
                         top = s;
                     }
-                    U.putOrderedInt(this, QLOCK, 0);
+                    U.putIntRelease(this, QLOCK, 0);
                 }
             }
             return popped;
@@ -1261,7 +1261,7 @@
                                         popped = true;
                                         top = s - 1;
                                     }
-                                    U.putOrderedInt(this, QLOCK, 0);
+                                    U.putIntRelease(this, QLOCK, 0);
                                     if (popped)
                                         return t;
                                 }
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinWorkerThread.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinWorkerThread.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/ForkJoinWorkerThread.java	Fri Mar 25 15:35:43 2016 +0300
@@ -92,7 +92,7 @@
     ForkJoinWorkerThread(ForkJoinPool pool, ThreadGroup threadGroup,
                          AccessControlContext acc) {
         super(threadGroup, null, "aForkJoinWorkerThread");
-        U.putOrderedObject(this, INHERITEDACCESSCONTROLCONTEXT, acc);
+        U.putObjectRelease(this, INHERITEDACCESSCONTROLCONTEXT, acc);
         eraseThreadLocals(); // clear before registering
         this.pool = pool;
         this.workQueue = pool.registerWorker(this);
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/FutureTask.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/FutureTask.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/FutureTask.java	Fri Mar 25 15:35:43 2016 +0300
@@ -174,7 +174,7 @@
                     if (t != null)
                         t.interrupt();
                 } finally { // final state
-                    U.putOrderedInt(this, STATE, INTERRUPTED);
+                    U.putIntRelease(this, STATE, INTERRUPTED);
                 }
             }
         } finally {
@@ -230,7 +230,7 @@
     protected void set(V v) {
         if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
             outcome = v;
-            U.putOrderedInt(this, STATE, NORMAL); // final state
+            U.putIntRelease(this, STATE, NORMAL); // final state
             finishCompletion();
         }
     }
@@ -248,7 +248,7 @@
     protected void setException(Throwable t) {
         if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
             outcome = t;
-            U.putOrderedInt(this, STATE, EXCEPTIONAL); // final state
+            U.putIntRelease(this, STATE, EXCEPTIONAL); // final state
             finishCompletion();
         }
     }
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/SubmissionPublisher.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/SubmissionPublisher.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/SubmissionPublisher.java	Fri Mar 25 15:35:43 2016 +0300
@@ -1496,7 +1496,7 @@
                     else if (((c & CONSUME) != 0 ||
                               U.compareAndSwapInt(this, CTL, c, c | CONSUME)) &&
                              U.compareAndSwapObject(a, i, x, null)) {
-                        U.putOrderedInt(this, HEAD, ++h);
+                        U.putIntRelease(this, HEAD, ++h);
                         U.getAndAddLong(this, DEMAND, -1L);
                         if ((w = waiter) != null)
                             signalWaiter(w);
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicBoolean.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicBoolean.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicBoolean.java	Fri Mar 25 15:35:43 2016 +0300
@@ -136,7 +136,7 @@
      * @since 1.6
      */
     public final void lazySet(boolean newValue) {
-        U.putOrderedInt(this, VALUE, (newValue ? 1 : 0));
+        U.putIntRelease(this, VALUE, (newValue ? 1 : 0));
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicInteger.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicInteger.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicInteger.java	Fri Mar 25 15:35:43 2016 +0300
@@ -108,7 +108,7 @@
      * @since 1.6
      */
     public final void lazySet(int newValue) {
-        U.putOrderedInt(this, VALUE, newValue);
+        U.putIntRelease(this, VALUE, newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerArray.java	Fri Mar 25 15:35:43 2016 +0300
@@ -136,7 +136,7 @@
      * @since 1.6
      */
     public final void lazySet(int i, int newValue) {
-        U.putOrderedInt(array, checkedByteOffset(i), newValue);
+        U.putIntRelease(array, checkedByteOffset(i), newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java	Fri Mar 25 15:35:43 2016 +0300
@@ -475,7 +475,7 @@
 
         public final void lazySet(T obj, int newValue) {
             accessCheck(obj);
-            U.putOrderedInt(obj, offset, newValue);
+            U.putIntRelease(obj, offset, newValue);
         }
 
         public final int get(T obj) {
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLong.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLong.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLong.java	Fri Mar 25 15:35:43 2016 +0300
@@ -124,7 +124,7 @@
      * @since 1.6
      */
     public final void lazySet(long newValue) {
-        U.putOrderedLong(this, VALUE, newValue);
+        U.putLongRelease(this, VALUE, newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongArray.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongArray.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongArray.java	Fri Mar 25 15:35:43 2016 +0300
@@ -135,7 +135,7 @@
      * @since 1.6
      */
     public final void lazySet(int i, long newValue) {
-        U.putOrderedLong(array, checkedByteOffset(i), newValue);
+        U.putLongRelease(array, checkedByteOffset(i), newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicLongFieldUpdater.java	Fri Mar 25 15:35:43 2016 +0300
@@ -457,7 +457,7 @@
 
         public final void lazySet(T obj, long newValue) {
             accessCheck(obj);
-            U.putOrderedLong(obj, offset, newValue);
+            U.putLongRelease(obj, offset, newValue);
         }
 
         public final long get(T obj) {
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReference.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReference.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReference.java	Fri Mar 25 15:35:43 2016 +0300
@@ -103,7 +103,7 @@
      * @since 1.6
      */
     public final void lazySet(V newValue) {
-        U.putOrderedObject(this, VALUE, newValue);
+        U.putObjectRelease(this, VALUE, newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java	Fri Mar 25 15:35:43 2016 +0300
@@ -147,7 +147,7 @@
      * @since 1.6
      */
     public final void lazySet(int i, E newValue) {
-        U.putOrderedObject(array, checkedByteOffset(i), newValue);
+        U.putObjectRelease(array, checkedByteOffset(i), newValue);
     }
 
     /**
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
--- a/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java	Fri Mar 25 15:35:43 2016 +0300
@@ -426,7 +426,7 @@
         public final void lazySet(T obj, V newValue) {
             accessCheck(obj);
             valueCheck(newValue);
-            U.putOrderedObject(obj, offset, newValue);
+            U.putObjectRelease(obj, offset, newValue);
         }
 
         @SuppressWarnings("unchecked")
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/jdk/internal/misc/InnocuousThread.java
--- a/jdk/src/java.base/share/classes/jdk/internal/misc/InnocuousThread.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/jdk/internal/misc/InnocuousThread.java	Fri Mar 25 15:35:43 2016 +0300
@@ -57,8 +57,8 @@
 
     public InnocuousThread(ThreadGroup group, Runnable target, String name) {
         super(group, target, name, 0L, false);
-        UNSAFE.putOrderedObject(this, INHERITEDACCESSCONTROLCONTEXT, ACC);
-        UNSAFE.putOrderedObject(this, CONTEXTCLASSLOADER, ClassLoader.getSystemClassLoader());
+        UNSAFE.putObjectRelease(this, INHERITEDACCESSCONTROLCONTEXT, ACC);
+        UNSAFE.putObjectRelease(this, CONTEXTCLASSLOADER, ClassLoader.getSystemClassLoader());
     }
 
     @Override
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/jdk/internal/misc/Unsafe.java
--- a/jdk/src/java.base/share/classes/jdk/internal/misc/Unsafe.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/jdk/internal/misc/Unsafe.java	Fri Mar 25 15:35:43 2016 +0300
@@ -1457,25 +1457,7 @@
     @HotSpotIntrinsicCandidate
     public native void    putDoubleVolatile(Object o, long offset, double x);
 
-    /**
-     * Version of {@link #putObjectVolatile(Object, long, Object)}
-     * that does not guarantee immediate visibility of the store to
-     * other threads. This method is generally only useful if the
-     * underlying field is a Java volatile (or if an array cell, one
-     * that is otherwise only accessed using volatile accesses).
-     *
-     * Corresponds to C11 atomic_store_explicit(..., memory_order_release).
-     */
-    @HotSpotIntrinsicCandidate
-    public native void    putOrderedObject(Object o, long offset, Object x);
 
-    /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
-    @HotSpotIntrinsicCandidate
-    public native void    putOrderedInt(Object o, long offset, int x);
-
-    /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
-    @HotSpotIntrinsicCandidate
-    public native void    putOrderedLong(Object o, long offset, long x);
 
     /** Acquire version of {@link #getObjectVolatile(Object, long)} */
     @HotSpotIntrinsicCandidate
@@ -1531,6 +1513,16 @@
         return getDoubleVolatile(o, offset);
     }
 
+    /*
+      * Versions of {@link #putObjectVolatile(Object, long, Object)}
+      * that do not guarantee immediate visibility of the store to
+      * other threads. This method is generally only useful if the
+      * underlying field is a Java volatile (or if an array cell, one
+      * that is otherwise only accessed using volatile accesses).
+      *
+      * Corresponds to C11 atomic_store_explicit(..., memory_order_release).
+      */
+
     /** Release version of {@link #putObjectVolatile(Object, long, Object)} */
     @HotSpotIntrinsicCandidate
     public final void putObjectRelease(Object o, long offset, Object x) {
diff -r 9a10a2c4dc13 -r bfcdf736a998 jdk/src/java.base/share/classes/sun/misc/Unsafe.java
--- a/jdk/src/java.base/share/classes/sun/misc/Unsafe.java	Thu Mar 24 16:21:19 2016 +0100
+++ b/jdk/src/java.base/share/classes/sun/misc/Unsafe.java	Fri Mar 25 15:35:43 2016 +0300
@@ -1068,19 +1068,19 @@
      */
     @ForceInline
     public void putOrderedObject(Object o, long offset, Object x) {
-        theInternalUnsafe.putOrderedObject(o, offset, x);
+        theInternalUnsafe.putObjectRelease(o, offset, x);
     }
 
     /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
     @ForceInline
     public void putOrderedInt(Object o, long offset, int x) {
-        theInternalUnsafe.putOrderedInt(o, offset, x);
+        theInternalUnsafe.putIntRelease(o, offset, x);
     }
 
     /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
     @ForceInline
     public void putOrderedLong(Object o, long offset, long x) {
-        theInternalUnsafe.putOrderedLong(o, offset, x);
+        theInternalUnsafe.putLongRelease(o, offset, x);
     }
 
     /**