jdk8-mips64-public/nashorn: src/jdk/nashorn/internal/runtime/AccessorProperty.java@5759f600fcf7 (annotated)

src/jdk/nashorn/internal/runtime/AccessorProperty.java@5759f600fcf7 (annotated)

src/jdk/nashorn/internal/runtime/AccessorProperty.java

Sat, 09 Mar 2013 21:49:32 +0530

author: sundar
date: Sat, 09 Mar 2013 21:49:32 +0530
changeset 133: 5759f600fcf7
parent 131: fe5211fc3114
child 137: e15806b9d716
permissions: -rw-r--r--

8009559: clean up method handle lookup code.
Reviewed-by: ahgross, jlaskey, attila, sundar

 /*
  * Copyright (c) 2010, 2013, 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.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * 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 jdk.nashorn.internal.runtime;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.ACCESSOR_TYPES;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.DEBUG_FIELDS;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.LOG;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.OBJECT_FIELDS_ONLY;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.PRIMITIVE_TYPE;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createGetter;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createGuardBoxedPrimitiveSetter;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createSetter;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getAccessorType;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getAccessorTypeIndex;
 import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getNumberOfAccessorTypes;
 import static jdk.nashorn.internal.lookup.Lookup.MH;
 import static jdk.nashorn.internal.lookup.MethodHandleFactory.stripName;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import jdk.nashorn.internal.codegen.ObjectClassGenerator;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.lookup.Lookup;
 import jdk.nashorn.internal.lookup.MethodHandleFactory;
 /**
  * An AccessorProperty is the most generic property type. An AccessorProperty is
  * represented as fields in a ScriptObject class.
  *
  * @see SpillProperty
  */
 public class AccessorProperty extends Property {
     private static final MethodHandle REPLACE_MAP = findOwnMH("replaceMap", Object.class, Object.class, PropertyMap.class, String.class, Class.class, Class.class);
     private static final int NOOF_TYPES = getNumberOfAccessorTypes();
     /** Property getter cache */
     private MethodHandle[] getters = new MethodHandle[NOOF_TYPES];
     private static final MethodType[] ACCESSOR_GETTER_TYPES = new MethodType[NOOF_TYPES];
     private static final MethodType[] ACCESSOR_SETTER_TYPES = new MethodType[NOOF_TYPES];
     /** Seed getter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */
     private MethodHandle primitiveGetter;
     /** Seed setter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */
     private MethodHandle primitiveSetter;
     /** Seed getter for the Object version of this field */
     private MethodHandle objectGetter;
     /** Seed setter for the Object version of this field */
     private MethodHandle objectSetter;
     /**
      * Current type of this object, in object only mode, this is an Object.class. In dual-fields mode
      * null means undefined, and primitive types are allowed. The reason a special type is used for
      * undefined, is that are no bits left to represent it in primitive types
      */
     private Class<?> currentType;
     static {
         for (int i = 0; i < NOOF_TYPES; i++) {
             final Type type = ACCESSOR_TYPES.get(i);
             ACCESSOR_GETTER_TYPES[i] = MH.type(type.getTypeClass(), Object.class);
             ACCESSOR_SETTER_TYPES[i] = MH.type(void.class, Object.class, type.getTypeClass());
         }
     }
     /**
      * Delegate constructor. This is used when adding properties to the Global scope, which
      * is necessary for outermost levels in a script (the ScriptObject is represented by
      * a JO-prefixed ScriptObject class, but the properties need to be in the Global scope
      * and are thus rebound with that as receiver
      *
      * @param property  accessor property to rebind
      * @param delegate  delegate script object to rebind receiver to
      */
     public AccessorProperty(final AccessorProperty property, final ScriptObject delegate) {
         this(property);
         this.getters = new MethodHandle[NOOF_TYPES];
         this.primitiveGetter = bindTo(primitiveGetter, delegate);
         this.primitiveSetter = bindTo(primitiveSetter, delegate);
         this.objectGetter    = bindTo(objectGetter, delegate);
         this.objectSetter    = bindTo(objectSetter, delegate);
         setCurrentType(property.getCurrentType());
     }
     /**
      * Constructor. Similar to the constructor with both primitive getters and setters, the difference
      * here being that only one getter and setter (setter is optional for non writable fields) is given
      * to the constructor, and the rest are created from those. Used e.g. by Nasgen classes
      *
      * @param key    the property key
      * @param flags  the property flags
      * @param slot   the property field number or spill slot
      * @param getter the property getter
      * @param setter the property setter or null if non writable, non configurable
      */
     public AccessorProperty(final String key, final int flags, final int slot, final MethodHandle getter, final MethodHandle setter) {
         super(key, flags, slot);
         // we don't need to prep the setters these will never be invalidated as this is a nasgen
         // or known type getter/setter. No invalidations will take place
         final Class<?> getterType = getter.type().returnType();
         final Class<?> setterType = setter == null ? null : setter.type().parameterType(1);
         assert setterType == null || setterType == getterType;
         if (getterType.isPrimitive()) {
             for (int i = 0; i < NOOF_TYPES; i++) {
                 getters[i] = MH.asType(
                     Lookup.filterReturnType(
                         getter,
                         getAccessorType(i).getTypeClass()),
                     ACCESSOR_GETTER_TYPES[i]);
             }
         } else {
             //this will work as the object setter and getter will be converted appropriately
             objectGetter = getter;
             objectSetter = setter;
         }
         setCurrentType(getterType);
     }
     /**
      * Constructor for dual field AccessorPropertys.
      *
      * @param key              property key
      * @param flags            property flags
      * @param structure        structure for objects associated with this property
      * @param slot             property field number or spill slot
      */
     public AccessorProperty(final String key, final int flags, final Class<?> structure, final int slot) {
         super(key, flags, slot);
         /*
          *
          * primitiveGetter and primitiveSetter are only used in dual fields mode. Setting them to null also
          * works in dual field mode, it only means that the property never has a primitive
          * representation.
          */
         primitiveGetter = null;
         primitiveSetter = null;
         final MethodHandles.Lookup lookup = MethodHandles.lookup();
         if (isParameter() && hasArguments()) {
             final MethodHandle arguments   = MH.getter(MethodHandles.lookup(), structure, "arguments", Object.class);
             final MethodHandle argumentsSO = MH.asType(arguments, arguments.type().changeReturnType(ScriptObject.class));
             objectGetter = MH.insertArguments(MH.filterArguments(ScriptObject.GET_ARGUMENT.methodHandle(), 0, argumentsSO), 1, slot);
             objectSetter = MH.insertArguments(MH.filterArguments(ScriptObject.SET_ARGUMENT.methodHandle(), 0, argumentsSO), 1, slot);
         } else {
             final String fieldNameObject    = ObjectClassGenerator.getFieldName(slot, Type.OBJECT);
             final String fieldNamePrimitive = ObjectClassGenerator.getFieldName(slot, ObjectClassGenerator.PRIMITIVE_TYPE);
             objectGetter = MH.getter(lookup, structure, fieldNameObject, Type.OBJECT.getTypeClass());
             objectSetter = MH.setter(lookup, structure, fieldNameObject, Type.OBJECT.getTypeClass());
             if (!OBJECT_FIELDS_ONLY) {
                 primitiveGetter = MH.getter(lookup, structure, fieldNamePrimitive, PRIMITIVE_TYPE.getTypeClass());
                 primitiveSetter = MH.setter(lookup, structure, fieldNamePrimitive, PRIMITIVE_TYPE.getTypeClass());
             }
         }
         Class<?> initialType = null;
         if (OBJECT_FIELDS_ONLY || isAlwaysObject()) {
             initialType = Object.class;
         } else if (!canBePrimitive()) {
             info(key + " cannot be primitive");
             initialType = Object.class;
         } else {
             info(key + " CAN be primitive");
             if (!canBeUndefined()) {
                 info(key + " is always defined");
                 initialType = int.class; //double works too for less type invalidation, but this requires experimentation, e.g. var x = 17; x += 2 will turn it into double now because of lack of range analysis
             }
         }
         // is always object means "is never initialized to undefined, and always of object type
         setCurrentType(initialType);
     }
     /**
      * Copy constructor
      *
      * @param property  source property
      */
     protected AccessorProperty(final AccessorProperty property) {
         super(property);
         this.getters         = property.getters;
         this.primitiveGetter = property.primitiveGetter;
         this.primitiveSetter = property.primitiveSetter;
         this.objectGetter    = property.objectGetter;
         this.objectSetter    = property.objectSetter;
         setCurrentType(property.getCurrentType());
     }
     private static MethodHandle bindTo(final MethodHandle mh, final Object receiver) {
         if (mh == null) {
             return null;
         }
         return MH.dropArguments(MH.bindTo(mh, receiver), 0, Object.class);
     }
     @Override
     protected Property copy() {
         return new AccessorProperty(this);
     }
     @Override
     public MethodHandle getGetter(final Class<?> type) {
         final int i = getAccessorTypeIndex(type);
         if (getters[i] == null) {
             getters[i] = debug(
                 MH.asType(
                     createGetter(
                         currentType,
                         type,
                         primitiveGetter,
                         objectGetter),
                     ACCESSOR_GETTER_TYPES[i]),
                 currentType,
                 type,
                 "get");
         }
         return getters[i];
     }
     private Property getWiderProperty(final Class<?> type) {
         final AccessorProperty newProperty = new AccessorProperty(this);
         newProperty.invalidate(type);
         return newProperty;
     }
     private PropertyMap getWiderMap(final PropertyMap oldMap, final Property newProperty) {
         final PropertyMap newMap = oldMap.replaceProperty(this, newProperty);
         assert oldMap.size() > 0;
         assert newMap.size() == oldMap.size();
         return newMap;
     }
     // the final three arguments are for debug printout purposes only
     @SuppressWarnings("unused")
     private static Object replaceMap(final Object sobj, final PropertyMap newMap, final String key, final Class<?> oldType, final Class<?> newType) {
         if (DEBUG_FIELDS) {
             final PropertyMap oldMap = ((ScriptObject)sobj).getMap();
             info("Type change for '" + key + "' " + oldType + "=>" + newType);
             finest("setting map " + sobj + " from " + Debug.id(oldMap) + " to " + Debug.id(newMap) + " " + oldMap + " => " + newMap);
         }
         ((ScriptObject)sobj).setMap(newMap);
         return sobj;
     }
     private MethodHandle generateSetter(final Class<?> forType, final Class<?> type) {
         MethodHandle mh = createSetter(forType, type, primitiveSetter, objectSetter);
         mh = MH.asType(mh, ACCESSOR_SETTER_TYPES[getAccessorTypeIndex(type)]); //has to be the case for invokeexact to work in ScriptObject
         mh = debug(mh, currentType, type, "set");
         return mh;
     }
     @Override
     public MethodHandle getSetter(final Class<?> type, final PropertyMap currentMap) {
         final int i            = getAccessorTypeIndex(type);
         final int ci           = currentType == null ? -1 : getAccessorTypeIndex(currentType);
         final Class<?> forType = currentType == null ? type : currentType;
         //if we are asking for an object setter, but are still a primitive type, we might try to box it
         if (needsInvalidator(i, ci)) {
             final Property     newProperty = getWiderProperty(type);
             final PropertyMap  newMap      = getWiderMap(currentMap, newProperty);
             final MethodHandle widerSetter = newProperty.getSetter(type, newMap);
             final MethodHandle explodeTypeSetter = MH.filterArguments(widerSetter, 0, MH.insertArguments(REPLACE_MAP, 1, newMap, getKey(), currentType, type));
             if (currentType != null && currentType.isPrimitive() && type == Object.class) {
                 //might try a box check on this to avoid widening field to object storage
                 return createGuardBoxedPrimitiveSetter(currentType, generateSetter(currentType, currentType), explodeTypeSetter);
             }
             return explodeTypeSetter;
         }
         return generateSetter(forType, type);
     }
     @Override
     public boolean canChangeType() {
         if (OBJECT_FIELDS_ONLY) {
             return false;
         }
         return currentType != Object.class && (isConfigurable() || isWritable());
     }
     private boolean needsInvalidator(final int ti, final int fti) {
         return canChangeType() && ti > fti;
     }
     private void invalidate(final Class<?> newType) {
         getters = new MethodHandle[NOOF_TYPES];
         setCurrentType(newType);
     }
     private static void finest(final String str) {
         if (DEBUG_FIELDS) {
             LOG.finest(str);
         }
     }
     private static void info(final String str) {
         if (DEBUG_FIELDS) {
             LOG.info(str);
         }
     }
     private MethodHandle debug(final MethodHandle mh, final Class<?> forType, final Class<?> type, final String tag) {
         if (DEBUG_FIELDS) {
            final MethodHandle mhd = MethodHandleFactory.addDebugPrintout(
                LOG,
                mh,
                tag + " '" + getKey() + "' (property="+ Debug.id(this) + ", forType=" + stripName(forType) + ", type=" + stripName(type) + ')');
            return mhd;
         }
         return mh;
     }
     private void setCurrentType(final Class<?> currentType) {
         this.currentType = currentType;
     }
     @Override
     public Class<?> getCurrentType() {
         return currentType;
     }
     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
         return MH.findStatic(MethodHandles.lookup(), AccessorProperty.class, name, MH.type(rtype, types));
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/internal/runtime/AccessorProperty.java@5759f600fcf7 (annotated)

src/jdk/nashorn/internal/runtime/AccessorProperty.java