--- a/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/invoke/MethodHandles.java	Mon May 01 11:48:16 2017 -0700
@@ -1447,9 +1447,10 @@
         }
 
         /**
-         * Produces a VarHandle giving access to non-static fields of type
-         * {@code T} declared by a receiver class of type {@code R}, supporting
-         * shape {@code (R : T)}.
+         * Produces a VarHandle giving access to a non-static field {@code name}
+         * of type {@code type} declared in a class of type {@code recv}.
+         * The VarHandle's variable type is {@code type} and it has one
+         * coordinate type, {@code recv}.
          * <p>
          * Access checking is performed immediately on behalf of the lookup
          * class.
@@ -1472,7 +1473,7 @@
          * <p>
          * If the field is declared {@code volatile} then the returned VarHandle
          * will override access to the field (effectively ignore the
-         * {@code volatile} declaration) in accordance to it's specified
+         * {@code volatile} declaration) in accordance to its specified
          * access modes.
          * <p>
          * If the field type is {@code float} or {@code double} then numeric
@@ -1568,9 +1569,10 @@
         }
 
         /**
-         * Produces a VarHandle giving access to a static field of type
-         * {@code T} declared by a given declaring class, supporting shape
-         * {@code ((empty) : T)}.
+         * Produces a VarHandle giving access to a static field {@code name} of
+         * type {@code type} declared in a class of type {@code decl}.
+         * The VarHandle's variable type is {@code type} and it has no
+         * coordinate types.
          * <p>
          * Access checking is performed immediately on behalf of the lookup
          * class.
@@ -1596,7 +1598,7 @@
          * <p>
          * If the field is declared {@code volatile} then the returned VarHandle
          * will override access to the field (effectively ignore the
-         * {@code volatile} declaration) in accordance to it's specified
+         * {@code volatile} declaration) in accordance to its specified
          * access modes.
          * <p>
          * If the field type is {@code float} or {@code double} then numeric
@@ -1691,7 +1693,13 @@
         public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
             Class<? extends Object> refc = receiver.getClass(); // may get NPE
             MemberName method = resolveOrFail(REF_invokeSpecial, refc, name, type);
-            MethodHandle mh = getDirectMethodNoRestrict(REF_invokeSpecial, refc, method, findBoundCallerClass(method));
+            MethodHandle mh = getDirectMethodNoRestrictInvokeSpecial(refc, method, findBoundCallerClass(method));
+            if (!mh.type().leadingReferenceParameter().isAssignableFrom(receiver.getClass())) {
+                throw new IllegalAccessException("The restricted defining class " +
+                                                 mh.type().leadingReferenceParameter().getName() +
+                                                 " is not assignable from receiver class " +
+                                                 receiver.getClass().getName());
+            }
             return mh.bindArgumentL(0, receiver).setVarargs(method);
         }
 
@@ -1877,11 +1885,12 @@
         }
 
         /**
-         * Produces a VarHandle that accesses fields of type {@code T} declared
-         * by a class of type {@code R}, as described by the given reflected
-         * field.
-         * If the field is non-static the VarHandle supports a shape of
-         * {@code (R : T)}, otherwise supports a shape of {@code ((empty) : T)}.
+         * Produces a VarHandle giving access to a reflected field {@code f}
+         * of type {@code T} declared in a class of type {@code R}.
+         * The VarHandle's variable type is {@code T}.
+         * If the field is non-static the VarHandle has one coordinate type,
+         * {@code R}.  Otherwise, the field is static, and the VarHandle has no
+         * coordinate types.
          * <p>
          * Access checking is performed immediately on behalf of the lookup
          * class, regardless of the value of the field's {@code accessible}
@@ -1909,7 +1918,7 @@
          * <p>
          * If the field is declared {@code volatile} then the returned VarHandle
          * will override access to the field (effectively ignore the
-         * {@code volatile} declaration) in accordance to it's specified
+         * {@code volatile} declaration) in accordance to its specified
          * access modes.
          * <p>
          * If the field type is {@code float} or {@code double} then numeric
@@ -2240,7 +2249,7 @@
                 throw method.makeAccessException("caller class must be a subclass below the method", caller);
             }
             MethodType rawType = mh.type();
-            if (rawType.parameterType(0) == caller)  return mh;
+            if (caller.isAssignableFrom(rawType.parameterType(0))) return mh; // no need to restrict; already narrow
             MethodType narrowType = rawType.changeParameterType(0, caller);
             assert(!mh.isVarargsCollector());  // viewAsType will lose varargs-ness
             assert(mh.viewAsTypeChecks(narrowType, true));
@@ -2253,11 +2262,11 @@
             final boolean checkSecurity = true;
             return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass);
         }
-        /** Check access and get the requested method, eliding receiver narrowing rules. */
-        private MethodHandle getDirectMethodNoRestrict(byte refKind, Class<?> refc, MemberName method, Class<?> callerClass) throws IllegalAccessException {
+        /** Check access and get the requested method, for invokespecial with no restriction on the application of narrowing rules. */
+        private MethodHandle getDirectMethodNoRestrictInvokeSpecial(Class<?> refc, MemberName method, Class<?> callerClass) throws IllegalAccessException {
             final boolean doRestrict    = false;
             final boolean checkSecurity = true;
-            return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass);
+            return getDirectMethodCommon(REF_invokeSpecial, refc, method, checkSecurity, doRestrict, callerClass);
         }
         /** Check access and get the requested method, eliding security manager checks. */
         private MethodHandle getDirectMethodNoSecurityManager(byte refKind, Class<?> refc, MemberName method, Class<?> callerClass) throws IllegalAccessException {
@@ -2309,10 +2318,8 @@
             DirectMethodHandle dmh = DirectMethodHandle.make(refKind, refc, method);
             MethodHandle mh = dmh;
             // Optionally narrow the receiver argument to refc using restrictReceiver.
-            if (doRestrict &&
-                   (refKind == REF_invokeSpecial ||
-                       (MethodHandleNatives.refKindHasReceiver(refKind) &&
-                           restrictProtectedReceiver(method)))) {
+            if ((doRestrict && refKind == REF_invokeSpecial) ||
+                    (MethodHandleNatives.refKindHasReceiver(refKind) && restrictProtectedReceiver(method))) {
                 mh = restrictReceiver(method, dmh, lookupClass());
             }
             mh = maybeBindCaller(method, mh, callerClass);
@@ -2572,9 +2579,11 @@
     }
 
     /**
-     *
-     * Produces a VarHandle giving access to elements of an array type
-     * {@code T[]}, supporting shape {@code (T[], int : T)}.
+     * Produces a VarHandle giving access to elements of an array of type
+     * {@code arrayClass}.  The VarHandle's variable type is the component type
+     * of {@code arrayClass} and the list of coordinate types is
+     * {@code (arrayClass, int)}, where the {@code int} coordinate type
+     * corresponds to an argument that is an index into an array.
      * <p>
      * Certain access modes of the returned VarHandle are unsupported under
      * the following conditions:
@@ -2629,13 +2638,14 @@
     /**
      * Produces a VarHandle giving access to elements of a {@code byte[]} array
      * viewed as if it were a different primitive array type, such as
-     * {@code int[]} or {@code long[]}.  The shape of the resulting VarHandle is
-     * {@code (byte[], int : T)}, where the {@code int} coordinate type
-     * corresponds to an argument that is an index in a {@code byte[]} array,
-     * and {@code T} is the component type of the given view array class.  The
-     * returned VarHandle accesses bytes at an index in a {@code byte[]} array,
-     * composing bytes to or from a value of {@code T} according to the given
-     * endianness.
+     * {@code int[]} or {@code long[]}.
+     * The VarHandle's variable type is the component type of
+     * {@code viewArrayClass} and the list of coordinate types is
+     * {@code (byte[], int)}, where the {@code int} coordinate type
+     * corresponds to an argument that is an index into a {@code byte[]} array.
+     * The returned VarHandle accesses bytes at an index in a {@code byte[]}
+     * array, composing bytes to or from a value of the component type of
+     * {@code viewArrayClass} according to the given endianness.
      * <p>
      * The supported component types (variables types) are {@code short},
      * {@code char}, {@code int}, {@code long}, {@code float} and
@@ -2713,13 +2723,14 @@
      * Produces a VarHandle giving access to elements of a {@code ByteBuffer}
      * viewed as if it were an array of elements of a different primitive
      * component type to that of {@code byte}, such as {@code int[]} or
-     * {@code long[]}.  The shape of the resulting VarHandle is
-     * {@code (ByteBuffer, int : T)}, where the {@code int} coordinate type
-     * corresponds to an argument that is an index in a {@code ByteBuffer}, and
-     * {@code T} is the component type of the given view array class.  The
-     * returned VarHandle accesses bytes at an index in a {@code ByteBuffer},
-     * composing bytes to or from a value of {@code T} according to the given
-     * endianness.
+     * {@code long[]}.
+     * The VarHandle's variable type is the component type of
+     * {@code viewArrayClass} and the list of coordinate types is
+     * {@code (ByteBuffer, int)}, where the {@code int} coordinate type
+     * corresponds to an argument that is an index into a {@code byte[]} array.
+     * The returned VarHandle accesses bytes at an index in a
+     * {@code ByteBuffer}, composing bytes to or from a value of the component
+     * type of {@code viewArrayClass} according to the given endianness.
      * <p>
      * The supported component types (variables types) are {@code short},
      * {@code char}, {@code int}, {@code long}, {@code float} and

--- a/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/invoke/VarHandle.java	Mon May 01 11:48:16 2017 -0700
@@ -41,7 +41,7 @@
 import static java.lang.invoke.MethodHandleStatics.newInternalError;
 
 /**
- * A VarHandle is a dynamically typed reference to a variable, or to a
+ * A VarHandle is a dynamically strongly typed reference to a variable, or to a
  * parametrically-defined family of variables, including static fields,
  * non-static fields, array elements, or components of an off-heap data
  * structure.  Access to such variables is supported under various
@@ -53,63 +53,62 @@
  *
  * <p>A VarHandle has:
  * <ul>
- * <li>a {@link #varType variable type}, referred to as {@code T}, which is the
- * type of variable(s) referenced by this VarHandle;
- * <li>a list of {@link #coordinateTypes coordinate types}, referred to as
- * {@code CT}, where the types (primitive and reference) are represented by
- * {@link Class} objects).  A list of arguments corresponding to instances of
- * the coordinate types uniquely locates a variable referenced by this
- * VarHandle; and
- * <li>a <em>shape</em>, that combines the variable type and coordinate types,
- * and is declared with the notation {@code (CT : T)}.  An empty list of
- * coordinate types is declared as {@code (empty)}.
+ * <li>a {@link #varType variable type} T, the type of every variable referenced
+ * by this VarHandle; and
+ * <li>a list of {@link #coordinateTypes coordinate types}
+ * {@code CT1, CT2, ..., CTn}, the types of <em>coordinate expressions</em> that
+ * jointly locate a variable referenced by this VarHandle.
  * </ul>
+ * Variable and coordinate types may be primitive or reference, and are
+ * represented by {@code Class} objects.  The list of coordinate types may be
+ * empty.
  *
  * <p>Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup
- * lookup} VarHandle instances document the supported variable type, coordinate
- * types, and shape.
+ * lookup} VarHandle instances document the supported variable type and the list
+ * of coordinate types.
  *
- * For example, a VarHandle referencing a non-static field will declare a shape
- * of {@code (R : T)}, where {@code R} is the receiver type and
- * {@code T} is the field type, and where the VarHandle and an instance of the
- * receiver type can be utilized to access the field variable.
- * A VarHandle referencing array elements will declare a shape of
- * {@code (T[], int : T)}, where {@code T[]} is the array type and {@code T}
- * its component type, and where the VarHandle, an instance of the array type,
- * and an {@code int} index can be utilized to access an array element variable.
- *
- * <p>Each access mode is associated with a
- * <a href="MethodHandle.html#sigpoly">signature polymorphic</a> method of the
- * same name, where the VarHandle shape and access mode uniquely determine the
- * canonical {@link #accessModeType(AccessMode) access mode type},
- * which in turn determines the matching constraints on a valid symbolic
- * type descriptor at the call site of an access mode's method
- * <a href="VarHandle.html#invoke">invocation</a>.
+ * <p>Each access mode is associated with one <em>access mode method</em>, a
+ * <a href="MethodHandle.html#sigpoly">signature polymorphic</a> method named
+ * for the access mode.  When an access mode method is invoked on a VarHandle
+ * instance, the initial arguments to the invocation are coordinate expressions
+ * that indicate in precisely which object the variable is to be accessed.
+ * Trailing arguments to the invocation represent values of importance to the
+ * access mode.  For example, the various compare-and-set or compare-and-exchange
+ * access modes require two trailing arguments for the variable's expected value
+ * and new value.
  *
- * As such, VarHandles are dynamically and strongly typed.  Their arity,
- * argument types, and return type of an access mode method invocation are not
- * statically checked.  If they, and associated values, do not match the arity
- * and types of the access mode's type, an exception will be thrown.
- *
- * The parameter types of an access mode method type will consist of those that
- * are the VarHandles's coordinate types (in order), followed by access mode
- * parameter types specific to the access mode.
+ * <p>The arity and types of arguments to the invocation of an access mode
+ * method are not checked statically.  Instead, each access mode method
+ * specifies an {@link #accessModeType(AccessMode) access mode type},
+ * represented as an instance of {@link MethodType}, that serves as a kind of
+ * method signature against which the arguments are checked dynamically.  An
+ * access mode type gives formal parameter types in terms of the coordinate
+ * types of a VarHandle instance and the types for values of importance to the
+ * access mode.  An access mode type also gives a return type, often in terms of
+ * the variable type of a VarHandle instance.  When an access mode method is
+ * invoked on a VarHandle instance, the symbolic type descriptor at the
+ * call site, the run time types of arguments to the invocation, and the run
+ * time type of the return value, must <a href="#invoke">match</a> the types
+ * given in the access mode type.  A runtime exception will be thrown if the
+ * match fails.
  *
- * <p>An access mode's method documents the form of its method signature, which
- * is derived from the access mode parameter types.  The form is declared with
- * the notation {@code (CT, P1 p1, P2 p2, ..., PN pn)R}, where {@code CT} is the
- * coordinate types (as documented by a VarHandle factory method), {@code P1},
- * {@code P2} and {@code PN} are the first, second and the n'th access mode
- * parameters named {@code p1}, {@code p2} and {@code pn} respectively, and
- * {@code R} is the return type.
- *
- * For example, for the generic shape of {@code (CT : T)} the
- * {@link #compareAndSet} access mode method documents that its method
- * signature is of the form {@code (CT, T expectedValue, T newValue)boolean},
- * where the parameter types named {@code extendedValue} and {@code newValue}
- * are the access mode parameter types.  If the VarHandle accesses array
- * elements with a shape of say {@code (T[], int : T)} then the access mode
- * method type is {@code (T[], int, T, T)boolean}.
+ * For example, the access mode method {@link #compareAndSet} specifies that if
+ * its receiver is a VarHandle instance with coordinate types
+ * {@code CT1, ..., CTn} and variable type {@code T}, then its access mode type
+ * is {@code (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean}.
+ * Suppose that a VarHandle instance can access array elements, and that its
+ * coordinate types are {@code String[]} and {@code int} while its variable type
+ * is {@code String}.  The access mode type for {@code compareAndSet} on this
+ * VarHandle instance would be
+ * {@code (String[] c1, int c2, String expectedValue, String newValue)boolean}.
+ * Such a VarHandle instance may produced by the
+ * {@link MethodHandles#arrayElementVarHandle(Class) array factory method} and
+ * access array elements as follows:
+ * <pre> {@code
+ * String[] sa = ...
+ * VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
+ * boolean r = avh.compareAndSet(sa, 10, "expected", "new");
+ * }</pre>
  *
  * <p>Access modes are grouped into the following categories:
  * <ul>
@@ -172,10 +171,10 @@
  * lookup} VarHandle instances document the set of access modes that are
  * supported, which may also include documenting restrictions based on the
  * variable type and whether a variable is read-only.  If an access mode is not
- * supported then the corresponding signature-polymorphic method will on
- * invocation throw an {@code UnsupportedOperationException}.  Factory methods
- * should document any additional undeclared exceptions that may be thrown by
- * access mode methods.
+ * supported then the corresponding access mode method will on invocation throw
+ * an {@code UnsupportedOperationException}.  Factory methods should document
+ * any additional undeclared exceptions that may be thrown by access mode
+ * methods.
  * The {@link #get get} access mode is supported for all
  * VarHandle instances and the corresponding method never throws
  * {@code UnsupportedOperationException}.
@@ -215,7 +214,7 @@
  * precise phrasing of the specification of access mode methods and memory fence
  * methods may accompany future updates of the Java Language Specification.
  *
- * <h1>Compilation of an access mode's method</h1>
+ * <h1>Compiling invocation of access mode methods</h1>
  * A Java method call expression naming an access mode method can invoke a
  * VarHandle from Java source code.  From the viewpoint of source code, these
  * methods can take any arguments and their polymorphic result (if expressed)
@@ -247,7 +246,7 @@
  * except the null reference.
  *
  *
- * <h1><a id="invoke">Invocation of an access mode's method</a></h1>
+ * <h1><a id="invoke">Performing invocation of access mode methods</a></h1>
  * The first time an {@code invokevirtual} instruction is executed it is linked
  * by symbolically resolving the names in the instruction and verifying that
  * the method call is statically legal.  This also holds for calls to access mode
@@ -264,38 +263,31 @@
  * invoking is not present on the individual VarHandle being invoked.
  *
  * <p>
- * Invocation of an access mode's signature-polymorphic method behaves as if an
- * invocation of {@link MethodHandle#invoke}, where the receiving method handle
- * is bound to a VarHandle instance and the access mode.  More specifically, the
- * following:
+ * Invocation of an access mode method behaves as if an invocation of
+ * {@link MethodHandle#invoke}, where the receiving method handle accepts the
+ * VarHandle instance as the leading argument.  More specifically, the
+ * following, where {@code {access-mode}} corresponds to the access mode method
+ * name:
  * <pre> {@code
  * VarHandle vh = ..
  * R r = (R) vh.{access-mode}(p1, p2, ..., pN);
  * }</pre>
- * behaves as if (modulo the access mode methods do not declare throwing of
- * {@code Throwable}):
+ * behaves as if:
  * <pre> {@code
  * VarHandle vh = ..
+ * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
  * MethodHandle mh = MethodHandles.varHandleExactInvoker(
- *                       VarHandle.AccessMode.{access-mode},
- *                       vh.accessModeType(VarHandle.AccessMode.{access-mode}));
+ *                       am,
+ *                       vh.accessModeType(am));
  *
- * mh = mh.bindTo(vh);
- * R r = (R) mh.invoke(p1, p2, ..., pN)
+ * R r = (R) mh.invoke(vh, p1, p2, ..., pN)
  * }</pre>
- * or, more concisely, behaves as if:
- * <pre> {@code
- * VarHandle vh = ..
- * MethodHandle mh = vh.toMethodHandle(VarHandle.AccessMode.{access-mode});
- *
- * R r = (R) mh.invoke(p1, p2, ..., pN)
- * }</pre>
- * In terms of equivalent {@code invokevirtual} bytecode behaviour an access
- * mode method invocation is equivalent to:
+ * (modulo access mode methods do not declare throwing of {@code Throwable}).
+ * This is equivalent to:
  * <pre> {@code
  * MethodHandle mh = MethodHandles.lookup().findVirtual(
  *                       VarHandle.class,
- *                       VarHandle.AccessMode.{access-mode}.methodName(),
+ *                       "{access-mode}",
  *                       MethodType.methodType(R, p1, p2, ..., pN));
  *
  * R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
@@ -306,6 +298,17 @@
  * widen primitive values, as if by {@link MethodHandle#asType asType} (see also
  * {@link MethodHandles#varHandleInvoker}).
  *
+ * More concisely, such behaviour is equivalent to:
+ * <pre> {@code
+ * VarHandle vh = ..
+ * VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
+ * MethodHandle mh = vh.toMethodHandle(am);
+ *
+ * R r = (R) mh.invoke(p1, p2, ..., pN)
+ * }</pre>
+ * Where, in this case, the method handle is bound to the VarHandle instance.
+ *
+ *
  * <h1>Invocation checking</h1>
  * In typical programs, VarHandle access mode type matching will usually
  * succeed.  But if a match fails, the JVM will throw a
@@ -439,7 +442,7 @@
      * if the variable was declared non-{@code volatile}.  Commonly referred to
      * as plain read access.
      *
-     * <p>The method signature is of the form {@code (CT)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code get}
      * must match the access mode type that is the result of calling
@@ -449,15 +452,15 @@
      * throws {@code UnsupportedOperationException}.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -469,21 +472,21 @@
      * semantics of setting as if the variable was declared non-{@code volatile}
      * and non-{@code final}.  Commonly referred to as plain write access.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)void}
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}
      *
      * <p>The symbolic type descriptor at the call site of {@code set}
      * must match the access mode type that is the result of calling
      * {@code accessModeType(VarHandle.AccessMode.SET)} on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -497,7 +500,7 @@
      * Returns the value of a variable, with memory semantics of reading as if
      * the variable was declared {@code volatile}.
      *
-     * <p>The method signature is of the form {@code (CT)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getVolatile}
      * must match the access mode type that is the result of calling
@@ -505,17 +508,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -526,7 +529,7 @@
      * Sets the value of a variable to the {@code newValue}, with memory
      * semantics of setting as if the variable was declared {@code volatile}.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)void}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * <p>The symbolic type descriptor at the call site of {@code setVolatile}
      * must match the access mode type that is the result of calling
@@ -538,14 +541,14 @@
      * memory ordering effects compatible with {@code memory_order_seq_cst}.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -557,7 +560,7 @@
      * Returns the value of a variable, accessed in program order, but with no
      * assurance of memory ordering effects with respect to other threads.
      *
-     * <p>The method signature is of the form {@code (CT)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getOpaque}
      * must match the access mode type that is the result of calling
@@ -565,17 +568,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -587,7 +590,7 @@
      * but with no assurance of memory ordering effects with respect to other
      * threads.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)void}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * <p>The symbolic type descriptor at the call site of {@code setOpaque}
      * must match the access mode type that is the result of calling
@@ -595,14 +598,14 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -616,7 +619,7 @@
      * Returns the value of a variable, and ensures that subsequent loads and
      * stores are not reordered before this access.
      *
-     * <p>The method signature is of the form {@code (CT)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAcquire}
      * must match the access mode type that is the result of calling
@@ -629,17 +632,17 @@
      * ordering.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT)}
+     * {@code (CT1 ct1, ..., CTn ctn)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the value of the
      * variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -650,7 +653,7 @@
      * Sets the value of a variable to the {@code newValue}, and ensures that
      * prior loads and stores are not reordered after this access.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)void}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}.
      *
      * <p>The symbolic type descriptor at the call site of {@code setRelease}
      * must match the access mode type that is the result of calling
@@ -663,14 +666,14 @@
      * ordering.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      */
     public final native
     @MethodHandle.PolymorphicSignature
@@ -687,7 +690,7 @@
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * compareAndSet} must match the access mode type that is the result of
@@ -695,16 +698,16 @@
      * this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -720,7 +723,7 @@
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * compareAndExchange}
@@ -729,7 +732,7 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
@@ -755,7 +758,7 @@
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * compareAndExchangeAcquire}
@@ -764,17 +767,17 @@
      * this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -790,7 +793,7 @@
      * {@code expectedValue}, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * compareAndExchangeRelease}
