src/share/classes/java/lang/invoke/MethodHandleImpl.java

rev 10092 : 8037209: Improvements and cleanups to bytecode assembly for lambda forms
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com
rev 10093 : 8038261: JSR292: cache and reuse typed array accessors
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com

*** 50,80 ****
          // Trigger selected static initializations.
          MemberName.Factory.INSTANCE.getClass();
      }
  
      static MethodHandle makeArrayElementAccessor(Class<?> arrayClass, boolean isSetter) {
          if (!arrayClass.isArray())
              throw newIllegalArgumentException("not an array: "+arrayClass);
!         MethodHandle accessor = ArrayAccessor.getAccessor(arrayClass, isSetter);
!         MethodType srcType = accessor.type().erase();
!         MethodType lambdaType = srcType.invokerType();
!         Name[] names = arguments(1, lambdaType);
!         Name[] args  = Arrays.copyOfRange(names, 1, 1 + srcType.parameterCount());
!         names[names.length - 1] = new Name(accessor.asType(srcType), (Object[]) args);
!         LambdaForm form = new LambdaForm("getElement", lambdaType.parameterCount(), names);
!         MethodHandle mh = SimpleMethodHandle.make(srcType, form);
!         if (ArrayAccessor.needCast(arrayClass)) {
!             mh = mh.bindTo(arrayClass);
          }
-         mh = mh.asType(ArrayAccessor.correctType(arrayClass, isSetter));
          return mh;
      }
  
      static final class ArrayAccessor {
          /// Support for array element access
!         static final HashMap<Class<?>, MethodHandle> GETTER_CACHE = new HashMap<>();  // TODO use it
!         static final HashMap<Class<?>, MethodHandle> SETTER_CACHE = new HashMap<>();  // TODO use it
  
          static int     getElementI(int[]     a, int i)            { return              a[i]; }
          static long    getElementJ(long[]    a, int i)            { return              a[i]; }
          static float   getElementF(float[]   a, int i)            { return              a[i]; }
          static double  getElementD(double[]  a, int i)            { return              a[i]; }
--- 50,107 ----
          // Trigger selected static initializations.
          MemberName.Factory.INSTANCE.getClass();
      }
  
      static MethodHandle makeArrayElementAccessor(Class<?> arrayClass, boolean isSetter) {
+         if (arrayClass == Object[].class)
+             return (isSetter ? ArrayAccessor.OBJECT_ARRAY_SETTER : ArrayAccessor.OBJECT_ARRAY_GETTER);
          if (!arrayClass.isArray())
              throw newIllegalArgumentException("not an array: "+arrayClass);
!         MethodHandle[] cache = ArrayAccessor.TYPED_ACCESSORS.get(arrayClass);
!         int cacheIndex = (isSetter ? ArrayAccessor.SETTER_INDEX : ArrayAccessor.GETTER_INDEX);
!         MethodHandle mh = cache[cacheIndex];
!         if (mh != null)  return mh;
!         mh = ArrayAccessor.getAccessor(arrayClass, isSetter);
!         MethodType correctType = ArrayAccessor.correctType(arrayClass, isSetter);
!         if (mh.type() != correctType) {
!             assert(mh.type().parameterType(0) == Object[].class);
!             assert((isSetter ? mh.type().parameterType(2) : mh.type().returnType()) == Object.class);
!             assert(isSetter || correctType.parameterType(0).getComponentType() == correctType.returnType());
!             // safe to view non-strictly, because element type follows from array type
!             mh = mh.viewAsType(correctType);
!         }
!         // Atomically update accessor cache.
!         synchronized(cache) {
!             if (cache[cacheIndex] == null) {
!                 cache[cacheIndex] = mh;
!             } else {
!                 // Throw away newly constructed accessor and use cached version.
!                 mh = cache[cacheIndex];
!             }
          }
          return mh;
      }
  
      static final class ArrayAccessor {
          /// Support for array element access
!         static final int GETTER_INDEX = 0, SETTER_INDEX = 1, INDEX_LIMIT = 2;
!         static final ClassValue<MethodHandle[]> TYPED_ACCESSORS
!                 = new ClassValue<MethodHandle[]>() {
!                     @Override
!                     protected MethodHandle[] computeValue(Class<?> type) {
!                         return new MethodHandle[INDEX_LIMIT];
!                     }
!                 };
!         static final MethodHandle OBJECT_ARRAY_GETTER, OBJECT_ARRAY_SETTER;
!         static {
!             MethodHandle[] cache = TYPED_ACCESSORS.get(Object[].class);
!             cache[GETTER_INDEX] = OBJECT_ARRAY_GETTER = getAccessor(Object[].class, false);
!             cache[SETTER_INDEX] = OBJECT_ARRAY_SETTER = getAccessor(Object[].class, true);
! 
!             assert(InvokerBytecodeGenerator.isStaticallyInvocable(ArrayAccessor.OBJECT_ARRAY_GETTER.internalMemberName()));
!             assert(InvokerBytecodeGenerator.isStaticallyInvocable(ArrayAccessor.OBJECT_ARRAY_SETTER.internalMemberName()));
!         }
  
          static int     getElementI(int[]     a, int i)            { return              a[i]; }
          static long    getElementJ(long[]    a, int i)            { return              a[i]; }
          static float   getElementF(float[]   a, int i)            { return              a[i]; }
          static double  getElementD(double[]  a, int i)            { return              a[i]; }
*** 92,140 ****
          static void    setElementB(byte[]    a, int i, byte    x) {              a[i] = x; }
          static void    setElementS(short[]   a, int i, short   x) {              a[i] = x; }
          static void    setElementC(char[]    a, int i, char    x) {              a[i] = x; }
          static void    setElementL(Object[]  a, int i, Object  x) {              a[i] = x; }
  
-         static Object  getElementL(Class<?> arrayClass, Object[] a, int i)           { arrayClass.cast(a); return a[i]; }
-         static void    setElementL(Class<?> arrayClass, Object[] a, int i, Object x) { arrayClass.cast(a); a[i] = x; }
- 
-         // Weakly typed wrappers of Object[] accessors:
-         static Object  getElementL(Object    a, int i)            { return getElementL((Object[])a, i); }
-         static void    setElementL(Object    a, int i, Object  x) {        setElementL((Object[]) a, i, x); }
-         static Object  getElementL(Object   arrayClass, Object a, int i)             { return getElementL((Class<?>) arrayClass, (Object[])a, i); }
-         static void    setElementL(Object   arrayClass, Object a, int i, Object x)   {        setElementL((Class<?>) arrayClass, (Object[])a, i, x); }
- 
-         static boolean needCast(Class<?> arrayClass) {
-             Class<?> elemClass = arrayClass.getComponentType();
-             return !elemClass.isPrimitive() && elemClass != Object.class;
-         }
          static String name(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
              return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
          }
-         static final boolean USE_WEAKLY_TYPED_ARRAY_ACCESSORS = false;  // FIXME: decide
          static MethodType type(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              Class<?> arrayArgClass = arrayClass;
              if (!elemClass.isPrimitive()) {
                  arrayArgClass = Object[].class;
!                 if (USE_WEAKLY_TYPED_ARRAY_ACCESSORS)
!                     arrayArgClass = Object.class;
              }
-             if (!needCast(arrayClass)) {
                  return !isSetter ?
                      MethodType.methodType(elemClass,  arrayArgClass, int.class) :
                      MethodType.methodType(void.class, arrayArgClass, int.class, elemClass);
-             } else {
-                 Class<?> classArgClass = Class.class;
-                 if (USE_WEAKLY_TYPED_ARRAY_ACCESSORS)
-                     classArgClass = Object.class;
-                 return !isSetter ?
-                     MethodType.methodType(Object.class, classArgClass, arrayArgClass, int.class) :
-                     MethodType.methodType(void.class,   classArgClass, arrayArgClass, int.class, Object.class);
-             }
          }
          static MethodType correctType(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              return !isSetter ?
                      MethodType.methodType(elemClass,  arrayClass, int.class) :
--- 119,143 ----
          static void    setElementB(byte[]    a, int i, byte    x) {              a[i] = x; }
          static void    setElementS(short[]   a, int i, short   x) {              a[i] = x; }
          static void    setElementC(char[]    a, int i, char    x) {              a[i] = x; }
          static void    setElementL(Object[]  a, int i, Object  x) {              a[i] = x; }
  
          static String name(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              if (elemClass == null)  throw newIllegalArgumentException("not an array", arrayClass);
              return (!isSetter ? "getElement" : "setElement") + Wrapper.basicTypeChar(elemClass);
          }
          static MethodType type(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              Class<?> arrayArgClass = arrayClass;
              if (!elemClass.isPrimitive()) {
                  arrayArgClass = Object[].class;
!                 elemClass = Object.class;
              }
              return !isSetter ?
                      MethodType.methodType(elemClass,  arrayArgClass, int.class) :
                      MethodType.methodType(void.class, arrayArgClass, int.class, elemClass);
          }
          static MethodType correctType(Class<?> arrayClass, boolean isSetter) {
              Class<?> elemClass = arrayClass.getComponentType();
              return !isSetter ?
                      MethodType.methodType(elemClass,  arrayClass, int.class) :