RFR: 5043030 (reflect) unnecessary object creation in reflection (original) (raw)

Sat Jun 21 22:00:41 UTC 2014

   //  *  [UTF-8] "valueOf"
   //  *  [UTF-8] "java/lang/Boolean"
   //  *  [CONSTANT_Class_info] for above
   //  *  [UTF-8] "(Z)V"
   //  *  [UTF-8] "(Z)Ljava/lang/Boolean;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "booleanValue"
   //  *  [UTF-8] "(B)V"
   //  *  [UTF-8] "(B)Ljava/lang/Byte;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "byteValue"
   //  *  [UTF-8] "(C)V"
   //  *  [UTF-8] "(C)Ljava/lang/Character;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "charValue"
   //  *  [UTF-8] "(D)V"
   //  *  [UTF-8] "(D)Ljava/lang/Double;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "doubleValue"
   //  *  [UTF-8] "(F)V"
   //  *  [UTF-8] "(F)Ljava/lang/Float;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "floatValue"
   //  *  [UTF-8] "(I)V"
   //  *  [UTF-8] "(I)Ljava/lang/Integer;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "intValue"
   //  *  [UTF-8] "(J)V"
   //  *  [UTF-8] "(J)Ljava/lang/Long;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "longValue"
   //  *  [UTF-8] "(S)V"
   //  *  [UTF-8] "(S)Ljava/lang/Short;"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   //  *  [UTF-8] "shortValue"
   //  *  [UTF-8] "()S"
   //  *  [CONSTANT_NameAndType_info] for above
   //  *  [CONSTANT_Methodref_info] for above
   // valueOf-method name
   asm.emitConstantPoolUTF8("valueOf");
   valueOfIdx = asm.cpi();
    // Boolean
    asm.emitConstantPoolUTF8("java/lang/Boolean");
    asm.emitConstantPoolClass(asm.cpi());
    booleanIdx = asm.cpi();
   asm.emitConstantPoolUTF8("(Z)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(Z)Ljava/lang/Boolean;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   booleanCtorIdx = asm.cpi();
   booleanBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("booleanValue");
   asm.emitConstantPoolUTF8("()Z");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(B)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(B)Ljava/lang/Byte;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   byteCtorIdx = asm.cpi();
   byteBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("byteValue");
   asm.emitConstantPoolUTF8("()B");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(C)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(C)Ljava/lang/Character;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   characterCtorIdx = asm.cpi();
   characterBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("charValue");
   asm.emitConstantPoolUTF8("()C");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(D)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(D)Ljava/lang/Double;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   doubleCtorIdx = asm.cpi();
   doubleBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("doubleValue");
   asm.emitConstantPoolUTF8("()D");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(F)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(F)Ljava/lang/Float;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   floatCtorIdx = asm.cpi();
   floatBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("floatValue");
   asm.emitConstantPoolUTF8("()F");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(I)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(I)Ljava/lang/Integer;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   integerCtorIdx = asm.cpi();
   integerBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("intValue");
   asm.emitConstantPoolUTF8("()I");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(J)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(J)Ljava/lang/Long;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   longCtorIdx = asm.cpi();
   longBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("longValue");
   asm.emitConstantPoolUTF8("()J");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
   asm.emitConstantPoolUTF8("(S)V");
   asm.emitConstantPoolNameAndType(initIdx, asm.cpi());
   asm.emitConstantPoolUTF8("(S)Ljava/lang/Short;");
   asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi());
   asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi());
   shortCtorIdx = asm.cpi();
   shortBoxIdx = asm.cpi();
   asm.emitConstantPoolUTF8("shortValue");
   asm.emitConstantPoolUTF8("()S");
   asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi());
       return booleanCtorIdx;
       return booleanBoxIdx;
   } else if (type == Byte.TYPE) {
       return byteCtorIdx;
       return byteBoxIdx;
   } else if (type == Character.TYPE) {
       return characterCtorIdx;
       return characterBoxIdx;
   } else if (type == Double.TYPE) {
       return doubleCtorIdx;
       return doubleBoxIdx;
   } else if (type == Float.TYPE) {
       return floatCtorIdx;
       return floatBoxIdx;
   } else if (type == Integer.TYPE) {
       return integerCtorIdx;
       return integerBoxIdx;
   } else if (type == Long.TYPE) {
       return longCtorIdx;
       return longBoxIdx;
   } else if (type == Short.TYPE) {
       return shortCtorIdx;
       return shortBoxIdx;
   }
   throw new InternalError("Should have found primitive type");
           cb.opc_invokespecial(ctorIndexForPrimitiveType(returnType),
                                typeSizeInStackSlots(returnType),
                                0);
           cb.opc_invokestatic(boxingMethodForPrimitiveType(returnType),
                               typeSizeInStackSlots(returnType),
                               0);
       } else if (returnType == Void.TYPE) {
           cb.opc_aconst_null();
       }
 public Object get(Object obj) throws IllegalArgumentException {
   return new Boolean(getBoolean(obj));
   return Boolean.valueOf(getBoolean(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Byte(getByte(obj));
   return Byte.valueOf(getByte(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Character(getChar(obj));
   return Character.valueOf(getChar(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Double(getDouble(obj));
   return Double.valueOf(getDouble(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Float(getFloat(obj));
   return Float.valueOf(getFloat(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Integer(getInt(obj));
   return Integer.valueOf(getInt(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Long(getLong(obj));
   return Long.valueOf(getLong(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Boolean(getBoolean(obj));
   return Boolean.valueOf(getBoolean(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Byte(getByte(obj));
   return Byte.valueOf(getByte(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Character(getChar(obj));
   return Character.valueOf(getChar(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Double(getDouble(obj));
   return Double.valueOf(getDouble(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Float(getFloat(obj));
   return Float.valueOf(getFloat(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Integer(getInt(obj));
   return Integer.valueOf(getInt(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Long(getLong(obj));
   return Long.valueOf(getLong(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Short(getShort(obj));
   return Short.valueOf(getShort(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Boolean(getBoolean(obj));
   return Boolean.valueOf(getBoolean(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Byte(getByte(obj));
   return Byte.valueOf(getByte(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Character(getChar(obj));
   return Character.valueOf(getChar(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Double(getDouble(obj));
   return Double.valueOf(getDouble(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Float(getFloat(obj));
   return Float.valueOf(getFloat(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Integer(getInt(obj));
   return Integer.valueOf(getInt(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Long(getLong(obj));
   return Long.valueOf(getLong(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Short(getShort(obj));
   return Short.valueOf(getShort(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Short(getShort(obj));
   return Short.valueOf(getShort(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Boolean(getBoolean(obj));
   return Boolean.valueOf(getBoolean(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Byte(getByte(obj));
   return Byte.valueOf(getByte(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Character(getChar(obj));
   return Character.valueOf(getChar(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Double(getDouble(obj));
   return Double.valueOf(getDouble(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Float(getFloat(obj));
   return Float.valueOf(getFloat(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Integer(getInt(obj));
   return Integer.valueOf(getInt(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Long(getLong(obj));
   return Long.valueOf(getLong(obj));
 public Object get(Object obj) throws IllegalArgumentException {
   return new Short(getShort(obj));
   return Short.valueOf(getShort(obj));
     use of the same caching mechanism as used for autoboxing
     when wrapping values of the primitive types.
   testUnsafeStaticFieldAccessors();
   testUnsafeQualifiedStaticFieldAccessors();
   testUnsafeFieldAccessors();
   testUnsafeQualifiedFieldAccessors();
   testFieldAccessors(true, false);
   testFieldAccessors(true, true);
   testFieldAccessors(false, false);
   testFieldAccessors(false, true);
   boolean checkVolatile)
   // Boolean#valueOf test
   testField(Boolean.TYPE, Boolean.FALSE, checkStatic, checkVolatile);
   testField(Boolean.TYPE, Boolean.TRUE, checkStatic, checkVolatile);
   // Byte#valueOf test
   for (int b = Byte.MIN_VALUE; b < (Byte.MAX_VALUE + 1); b++) {
       testField(Byte.TYPE, Byte.valueOf((byte) b), checkStatic, checkVolatile);
   }
   // Character#valueOf test
   for (char c = '\u0000'; c <= '\u007F'; c++) {
       testField(Character.TYPE, Character.valueOf(c), checkStatic, checkVolatile);
   }
   // Integer#valueOf test
   for (int i = -128; i <= 127; i++) {
       testField(Integer.TYPE, Integer.valueOf(i), checkStatic, checkVolatile);
   }
   // Long#valueOf test
   for (long l = -128L; l <= 127L; l++) {
       testField(Long.TYPE, Long.valueOf(l), checkStatic, checkVolatile);
   }
   // Short#valueOf test
   for (short s = -128; s <= 127; s++) {
       testField(Short.TYPE, Short.valueOf(s), checkStatic, checkVolatile);
   }
   boolean checkStatic, boolean checkVolatile)
   String fieldName = primType.getName();
   if (checkStatic) {
       fieldName += "Static";
   }
   if (checkVolatile) {
       fieldName += "Volatile";
   }
   fieldName += "Field";
   try {
       Field field = TestFieldReflectValueOf.class.getDeclaredField(fieldName);
       field.setAccessible(true);
       TestFieldReflectValueOf obj = new TestFieldReflectValueOf();
       field.set(obj, wrappedValue);
       Object result = field.get(obj);
       if (result != wrappedValue) {
           throw new RuntimeException("The value " + wrappedValue
               + " is not cached for the type " + primType);
       }
   } catch (  NoSuchFieldException | SecurityException
            | IllegalAccessException | IllegalArgumentException e)
   {
       throw new RuntimeException(e);
   }
     makes use of the same caching mechanism as used for autoboxing
     when wrapping returned values of the primitive types.
   // When the inflation is disabled we compare values using "=="
   // as the returned values of the primitive types should be cached
   // by the same mechanism as used for autoboxing. When the inflation
   // is enabled we use "equals()"-method to compare values as the native
   // code still creates new instances to wrap values of the primitive
   // types.
   boolean checkIdentity = Boolean.getBoolean("sun.reflect.noInflation");
   // Boolean#valueOf test
   testMethod(Boolean.TYPE, Boolean.FALSE, checkIdentity);
   testMethod(Boolean.TYPE, Boolean.TRUE, checkIdentity);
   // Byte#valueOf test
   for (int b = Byte.MIN_VALUE; b < (Byte.MAX_VALUE + 1); b++) {
       testMethod(Byte.TYPE, Byte.valueOf((byte) b), checkIdentity);
   }
   // Character#valueOf test
   for (char c = '\u0000'; c <= '\u007F'; c++) {
       testMethod(Character.TYPE, Character.valueOf(c), checkIdentity);
   }
   // Integer#valueOf test
   for (int i = -128; i <= 127; i++) {
       testMethod(Integer.TYPE, Integer.valueOf(i), checkIdentity);
   }
   // Long#valueOf test
   for (long l = -128L; l <= 127L; l++) {
       testMethod(Long.TYPE, Long.valueOf(l), checkIdentity);
   }
   // Short#valueOf test
   for (short s = -128; s <= 127; s++) {
       testMethod(Short.TYPE, Short.valueOf(s), checkIdentity);
   }
       boolean checkIdentity)
   String methodName = primType.getName() + "Method";
   try {
       Method method = TestMethodReflectValueOf.class.getMethod(methodName, primType);
       Object result = method.invoke(new TestMethodReflectValueOf(), wrappedValue);
       if (checkIdentity) {
           if (result != wrappedValue) {
               throw new RuntimeException("The value " + wrappedValue
                   + " is not cached for the type " + primType);
           }
       } else {
           if (!result.equals(wrappedValue)) {
               throw new RuntimeException("The result value " + result
                   + " is not equal to the expected value " 
                   + wrappedValue + " for the type " + primType);
           }
       }
   } catch (  NoSuchMethodException | SecurityException
            | IllegalAccessException | IllegalArgumentException
            | InvocationTargetException e)
   {
       throw new RuntimeException(e);
   }
   return value;
   return value;
   return value;
   return value;
   return value;
   return value;