@@ -799,17 +802,17 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the witness value, which
      * will be the same as the {@code expectedValue} if successful
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -830,7 +833,7 @@
      * <p>This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetPlain} must match the access mode type that is the result of
@@ -838,17 +841,17 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #get(Object...)
      */
@@ -867,7 +870,7 @@
      * <p>This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * weakCompareAndSet} must match the access mode type that is the
@@ -875,17 +878,17 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -904,7 +907,7 @@
      * <p>This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetAcquire}
@@ -913,17 +916,17 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -942,7 +945,7 @@
      * <p>This operation may fail spuriously (typically, due to memory
      * contention) even if the witness value does match the expected value.
      *
-     * <p>The method signature is of the form {@code (CT, T expectedValue, T newValue)boolean}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}.
      *
      * <p>The symbolic type descriptor at the call site of {@code
      * weakCompareAndSetRelease}
@@ -951,17 +954,17 @@
      * on this VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T expectedValue, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)}
      * , statically represented using varargs.
      * @return {@code true} if successful, otherwise {@code false} if the
      * witness value was not the same as the {@code expectedValue} or if this
      * operation spuriously failed.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -976,7 +979,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndSet}
      * must match the access mode type that is the result of calling
@@ -984,17 +987,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1009,7 +1012,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndSetAcquire}
      * must match the access mode type that is the result of calling
