Merging master HEAD into openj9-staging

make/autoconf/help.m4

@@ -238,6 +238,7 @@ AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS],
 
  printf "\n"
  printf "Configuration summary:\n"
+ printf "* Name: $CONF_NAME\n"
  printf "* Debug level: $DEBUG_LEVEL\n"
  printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
  printf "* JVM variants: $JVM_VARIANTS\n"

src/java.base/share/classes/java/io/InputStream.java

@@ -577,13 +577,15 @@ public long skip(long n) throws IOException {
  * @implSpec
  * If {@code n} is zero or negative, then no bytes are skipped.
  * If {@code n} is positive, the default implementation of this method
- * invokes {@link #skip(long) skip()} with parameter {@code n}. If the
- * return value of {@code skip(n)} is non-negative and less than {@code n},
- * then {@link #read()} is invoked repeatedly until the stream is {@code n}
- * bytes beyond its position when this method was invoked or end of stream
- * is reached. If the return value of {@code skip(n)} is negative or
- * greater than {@code n}, then an {@code IOException} is thrown. Any
- * exception thrown by {@code skip()} or {@code read()} will be propagated.
+ * invokes {@link #skip(long) skip()} repeatedly with its parameter equal
+ * to the remaining number of bytes to skip until the requested number
+ * of bytes has been skipped or an error condition occurs. If at any
+ * point the return value of {@code skip()} is negative or greater than the
+ * remaining number of bytes to be skipped, then an {@code IOException} is
+ * thrown. If {@code skip()} ever returns zero, then {@link #read()} is
+ * invoked to read a single byte, and if it returns {@code -1}, then an
+ * {@code EOFException} is thrown. Any exception thrown by {@code skip()}
+ * or {@code read()} will be propagated.
  *
  * @param n the number of bytes to be skipped.
  * @throws EOFException if end of stream is encountered before the
@@ -596,20 +598,19 @@ public long skip(long n) throws IOException {
  * @since 12
  */
  public void skipNBytes(long n) throws IOException {
- if (n > 0) {
+ while (n > 0) {
  long ns = skip(n);
- if (ns >= 0 && ns < n) { // skipped too few bytes
+ if (ns > 0 && ns <= n) {
  // adjust number to skip
  n -= ns;
- // read until requested number skipped or EOS reached
- while (n > 0 && read() != -1) {
- n--;
- }
- // if not enough skipped, then EOFE
- if (n != 0) {
+ } else if (ns == 0) { // no bytes skipped
+ // read one byte to check for EOS
+ if (read() == -1) {
  throw new EOFException();
  }
- } else if (ns != n) { // skipped negative or too many bytes
+ // one byte read so decrement number to skip
+ n--;
+ } else { // skipped negative or too many bytes
  throw new IOException("Unable to skip exactly");
  }
  }

src/java.base/share/classes/java/lang/AbstractStringBuilder.java

@@ -1717,7 +1717,7 @@ private void putStringAt(int index, String str, int off, int end) {
  if (getCoder() != str.coder()) {
  inflate();
  }
- str.getBytes(value, off, index, coder, end);
+ str.getBytes(value, off, index, coder, end - off);
  }
 
  private void putStringAt(int index, String str) {

src/java.base/share/classes/java/lang/System.java

@@ -2221,6 +2221,9 @@ public void addReads(Module m1, Module m2) {
  public void addReadsAllUnnamed(Module m) {
  m.implAddReadsAllUnnamed();
  }
+ public void addExports(Module m, String pn) {
+ m.implAddExports(pn);
+ }
  public void addExports(Module m, String pn, Module other) {
  m.implAddExports(pn, other);
  }

src/java.base/share/classes/java/lang/module/Resolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2020, 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
@@ -560,7 +560,7 @@ private Map<ResolvedModule, Set<ResolvedModule>> makeGraph(Configuration cf) {
  for (ModuleDescriptor.Requires requires : descriptor.requires()) {
  String dn = requires.name();
 
- ResolvedModule m2 = null;
+ ResolvedModule m2;
  ModuleReference mref2 = nameToReference.get(dn);
  if (mref2 != null) {
  // same configuration
@@ -572,6 +572,14 @@ private Map<ResolvedModule, Set<ResolvedModule>> makeGraph(Configuration cf) {
  assert requires.modifiers().contains(Modifier.STATIC);
  continue;
  }
+
+ // m2 is automatic module in parent configuration => m1 reads
+ // all automatic modules that m2 reads.
+ if (m2.descriptor().isAutomatic()) {
+ m2.reads().stream()
+ .filter(d -> d.descriptor().isAutomatic())
+ .forEach(reads::add);
+ }
  }
 
  // m1 requires m2 => m1 reads m2
@@ -838,9 +846,7 @@ private ResolvedModule findInParent(String mn) {
  * Invokes the beforeFinder to find method to find the given module.
  */
  private ModuleReference findWithBeforeFinder(String mn) {
-
  return beforeFinder.find(mn).orElse(null);
-
  }
 
  /**

src/java.base/share/classes/java/lang/reflect/InvocationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2020, 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
@@ -25,6 +25,12 @@
 
 package java.lang.reflect;
 
+import jdk.internal.reflect.CallerSensitive;
+import jdk.internal.reflect.Reflection;
+
+import java.lang.invoke.MethodHandle;
+import java.util.Objects;
+
 /**
  * {@code InvocationHandler} is the interface implemented by
  * the <i>invocation handler</i> of a proxy instance.
@@ -92,4 +98,197 @@ public interface InvocationHandler {
  */
  public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable;
+
+ /**
+ * Invokes the specified default method on the given {@code proxy} instance with
+ * the given parameters. The given {@code method} must be a default method
+ * declared in a proxy interface of the {@code proxy}'s class or inherited
+ * from its superinterface directly or indirectly.
+ * <p>
+ * Invoking this method behaves as if {@code invokespecial} instruction executed
+ * from the proxy class, targeting the default method in a proxy interface.
+ * This is equivalent to the invocation:
+ * {@code X.super.m(A* a)} where {@code X} is a proxy interface and the call to
+ * {@code X.super::m(A*)} is resolved to the given {@code method}.
+ * <p>
+ * Examples: interface {@code A} and {@code B} both declare a default
+ * implementation of method {@code m}. Interface {@code C} extends {@code A}
+ * and inherits the default method {@code m} from its superinterface {@code A}.
+ *
+ * <blockquote><pre>{@code
+ * interface A {
+ * default T m(A a) { return t1; }
+ * }
+ * interface B {
+ * default T m(A a) { return t2; }
+ * }
+ * interface C extends A {}
+ * }</pre></blockquote>
+ *
+ * The following creates a proxy instance that implements {@code A}
+ * and invokes the default method {@code A::m}.
+ *
+ * <blockquote><pre>{@code
+ * Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { A.class },
+ * (o, m, params) -> {
+ * if (m.isDefault()) {
+ * // if it's a default method, invoke it
+ * return InvocationHandler.invokeDefault(o, m, params);
+ * }
+ * });
+ * }</pre></blockquote>
+ *
+ * If a proxy instance implements both {@code A} and {@code B}, both
+ * of which provides the default implementation of method {@code m},
+ * the invocation handler can dispatch the method invocation to
+ * {@code A::m} or {@code B::m} via the {@code invokeDefault} method.
+ * For example, the following code delegates the method invocation
+ * to {@code B::m}.
+ *
+ * <blockquote><pre>{@code
+ * Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { A.class, B.class },
+ * (o, m, params) -> {
+ * if (m.getName().equals("m")) {
+ * // invoke B::m instead of A::m
+ * Method bMethod = B.class.getMethod(m.getName(), m.getParameterTypes());
+ * return InvocationHandler.invokeDefault(o, bMethod, params);
+ * }
+ * });
+ * }</pre></blockquote>
+ *
+ * If a proxy instance implements {@code C} that inherits the default
+ * method {@code m} from its superinterface {@code A}, then
+ * the interface method invocation on {@code "m"} is dispatched to
+ * the invocation handler's {@link #invoke(Object, Method, Object[]) invoke}
+ * method with the {@code Method} object argument representing the
+ * default method {@code A::m}.
+ *
+ * <blockquote><pre>{@code
+ * Object proxy = Proxy.newProxyInstance(loader, new Class<?>[] { C.class },
+ * (o, m, params) -> {
+ * if (m.isDefault()) {
+ * // behaves as if calling C.super.m(params)
+ * return InvocationHandler.invokeDefault(o, m, params);
+ * }
+ * });
+ * }</pre></blockquote>
+ *
+ * The invocation of method {@code "m"} on this {@code proxy} will behave
+ * as if {@code C.super::m} is called and that is resolved to invoking
+ * {@code A::m}.
+ * <p>
+ * Adding a default method, or changing a method from abstract to default
+ * may cause an exception if an existing code attempts to call {@code invokeDefault}
+ * to invoke a default method.
+ *
+ * For example, if {@code C} is modified to implement a default method
+ * {@code m}:
+ *
+ * <blockquote><pre>{@code
+ * interface C extends A {
+ * default T m(A a) { return t3; }
+ * }
+ * }</pre></blockquote>
+ *
+ * The code above that creates proxy instance {@code proxy} with
+ * the modified {@code C} will run with no exception and it will result in
+ * calling {@code C::m} instead of {@code A::m}.
+ * <p>
+ * The following is another example that creates a proxy instance of {@code C}
+ * and the invocation handler calls the {@code invokeDefault} method
+ * to invoke {@code A::m}:
+ *
+ * <blockquote><pre>{@code
+ * C c = (C) Proxy.newProxyInstance(loader, new Class<?>[] { C.class },
+ * (o, m, params) -> {
+ * if (m.getName().equals("m")) {
+ * // IllegalArgumentException thrown as {@code A::m} is not a method
+ * // inherited from its proxy interface C
+ * Method aMethod = A.class.getMethod(m.getName(), m.getParameterTypes());
+ * return InvocationHandler.invokeDefault(o, aMethod params);
+ * }
+ * });
+ * c.m(...);
+ * }</pre></blockquote>
+ *
+ * The above code runs successfully with the old version of {@code C} and
+ * {@code A::m} is invoked. When running with the new version of {@code C},
+ * the above code will fail with {@code IllegalArgumentException} because
+ * {@code C} overrides the implementation of the same method and
+ * {@code A::m} is not accessible by a proxy instance.
+ *
+ * @apiNote
+ * The {@code proxy} parameter is of type {@code Object} rather than {@code Proxy}
+ * to make it easy for {@link InvocationHandler#invoke(Object, Method, Object[])
+ * InvocationHandler::invoke} implementation to call directly without the need
+ * of casting.
+ *
+ * @param proxy the {@code Proxy} instance on which the default method to be invoked
+ * @param method the {@code Method} instance corresponding to a default method
+ * declared in a proxy interface of the proxy class or inherited
+ * from its superinterface directly or indirectly
+ * @param args the parameters used for the method invocation; can be {@code null}
+ * if the number of formal parameters required by the method is zero.
+ * @return the value returned from the method invocation
+ *
+ * @throws IllegalArgumentException if any of the following conditions is {@code true}:
+ * <ul>
+ * <li>{@code proxy} is not {@linkplain Proxy#isProxyClass(Class)
+ * a proxy instance}; or</li>
+ * <li>the given {@code method} is not a default method declared
+ * in a proxy interface of the proxy class and not inherited from
+ * any of its superinterfaces; or</li>
+ * <li>the given {@code method} is overridden directly or indirectly by
+ * the proxy interfaces and the method reference to the named
+ * method never resolves to the given {@code method}; or</li>
+ * <li>the length of the given {@code args} array does not match the
+ * number of parameters of the method to be invoked; or</li>
+ * <li>any of the {@code args} elements fails the unboxing
+ * conversion if the corresponding method parameter type is
+ * a primitive type; or if, after possible unboxing, any of the
+ * {@code args} elements cannot be assigned to the corresponding
+ * method parameter type.</li>
+ * </ul>
+ * @throws IllegalAccessException if the declaring class of the specified
+ * default method is inaccessible to the caller class
+ * @throws NullPointerException if {@code proxy} or {@code method} is {@code null}
+ * @throws Throwable anything thrown by the default method
+
+ * @since 16
+ * @jvms 5.4.3. Method Resolution
+ */
+ @CallerSensitive
+ public static Object invokeDefault(Object proxy, Method method, Object... args)
+ throws Throwable {
+ Objects.requireNonNull(proxy);
+ Objects.requireNonNull(method);
+
+ // verify that the object is actually a proxy instance
+ if (!Proxy.isProxyClass(proxy.getClass())) {
+ throw new IllegalArgumentException("'proxy' is not a proxy instance");
+ }
+ if (!method.isDefault()) {
+ throw new IllegalArgumentException("\"" + method + "\" is not a default method");
+ }
+ @SuppressWarnings("unchecked")
+ Class<? extends Proxy> proxyClass = (Class<? extends Proxy>)proxy.getClass();
+
+ Class<?> intf = method.getDeclaringClass();
+ // access check on the default method
+ method.checkAccess(Reflection.getCallerClass(), intf, proxyClass, method.getModifiers());
+
+ MethodHandle mh = Proxy.defaultMethodHandle(proxyClass, method);
+ // invoke the super method
+ try {
+ // the args array can be null if the number of formal parameters required by
+ // the method is zero (consistent with Method::invoke)
+ Object[] params = args != null ? args : Proxy.EMPTY_ARGS;
+ return mh.invokeExact(proxy, params);
+ } catch (ClassCastException | NullPointerException e) {
+ throw new IllegalArgumentException(e.getMessage(), e);
+ } catch (Proxy.InvocationException e) {
+ // unwrap and throw the exception thrown by the default method
+ throw e.getCause();
+ }
+ }
 }

src/java.base/share/classes/java/lang/reflect/Method.java

@@ -31,6 +31,7 @@
 import jdk.internal.reflect.Reflection;
 import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.vm.annotation.IntrinsicCandidate;
+import jdk.internal.vm.annotation.Stable;
 import sun.reflect.annotation.ExceptionProxy;
 import sun.reflect.annotation.TypeNotPresentExceptionProxy;
 import sun.reflect.generics.repository.MethodRepository;
@@ -66,6 +67,7 @@
  * @since 1.1
  */
 public final class Method extends Executable {
+ @Stable
  private Class<?> clazz;
  private int slot;
  // This is guaranteed to be interned by the VM in the 1.4
@@ -74,6 +76,7 @@ public final class Method extends Executable {
  private Class<?> returnType;
  private Class<?>[] parameterTypes;
  private Class<?>[] exceptionTypes;
+ @Stable
  private int modifiers;
  // Generics and annotations support
  private transient String signature;