@@ -1017,17 +1020,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1042,7 +1045,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * <p>The method signature is of the form {@code (CT, T newValue)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndSetRelease}
      * must match the access mode type that is the result of calling
@@ -1050,17 +1053,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T newValue)}
+     * {@code (CT1 ct1, ..., CTn ctn, T newValue)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1078,7 +1081,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #getVolatile}.
      *
-     * <p>The method signature is of the form {@code (CT, T value)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndAdd}
      * must match the access mode type that is the result of calling
@@ -1086,17 +1089,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1111,7 +1114,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #getAcquire}.
      *
-     * <p>The method signature is of the form {@code (CT, T value)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndAddAcquire}
      * must match the access mode type that is the result of calling
@@ -1119,17 +1122,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1144,7 +1147,7 @@
      * previous value, as accessed with the memory semantics of
      * {@link #get}.
      *
-     * <p>The method signature is of the form {@code (CT, T value)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndAddRelease}
      * must match the access mode type that is the result of calling
@@ -1152,17 +1155,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T value)}
+     * {@code (CT1 ct1, ..., CTn ctn, T value)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1185,7 +1188,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOr}
      * must match the access mode type that is the result of calling
@@ -1193,17 +1196,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1222,7 +1225,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOrAcquire}
      * must match the access mode type that is the result of calling
@@ -1230,17 +1233,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1259,7 +1262,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical OR is performed instead of a bitwise OR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseOrRelease}
      * must match the access mode type that is the result of calling
@@ -1267,17 +1270,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1296,7 +1299,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAnd}
      * must match the access mode type that is the result of calling
@@ -1304,17 +1307,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1333,7 +1336,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAndAcquire}
      * must match the access mode type that is the result of calling
@@ -1341,17 +1344,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1370,7 +1373,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical AND is performed instead of a bitwise AND.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseAndRelease}
      * must match the access mode type that is the result of calling
@@ -1378,17 +1381,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1407,7 +1410,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXor}
      * must match the access mode type that is the result of calling
@@ -1415,17 +1418,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setVolatile(Object...)
      * @see #getVolatile(Object...)
      */
@@ -1444,7 +1447,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXorAcquire}
      * must match the access mode type that is the result of calling
@@ -1452,17 +1455,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #set(Object...)
      * @see #getAcquire(Object...)
      */
@@ -1481,7 +1484,7 @@
      * <p>If the variable type is the non-integral {@code boolean} type then a
      * logical XOR is performed instead of a bitwise XOR.
      *
-     * <p>The method signature is of the form {@code (CT, T mask)T}.
+     * <p>The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}.
      *
      * <p>The symbolic type descriptor at the call site of {@code getAndBitwiseXorRelease}
      * must match the access mode type that is the result of calling
@@ -1489,17 +1492,17 @@
      * VarHandle.
      *
      * @param args the signature-polymorphic parameter list of the form
-     * {@code (CT, T mask)}
+     * {@code (CT1 ct1, ..., CTn ctn, T mask)}
      * , statically represented using varargs.
      * @return the signature-polymorphic result that is the previous value of
      * the variable
      * , statically represented using {@code Object}.
      * @throws UnsupportedOperationException if the access mode is unsupported
      * for this VarHandle.
-     * @throws WrongMethodTypeException if the access mode type is not
-     * compatible with the caller's symbolic type descriptor.
-     * @throws ClassCastException if the access mode type is compatible with the
-     * caller's symbolic type descriptor, but a reference cast fails.
+     * @throws WrongMethodTypeException if the access mode type does not
+     * match the caller's symbolic type descriptor.
+     * @throws ClassCastException if the access mode type matches the caller's
+     * symbolic type descriptor, but a reference cast fails.
      * @see #setRelease(Object...)
      * @see #get(Object...)
      */
@@ -1790,7 +1793,7 @@
 
         /**
          * Returns the {@code VarHandle} signature-polymorphic method name
-         * associated with this {@code AccessMode} value
+         * associated with this {@code AccessMode} value.
          *
          * @return the signature-polymorphic method name
          * @see #valueFromMethodName
@@ -1861,14 +1864,13 @@
     }
 
     /**
-     * Obtains the canonical access mode type for this VarHandle and a given
-     * access mode.
+     * Obtains the access mode type for this VarHandle and a given access mode.
      *
      * <p>The access mode type's parameter types will consist of a prefix that
      * is the coordinate types of this VarHandle followed by further
-     * types as defined by the access mode's method.
+     * types as defined by the access mode method.
      * The access mode type's return type is defined by the return type of the
-     * access mode's method.
+     * access mode method.
      *
      * @param accessMode the access mode, corresponding to the
      * signature-polymorphic method of the same name
@@ -1891,7 +1893,7 @@
      *
      * <p>The return of a {@code false} value for a given access mode indicates
      * that an {@code UnsupportedOperationException} is thrown on invocation
-     * of the corresponding access mode's signature-polymorphic method.
+     * of the corresponding access mode method.
      *
      * @param accessMode the access mode, corresponding to the
      * signature-polymorphic method of the same name
@@ -1908,7 +1910,7 @@
      *
      * @apiNote This method, for a VarHandle {@code vh} and access mode
      * {@code {access-mode}}, returns a method handle that is equivalent to
-     * method handle {@code bhm} in the following code (though it may be more
+     * method handle {@code bmh} in the following code (though it may be more
      * efficient):
      * <pre>{@code
      * MethodHandle mh = MethodHandles.varHandleExactInvoker(

--- a/jdk/src/java.management.rmi/share/classes/javax/management/remote/rmi/package.html	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management.rmi/share/classes/javax/management/remote/rmi/package.html	Mon May 01 11:48:16 2017 -0700
@@ -98,7 +98,7 @@
       constructor.</p>
 
 
-    <h4><a name="servergen">Connector addresses generated by the
+    <h4><a id="servergen">Connector addresses generated by the
 	server</a></h4>
 
     <p>If the <code>serviceURL</code> you specify has an empty URL
@@ -157,7 +157,7 @@
       <code><em>port</em></code>.</p>
 
 
-    <h4><a name="directory">Connector addresses based on directory
+    <h4><a id="directory">Connector addresses based on directory
 	entries</a></h4>
 
     <p>As an alternative to the generated addresses just described,

--- a/jdk/src/java.management/share/classes/java/lang/management/LockInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/LockInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -34,7 +34,7 @@
  * an <em>ownable synchronizer</em>, or the {@link Condition Condition}
  * object associated with synchronizers.
  * <p>
- * <a name="OwnableSynchronizer">An ownable synchronizer</a> is
+ * <a id="OwnableSynchronizer">An ownable synchronizer</a> is
  * a synchronizer that may be exclusively owned by a thread and uses
  * {@link AbstractOwnableSynchronizer AbstractOwnableSynchronizer}
  * (or its subclass) to implement its synchronization property.
@@ -42,7 +42,7 @@
  * the read-lock) of {@link ReentrantReadWriteLock ReentrantReadWriteLock} are
  * two examples of ownable synchronizers provided by the platform.
  *
- * <h3><a name="MappedType">MXBean Mapping</a></h3>
+ * <h3><a id="MappedType">MXBean Mapping</a></h3>
  * {@code LockInfo} is mapped to a {@link CompositeData CompositeData}
  * as specified in the {@link #from from} method.
  *
@@ -105,10 +105,11 @@
      * given {@code CompositeData}.
      * The given {@code CompositeData} must contain the following attributes:
      * <blockquote>
-     * <table border summary="The attributes and the types the given CompositeData contains">
+     * <table border="1">
+     * <caption style="display:none">The attributes and the types the given CompositeData contains</caption>
      * <tr>
-     *   <th align=left>Attribute Name</th>
-     *   <th align=left>Type</th>
+     *   <th style="text-align:left">Attribute Name</th>
+     *   <th style="text-align:left">Type</th>
      * </tr>
      * <tr>
      *   <td>className</td>

--- a/jdk/src/java.management/share/classes/java/lang/management/ManagementFactory.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/ManagementFactory.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -67,7 +67,7 @@
  * the management interface of a component of the Java virtual
  * machine.
  *
- * <h3><a name="MXBean">Platform MXBeans</a></h3>
+ * <h3><a id="MXBean">Platform MXBeans</a></h3>
  * <p>
  * A platform MXBean is a <i>managed bean</i> that
  * conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
@@ -83,7 +83,7 @@
  * See <a href="../../../javax/management/MXBean.html#MXBean-spec">
  * the specification of MXBeans</a> for details.
  *
- * <a name="MXBeanNames"></a>
+ * <a id="MXBeanNames"></a>
  * <p>Each platform MXBean is a {@link PlatformManagedObject}
  * and it has a unique
  * {@link javax.management.ObjectName ObjectName} for
@@ -141,7 +141,8 @@
  * interfaces:
  *
  * <blockquote>
- * <table border summary="The list of Management Interfaces and their single instances">
+ * <table border="1">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
  * <tr>
  * <th>Management Interface</th>
  * <th>ObjectName</th>
@@ -184,7 +185,8 @@
  * the following management interfaces.
  *
  * <blockquote>
- * <table border summary="The list of Management Interfaces and their single instances">
+ * <table border="1">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
  * <tr>
  * <th>Management Interface</th>
  * <th>ObjectName</th>
@@ -201,7 +203,8 @@
  * A Java virtual machine may have one or more instances of the following
  * management interfaces.
  * <blockquote>
- * <table border summary="The list of Management Interfaces and their single instances">
+ * <table border="1">
+ * <caption style="display:none">The list of Management Interfaces and their single instances</caption>
  * <tr>
  * <th>Management Interface</th>
  * <th>ObjectName</th>

--- a/jdk/src/java.management/share/classes/java/lang/management/ManagementPermission.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/ManagementPermission.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -34,7 +34,8 @@
  * provides a summary description of what the permission allows,
  * and discusses the risks of granting code the permission.
  *
- * <table border=1 cellpadding=5 summary="Table shows permission target name, what the permission allows, and associated risks">
+ * <table border="1" cellpadding=5>
+ * <caption style="display:none">Table shows permission target name, what the permission allows, and associated risks</caption>
  * <tr>
  * <th>Permission Target Name</th>
  * <th>What the Permission Allows</th>

--- a/jdk/src/java.management/share/classes/java/lang/management/MemoryNotificationInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/MemoryNotificationInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -212,10 +212,11 @@
      * The given {@code CompositeData} must contain
      * the following attributes:
      * <blockquote>
-     * <table border summary="The attributes and the types the given CompositeData contains">
+     * <table border="1">
+     * <caption style="display:none">The attributes and the types the given CompositeData contains</caption>
      * <tr>
-     *   <th align=left>Attribute Name</th>
-     *   <th align=left>Type</th>
+     *   <th style="text-align:left">Attribute Name</th>
+     *   <th style="text-align:left">Type</th>
      * </tr>
      * <tr>
      *   <td>poolName</td>

--- a/jdk/src/java.management/share/classes/java/lang/management/MemoryPoolMXBean.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/MemoryPoolMXBean.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -71,7 +71,7 @@
  *       (only supported by some <em>garbage-collected</em> memory pools)</li>
  * </ul>
  *
- * <h3><a name="Usage">1. Memory Usage</a></h3>
+ * <h3><a id="Usage">1. Memory Usage</a></h3>
  *
  * The {@link #getUsage} method provides an estimate
  * of the current usage of a memory pool.
@@ -86,14 +86,14 @@
  * the current memory usage.  An implementation should document when
  * this is the case.
  *
- * <h3><a name="PeakUsage">2. Peak Memory Usage</a></h3>
+ * <h3><a id="PeakUsage">2. Peak Memory Usage</a></h3>
  *
  * The Java virtual machine maintains the peak memory usage of a memory
  * pool since the virtual machine was started or the peak was reset.
  * The peak memory usage is returned by the {@link #getPeakUsage} method
  * and reset by calling the {@link #resetPeakUsage} method.
  *
- * <h3><a name="UsageThreshold">3. Usage Threshold</a></h3>
+ * <h3><a id="UsageThreshold">3. Usage Threshold</a></h3>
  *
  * Each memory pool has a manageable attribute
  * called the <i>usage threshold</i> which has a default value supplied
@@ -141,7 +141,7 @@
  * <a href="#ThresholdNotification">threshold notification</a> mechanisms.
  *
  * <ol type="a">
- *   <li><a name="Polling"><b>Polling</b></a>
+ *   <li><a id="Polling"><b>Polling</b></a>
  *       <p>
  *       An application can continuously monitor its memory usage
  *       by calling either the {@link #getUsage} method for all
@@ -231,7 +231,7 @@
  *       }
  *       </pre><hr>
  *   </li>
- *   <li><a name="ThresholdNotification"><b>Usage Threshold Notifications</b></a>
+ *   <li><a id="ThresholdNotification"><b>Usage Threshold Notifications</b></a>
  *       <p>
  *       Usage threshold notification will be emitted by {@link MemoryMXBean}.
  *       When the Java virtual machine detects that the memory usage of
@@ -304,7 +304,7 @@
  *   </li>
  * </ol>
  *
- * <h3><a name="CollectionThreshold">4. Collection Usage Threshold</a></h3>
+ * <h3><a id="CollectionThreshold">4. Collection Usage Threshold</a></h3>
  *
  * Collection usage threshold is a manageable attribute only applicable
  * to some garbage-collected memory pools.

--- a/jdk/src/java.management/share/classes/java/lang/management/MemoryUsage.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/MemoryUsage.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -36,10 +36,11 @@
  * the heap or non-heap memory of the Java virtual machine as a whole.
  *
  * <p> A {@code MemoryUsage} object contains four values:
- * <table summary="Describes the MemoryUsage object content">
+ * <table>
+ * <caption style="display:none">Describes the MemoryUsage object content</caption>
  * <tr>
- * <td valign=top> {@code init} </td>
- * <td valign=top> represents the initial amount of memory (in bytes) that
+ * <td style="vertical-align:top"> {@code init} </td>
+ * <td style="vertical-align:top"> represents the initial amount of memory (in bytes) that
  *      the Java virtual machine requests from the operating system
  *      for memory management during startup.  The Java virtual machine
  *      may request additional memory from the operating system and
@@ -48,13 +49,13 @@
  * </td>
  * </tr>
  * <tr>
- * <td valign=top> {@code used} </td>
- * <td valign=top> represents the amount of memory currently used (in bytes).
+ * <td style="vertical-align:top"> {@code used} </td>
+ * <td style="vertical-align:top"> represents the amount of memory currently used (in bytes).
  * </td>
  * </tr>
  * <tr>
- * <td valign=top> {@code committed} </td>
- * <td valign=top> represents the amount of memory (in bytes) that is
+ * <td style="vertical-align:top"> {@code committed} </td>
+ * <td style="vertical-align:top"> represents the amount of memory (in bytes) that is
  *      guaranteed to be available for use by the Java virtual machine.
  *      The amount of committed memory may change over time (increase
  *      or decrease).  The Java virtual machine may release memory to
@@ -64,8 +65,8 @@
  * </td>
  * </tr>
  * <tr>
- * <td valign=top> {@code max} </td>
- * <td valign=top> represents the maximum amount of memory (in bytes)
+ * <td style="vertical-align:top"> {@code max} </td>
+ * <td style="vertical-align:top"> represents the maximum amount of memory (in bytes)
  *      that can be used for memory management. Its value may be undefined.
  *      The maximum amount of memory may change over time if defined.
  *      The amount of used and committed memory will always be less than
@@ -252,10 +253,11 @@
      * must contain the following attributes:
      *
      * <blockquote>
-     * <table border summary="The attributes and the types the given CompositeData contains">
+     * <table border="1">
+     * <caption style="display:none">The attributes and the types the given CompositeData contains</caption>
      * <tr>
-     *   <th align=left>Attribute Name</th>
-     *   <th align=left>Type</th>
+     *   <th style="text-align:left">Attribute Name</th>
+     *   <th style="text-align:left">Type</th>
      * </tr>
      * <tr>
      *   <td>init</td>

--- a/jdk/src/java.management/share/classes/java/lang/management/MonitorInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/MonitorInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -106,10 +106,11 @@
      * <a href="LockInfo.html#MappedType">
      * mapped type</a> for the {@link LockInfo} class:
      * <blockquote>
-     * <table border summary="The attributes and their types the given CompositeData contains">
+     * <table border="1">
+     * <caption style="display:none">The attributes and their types the given CompositeData contains</caption>
      * <tr>
-     *   <th align=left>Attribute Name</th>
-     *   <th align=left>Type</th>
+     *   <th style="text-align:left">Attribute Name</th>
+     *   <th style="text-align:left">Type</th>
      * </tr>
      * <tr>
      *   <td>lockedStackFrame</td>

--- a/jdk/src/java.management/share/classes/java/lang/management/RuntimeMXBean.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/RuntimeMXBean.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -312,7 +312,8 @@
      * {@link javax.management.openmbean.TabularData TabularData}
      * with two items in each row as follows:
      * <blockquote>
-     * <table border summary="Name and Type for each item">
+     * <table border="1">
+     * <caption style="display:none">Name and Type for each item</caption>
      * <tr>
      *   <th>Item Name</th>
      *   <th>Item Type</th>

--- a/jdk/src/java.management/share/classes/java/lang/management/ThreadInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/ThreadInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -61,7 +61,7 @@
  *   <li>Thread priority</li>
  * </ul>
  *
- * <h4><a name="SyncStats">Synchronization Statistics</a></h4>
+ * <h4><a id="SyncStats">Synchronization Statistics</a></h4>
  * <ul>
  *   <li>The number of times that the thread has blocked for
  *       synchronization or waited for notification.</li>
@@ -695,10 +695,11 @@
      * The given {@code CompositeData} must contain the following attributes
      * unless otherwise specified below:
      * <blockquote>
-     * <table border summary="The attributes and their types the given CompositeData contains">
+     * <table border="1">
+     * <caption style="display:none">The attributes and their types the given CompositeData contains</caption>
      * <tr>
-     *   <th align=left>Attribute Name</th>
-     *   <th align=left>Type</th>
+     *   <th style="text-align:left">Attribute Name</th>
+     *   <th style="text-align:left">Type</th>
      * </tr>
      * <tr>
      *   <td>threadId</td>
@@ -759,16 +760,17 @@
      *   <td>{@code java.lang.String}</td>
      * </tr>
      * <tr>
-     *   <td><a name="StackTrace">stackTrace</a></td>
+     *   <td><a id="StackTrace">stackTrace</a></td>
      *   <td>{@code javax.management.openmbean.CompositeData[]}
      *       <p>
      *       Each element is a {@code CompositeData} representing
      *       StackTraceElement containing the following attributes:
      *       <blockquote>
-     *       <table cellspacing=1 cellpadding=0 summary="The attributes and their types the given CompositeData contains">
+     *       <table cellspacing=1 cellpadding=0>
+     *       <caption style="display:none">The attributes and their types the given CompositeData contains</caption>
      *       <tr>
-     *         <th align=left>Attribute Name</th>
-     *         <th align=left>Type</th>
+     *         <th style="text-align:left">Attribute Name</th>
+     *         <th style="text-align:left">Type</th>
      *       </tr>
      *       <tr>
      *         <td>moduleName</td>

--- a/jdk/src/java.management/share/classes/java/lang/management/package.html	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/java/lang/management/package.html	Mon May 01 11:48:16 2017 -0700
@@ -32,7 +32,7 @@
 It allows both local and remote
 monitoring and management of the running Java virtual machine.
 
-<h4><a name="MXBean">Platform MXBean</a></h4>
+<h3><a id="MXBean">Platform MXBean</a></h3>
 <p>
 A platform MXBean is a <i>managed bean</i> that
 conforms to the <a href="../../../javax/management/package-summary.html">JMX</a>
@@ -40,7 +40,7 @@
 Each platform MXBean is a {@link java.lang.management.PlatformManagedObject}
 with a unique
 {@linkplain java.lang.management.PlatformManagedObject#getObjectName name}.
-<h4>ManagementFactory</h4>
+<h3>ManagementFactory</h3>
 
 <p>The {@link java.lang.management.ManagementFactory} class is the management
 factory class for the Java platform.  This class provides a set of
@@ -58,7 +58,7 @@
 This is a single MBeanServer that can be shared by different managed
 components running within the same Java virtual machine.
 
-<h4>Interoperability</h4>
+<h3>Interoperability</h3>
 
 <p>A management application and a platform MBeanServer of a running
 virtual machine can interoperate
@@ -72,7 +72,7 @@
 See the <a href="../../../javax/management/MXBean.html#MXBean-spec">
 MXBean</a> specification for details.
 
-<h4><a name="examples">Ways to Access MXBeans</a></h4>
+<h3><a id="examples">Ways to Access MXBeans</a></h3>
 
 <p>An application can monitor the instrumentation of the
 Java virtual machine and the runtime in the following ways:
@@ -163,7 +163,7 @@
 </ul>
 
 
-<h4><a name="extension">Platform Extension</a></h4>
+<h3><a id="extension">Platform Extension</a></h3>
 
 <p>A Java virtual machine implementation may add its platform extension to
 the management interface by defining platform-dependent

--- a/jdk/src/java.management/share/classes/javax/management/Descriptor.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/Descriptor.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -96,7 +96,8 @@
  * of the mapped Java type, called <em>opendata</em>(J) in the <a
  * href="MXBean.html#mapping-rules">MXBean type mapping rules</a>.</p>
  *
- * <table border="1" cellpadding="5" summary="Descriptor Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">Descriptor Fields</caption>
  *
  * <tr><th>Name</th><th>Type</th><th>Used in</th><th>Meaning</th></tr>
  *
@@ -330,7 +331,8 @@
  * interest outside Model MBeans, for example.  But only Model MBeans have
  * a predefined behavior for these fields.</p>
  *
- * <table border="1" cellpadding="5" summary="ModelMBean Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">ModelMBean Fields</caption>
  *
  * <tr><th>Name</th><th>Type</th><th>Used in</th><th>Meaning</th></tr>
  *

--- a/jdk/src/java.management/share/classes/javax/management/DescriptorKey.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/DescriptorKey.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -94,7 +94,8 @@
  * <p>then the resulting {@code Descriptor} will contain the following
  * fields:</p>
  *
- * <table border="2" summary="Descriptor Fields">
+ * <table border="1">
+ * <caption style="display:none">Descriptor Fields</caption>
  * <tr><th>Name</th><th>Value</th></tr>
  * <tr><td>units</td><td>"bytes"</td></tr>
  * <tr><td>descriptionResourceKey</td><td>"bytes.key"</td></tr>
@@ -143,7 +144,8 @@
  * or an array of annotations.  The value of the field is derived from
  * the value of the annotation element as follows:</p>
  *
- * <table border="2" summary="Descriptor Field Types">
+ * <table border="1">
+ * <caption style="display:none">Descriptor Field Types</caption>
  * <tr><th>Annotation element</th><th>Descriptor field</th></tr>
  * <tr><td>Primitive value ({@code 5}, {@code false}, etc)</td>
  *     <td>Wrapped value ({@code Integer.valueOf(5)},

--- a/jdk/src/java.management/share/classes/javax/management/MBeanPermission.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/MBeanPermission.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -133,7 +133,7 @@
  * any value (including another null value) but does not imply any
  * other value.</p>
  *
- * <p><a name="action-list">The possible actions are these:</a></p>
+ * <p><a id="action-list">The possible actions are these:</a></p>
  *
  * <ul>
  * <li>addNotificationListener</li>

--- a/jdk/src/java.management/share/classes/javax/management/MXBean.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/MXBean.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -93,7 +93,8 @@
       Standard MBean concept.  Here is how a managed object might be
       represented as a Standard MBean, and as an MXBean:</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -133,7 +134,8 @@
 
     <p>So, we might define <code>MemoryUsage</code> like this:</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -195,7 +197,8 @@
     <p>This becomes clearer if we compare what the clients of the two
       models might look like:</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -232,7 +235,8 @@
       managed objects when you know the model beforehand, regardless
       of whether you are using Standard MBeans or MXBeans:</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -265,7 +269,8 @@
     <p>Implementing the MemoryPool object works similarly for both
       Standard MBeans and MXBeans.</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -292,7 +297,8 @@
     <p>Registering the MBean in the MBean Server works in the same way
       in both cases:</p>
 
-    <table border="1" cellpadding="5" summary="Standard Bean vs. MXBean">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Standard Bean vs. MXBean</caption>
       <tr>
         <th>Standard MBean</th><th>MXBean</th>
       </tr>
@@ -478,13 +484,14 @@
 
     <p>The following table summarizes the type mapping rules.</p>
 
-    <table border="1" cellpadding="5" summary="Type Mapping Rules">
+    <table border="1" cellpadding="5">
+    <caption style="display:none">Type Mapping Rules</caption>
       <tr>
         <th>Java type <em>J</em></th>
         <th><em>opentype(J)</em></th>
         <th><em>opendata(J)</em></th>
       </tr>
-      <tbody valign="top">
+      <tbody style="vertical-align:top">
         <tr>
           <td>{@code int}, {@code boolean}, etc<br>
             (the 8 primitive Java types)</td>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanAttributeInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -57,7 +57,8 @@
  * Note that when the Type in this table is Number, a String that is the decimal
  * representation of a Long can also be used.</P>
  *
- * <table border="1" cellpadding="5" summary="ModelMBeanAttributeInfo Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">ModelMBeanAttributeInfo Fields</caption>
  * <tr><th>Name</th><th>Type</th><th>Meaning</th></tr>
  * <tr><td>name</td><td>String</td>
  *     <td>Attribute name.</td></tr>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanConstructorInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -58,7 +58,8 @@
  * Note that when the Type in this table is Number, a String that is the decimal
  * representation of a Long can also be used.</P>
  *
- * <table border="1" cellpadding="5" summary="ModelMBeanConstructorInfo Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">ModelMBeanConstructorInfo Fields</caption>
  * <tr><th>Name</th><th>Type</th><th>Meaning</th></tr>
  * <tr><td>name</td><td>String</td>
  *     <td>Constructor name.</td></tr>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -165,7 +165,8 @@
      * following.  Note that when the Type in this table is Number, a String
      * that is the decimal representation of a Long can also be used.</P>
      *
-     * <table border="1" cellpadding="5" summary="ModelMBean Fields">
+     * <table border="1" cellpadding="5">
+     * <caption style="display:none">ModelMBean Fields</caption>
      * <tr><th>Name</th><th>Type</th><th>Meaning</th></tr>
      * <tr><td>name</td><td>String</td>
      *     <td>MBean name.</td></tr>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanNotificationInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -56,7 +56,8 @@
  * Note that when the Type in this table is Number, a String that is the decimal
  * representation of a Long can also be used.</P>
  *
- * <table border="1" cellpadding="5" summary="ModelMBeanNotificationInfo Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">ModelMBeanNotificationInfo Fields</caption>
  * <tr><th>Name</th><th>Type</th><th>Meaning</th></tr>
  * <tr><td>name</td><td>String</td>
  *     <td>Notification name.</td></tr>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/ModelMBeanOperationInfo.java	Mon May 01 11:48:16 2017 -0700
@@ -59,7 +59,8 @@
  * Note that when the Type in this table is Number, a String that is the decimal
  * representation of a Long can also be used.</P>
  *
- * <table border="1" cellpadding="5" summary="ModelMBeanOperationInfo Fields">
+ * <table border="1" cellpadding="5">
+ * <caption style="display:none">ModelMBeanOperationInfo Fields</caption>
  * <tr><th>Name</th><th>Type</th><th>Meaning</th></tr>
  * <tr><td>name</td><td>String</td>
  *     <td>Operation name.</td></tr>

--- a/jdk/src/java.management/share/classes/javax/management/modelmbean/package.html	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/modelmbean/package.html	Mon May 01 11:48:16 2017 -0700
@@ -110,7 +110,7 @@
 // returns "value"
     </pre>
 
-    <h2><a name="spec">Package Specification</a></h2>
+    <h2><a id="spec">Package Specification</a></h2>
 
     <ul>
 	  <li>See the <i>JMX 1.4 Specification</i>

--- a/jdk/src/java.management/share/classes/javax/management/openmbean/package.html	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/openmbean/package.html	Mon May 01 11:48:16 2017 -0700
@@ -77,7 +77,7 @@
       describes the items in the <code>CompositeData</code> instances
       for the attribute.</p>
 
-    <h2><a name="constraints">Default values and constraints</a></h2>
+    <h2><a id="constraints">Default values and constraints</a></h2>
 
     <p>In Open MBeans, attributes and parameters can have default values
       and/or constraints associated with them in the {@code

--- a/jdk/src/java.management/share/classes/javax/management/remote/JMXConnectionNotification.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/src/java.management/share/classes/javax/management/remote/JMXConnectionNotification.java	Mon May 01 11:48:16 2017 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -40,11 +40,12 @@
  *
  * <p>The notification type is one of the following:</p>
  *
- * <table summary="JMXConnectionNotification Types">
+ * <table>
+ * <caption style="display:none">JMXConnectionNotification Types</caption>
  *
  * <tr>
- * <th align=left>Type</th>
- * <th align=left>Meaning</th>
+ * <th style="text-align:left">Type</th>
+ * <th style="text-align:left">Meaning</th>
  * </tr>
  *
  * <tr>

--- a/jdk/test/java/io/FileInputStream/LargeFileAvailable.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/test/java/io/FileInputStream/LargeFileAvailable.java	Mon May 01 11:48:16 2017 -0700
@@ -24,7 +24,6 @@
 /*
  * @test
  * @bug 6402006 7030573 8011136
- * @key intermittent
  * @summary Test if available returns correct value when reading
  *          a large file.
  * @run main/timeout=300 LargeFileAvailable

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/invoke/8177146/TestMethodHandleBind.java	Mon May 01 11:48:16 2017 -0700
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/* @test
+ * @bug 8177146
+ * @run testng/othervm TestMethodHandleBind
+ */
+
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+
+import static java.lang.invoke.MethodHandles.lookup;
+
+import static org.testng.Assert.*;
+
+public class TestMethodHandleBind extends pkg.A {
+    static class B extends TestMethodHandleBind {}
+
+    @Test
+    public void testInstanceOfCallerClass() throws Throwable {
+        MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m1", MethodType.methodType(String.class));
+        String x = (String)bound.invoke();
+        assertEquals(x, this.getClass().getSimpleName());
+    }
+
+    @Test
+    public void testInstanceOfCallerSubclass() throws Throwable {
+        MethodHandle bound = lookup().bind(new B() , "m1", MethodType.methodType(String.class));
+        // MethodHandle bound = lookup().findVirtual(B.class,  "m1", MethodType.methodType(String.class)).bindTo(new B());
+        String x = (String)bound.invoke();
+        assertEquals(x, "B");
+    }
+
+    @Test
+    public void testInstanceOfReceiverClass() throws Throwable {
+        try {
+            MethodHandle bound = lookup().bind(new pkg.A() , "m1", MethodType.methodType(String.class));
+            bound.invoke();
+            fail("IllegalAccessException expected");
+        } catch (IllegalAccessException e) {
+        }
+    }
+
+    @Test
+    public void testPublicMethod() throws Throwable {
+        MethodHandle bound = lookup().bind(new pkg.A() , "m2", MethodType.methodType(String.class));
+        String x = (String)bound.invoke();
+        assertEquals(x, "A");
+    }
+
+    @Test
+    public void testPublicMethod2() throws Throwable {
+        MethodHandle bound = lookup().bind(new TestMethodHandleBind(), "m2", MethodType.methodType(String.class));
+        String x = (String)bound.invoke();
+        assertEquals(x, this.getClass().getSimpleName());
+    }
+
+    @Test
+    public void testInstanceOfCallerClassVarargs() throws Throwable {
+        MethodHandle bound = lookup().bind(new TestMethodHandleBind() , "m3", MethodType.methodType(String.class, String[].class));
+        String x = (String)bound.invoke("a", "b", "c");
+        assertEquals(x, this.getClass().getSimpleName() + "abc");
+    }
+
+    @Test
+    public void testInstanceOfReceiverClassVarargs() throws Throwable {
+        try {
+            MethodHandle bound = lookup().bind(new pkg.A(), "m3", MethodType.methodType(String.class, String[].class));
+            bound.invoke();
+            fail("IllegalAccessException expected");
+        } catch (IllegalAccessException e) {
+        }
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/invoke/8177146/pkg/A.java	Mon May 01 11:48:16 2017 -0700
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package pkg;
+
+public class A {
+    protected String m1() {
+        return this.getClass().getSimpleName();
+    }
+
+    public String m2() {
+        return this.getClass().getSimpleName();
+    }
+
+    protected String m3(String... args) {
+        StringBuilder sb = new StringBuilder();
+        for (String s : args)
+            sb.append(s);
+        return this.getClass().getSimpleName() + sb.toString();
+    }
+}

--- a/jdk/test/java/nio/channels/FileChannel/LoopingTruncate.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/test/java/nio/channels/FileChannel/LoopingTruncate.java	Mon May 01 11:48:16 2017 -0700
@@ -24,7 +24,6 @@
 /**
  * @test
  * @bug 8137121 8137230
- * @key intermittent
  * @summary (fc) Infinite loop FileChannel.truncate
  * @library /lib/testlibrary
  * @build jdk.testlibrary.Utils

--- a/jdk/test/java/nio/channels/FileChannel/Transfer.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/test/java/nio/channels/FileChannel/Transfer.java	Mon May 01 11:48:16 2017 -0700
@@ -23,7 +23,6 @@
 
 /* @test
  * @bug 4434723 4482726 4559072 4795550 5081340 5103988 6984545
- * @key intermittent
  * @summary Test FileChannel.transferFrom and transferTo (use -Dseed=X to set PRNG seed)
  * @library ..
  * @library /lib/testlibrary/

--- a/jdk/test/java/nio/channels/FileChannel/Transfers.java	Fri Apr 28 17:21:28 2017 -0700
+++ b/jdk/test/java/nio/channels/FileChannel/Transfers.java	Mon May 01 11:48:16 2017 -0700
@@ -22,7 +22,6 @@
  */
 
 /* @test
- * @key intermittent
  * @summary Comprehensive test for FileChannel.transfer{From,To}
  * @bug 4708120
  * @author Mark Reinhold