author | hannesw |
Wed, 02 Apr 2014 18:26:57 +0200 | |
changeset 23767 | 7c0614b75e23 |
parent 23372 | 09707b3e5fb0 |
child 24769 | de4dcfa9380f |
permissions | -rw-r--r-- |
16147 | 1 |
/* |
16151 | 2 |
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. |
16147 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. Oracle designates this |
|
8 |
* particular file as subject to the "Classpath" exception as provided |
|
9 |
* by Oracle in the LICENSE file that accompanied this code. |
|
10 |
* |
|
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
24 |
*/ |
|
25 |
||
26 |
package jdk.nashorn.internal.runtime; |
|
27 |
||
16240
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
28 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.ACCESSOR_TYPES; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
29 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.DEBUG_FIELDS; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
30 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.LOG; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
31 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.OBJECT_FIELDS_ONLY; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
32 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.PRIMITIVE_TYPE; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
33 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createGetter; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
34 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createGuardBoxedPrimitiveSetter; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
35 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.createSetter; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
36 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getAccessorType; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
37 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getAccessorTypeIndex; |
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
38 |
import static jdk.nashorn.internal.codegen.ObjectClassGenerator.getNumberOfAccessorTypes; |
16277 | 39 |
import static jdk.nashorn.internal.lookup.Lookup.MH; |
40 |
import static jdk.nashorn.internal.lookup.MethodHandleFactory.stripName; |
|
16147 | 41 |
|
23767 | 42 |
import java.io.IOException; |
43 |
import java.io.ObjectInputStream; |
|
44 |
import java.io.Serializable; |
|
16147 | 45 |
import java.lang.invoke.MethodHandle; |
46 |
import java.lang.invoke.MethodHandles; |
|
47 |
import java.lang.invoke.MethodType; |
|
16240
e1468b33e201
8008239: Unpublicized parts of the code generator package that were only package internal.
lagergren
parents:
16224
diff
changeset
|
48 |
import jdk.nashorn.internal.codegen.ObjectClassGenerator; |
16147 | 49 |
import jdk.nashorn.internal.codegen.types.Type; |
16277 | 50 |
import jdk.nashorn.internal.lookup.Lookup; |
51 |
import jdk.nashorn.internal.lookup.MethodHandleFactory; |
|
16147 | 52 |
|
53 |
/** |
|
54 |
* An AccessorProperty is the most generic property type. An AccessorProperty is |
|
55 |
* represented as fields in a ScriptObject class. |
|
56 |
*/ |
|
23767 | 57 |
public final class AccessorProperty extends Property implements Serializable { |
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
58 |
private static final MethodHandles.Lookup lookup = MethodHandles.lookup(); |
16147 | 59 |
private static final MethodHandle REPLACE_MAP = findOwnMH("replaceMap", Object.class, Object.class, PropertyMap.class, String.class, Class.class, Class.class); |
60 |
||
61 |
private static final int NOOF_TYPES = getNumberOfAccessorTypes(); |
|
23767 | 62 |
private static final long serialVersionUID = 3371720170182154920L; |
16147 | 63 |
|
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
64 |
/** |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
65 |
* Properties in different maps for the same structure class will share their field getters and setters. This could |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
66 |
* be further extended to other method handles that are looked up in the AccessorProperty constructor, but right now |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
67 |
* these are the most frequently retrieved ones, and lookup of method handle natives only registers in the profiler |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
68 |
* for them. |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
69 |
*/ |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
70 |
private static ClassValue<GettersSetters> GETTERS_SETTERS = new ClassValue<GettersSetters>() { |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
71 |
@Override |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
72 |
protected GettersSetters computeValue(Class<?> structure) { |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
73 |
return new GettersSetters(structure); |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
74 |
} |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
75 |
}; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
76 |
|
16147 | 77 |
/** Property getter cache */ |
23767 | 78 |
private transient MethodHandle[] getters = new MethodHandle[NOOF_TYPES]; |
16147 | 79 |
|
80 |
private static final MethodType[] ACCESSOR_GETTER_TYPES = new MethodType[NOOF_TYPES]; |
|
81 |
private static final MethodType[] ACCESSOR_SETTER_TYPES = new MethodType[NOOF_TYPES]; |
|
18847 | 82 |
private static final MethodType ACCESSOR_GETTER_PRIMITIVE_TYPE; |
83 |
private static final MethodType ACCESSOR_SETTER_PRIMITIVE_TYPE; |
|
17770 | 84 |
private static final MethodHandle SPILL_ELEMENT_GETTER; |
85 |
private static final MethodHandle SPILL_ELEMENT_SETTER; |
|
86 |
||
87 |
private static final int SPILL_CACHE_SIZE = 8; |
|
88 |
private static final MethodHandle[] SPILL_ACCESSORS = new MethodHandle[SPILL_CACHE_SIZE * 2]; |
|
89 |
||
90 |
static { |
|
18847 | 91 |
MethodType getterPrimitiveType = null; |
92 |
MethodType setterPrimitiveType = null; |
|
93 |
||
17770 | 94 |
for (int i = 0; i < NOOF_TYPES; i++) { |
95 |
final Type type = ACCESSOR_TYPES.get(i); |
|
96 |
ACCESSOR_GETTER_TYPES[i] = MH.type(type.getTypeClass(), Object.class); |
|
97 |
ACCESSOR_SETTER_TYPES[i] = MH.type(void.class, Object.class, type.getTypeClass()); |
|
18847 | 98 |
|
99 |
if (type == PRIMITIVE_TYPE) { |
|
100 |
getterPrimitiveType = ACCESSOR_GETTER_TYPES[i]; |
|
101 |
setterPrimitiveType = ACCESSOR_SETTER_TYPES[i]; |
|
102 |
} |
|
17770 | 103 |
} |
104 |
||
18847 | 105 |
ACCESSOR_GETTER_PRIMITIVE_TYPE = getterPrimitiveType; |
106 |
ACCESSOR_SETTER_PRIMITIVE_TYPE = setterPrimitiveType; |
|
107 |
||
108 |
final MethodType spillGetterType = MethodType.methodType(Object[].class, Object.class); |
|
109 |
final MethodHandle spillGetter = MH.asType(MH.getter(MethodHandles.lookup(), ScriptObject.class, "spill", Object[].class), spillGetterType); |
|
17770 | 110 |
SPILL_ELEMENT_GETTER = MH.filterArguments(MH.arrayElementGetter(Object[].class), 0, spillGetter); |
111 |
SPILL_ELEMENT_SETTER = MH.filterArguments(MH.arrayElementSetter(Object[].class), 0, spillGetter); |
|
112 |
} |
|
16147 | 113 |
|
18855
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
114 |
/** |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
115 |
* Create a new accessor property. Factory method used by nasgen generated code. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
116 |
* |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
117 |
* @param key {@link Property} key. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
118 |
* @param propertyFlags {@link Property} flags. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
119 |
* @param getter {@link Property} get accessor method. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
120 |
* @param setter {@link Property} set accessor method. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
121 |
* |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
122 |
* @return New {@link AccessorProperty} created. |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
123 |
*/ |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
124 |
public static AccessorProperty create(final String key, final int propertyFlags, final MethodHandle getter, final MethodHandle setter) { |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
125 |
return new AccessorProperty(key, propertyFlags, -1, getter, setter); |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
126 |
} |
408663ef8f66
8020015: shared PropertyMaps should not be used without duplication
sundar
parents:
18852
diff
changeset
|
127 |
|
16147 | 128 |
/** Seed getter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */ |
23767 | 129 |
private transient MethodHandle primitiveGetter; |
16147 | 130 |
|
131 |
/** Seed setter for the primitive version of this field (in -Dnashorn.fields.dual=true mode) */ |
|
23767 | 132 |
private transient MethodHandle primitiveSetter; |
16147 | 133 |
|
134 |
/** Seed getter for the Object version of this field */ |
|
23767 | 135 |
private transient MethodHandle objectGetter; |
16147 | 136 |
|
137 |
/** Seed setter for the Object version of this field */ |
|
23767 | 138 |
private transient MethodHandle objectSetter; |
16147 | 139 |
|
140 |
/** |
|
141 |
* Current type of this object, in object only mode, this is an Object.class. In dual-fields mode |
|
142 |
* null means undefined, and primitive types are allowed. The reason a special type is used for |
|
143 |
* undefined, is that are no bits left to represent it in primitive types |
|
144 |
*/ |
|
145 |
private Class<?> currentType; |
|
146 |
||
147 |
/** |
|
23372
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
148 |
* Delegate constructor for bound properties. This is used for properties created by |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
149 |
* {@link ScriptRuntime#mergeScope} and the Nashorn {@code Object.bindProperties} method. |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
150 |
* The former is used to add a script's defined globals to the current global scope while |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
151 |
* still storing them in a JO-prefixed ScriptObject class. |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
152 |
* |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
153 |
* <p>All properties created by this constructor have the {@link #IS_BOUND} flag set.</p> |
16147 | 154 |
* |
155 |
* @param property accessor property to rebind |
|
18860
e387fde9322a
8014785: Ability to extend global instance by binding properties of another object
sundar
parents:
18859
diff
changeset
|
156 |
* @param delegate delegate object to rebind receiver to |
16147 | 157 |
*/ |
19105
a01ba9d17eab
8021571: @fork tests should use VM options passed from project.properties
sundar
parents:
18860
diff
changeset
|
158 |
AccessorProperty(final AccessorProperty property, final Object delegate) { |
17770 | 159 |
super(property); |
16147 | 160 |
|
17770 | 161 |
this.primitiveGetter = bindTo(property.primitiveGetter, delegate); |
162 |
this.primitiveSetter = bindTo(property.primitiveSetter, delegate); |
|
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
163 |
this.objectGetter = bindTo(property.ensureObjectGetter(), delegate); |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
164 |
this.objectSetter = bindTo(property.ensureObjectSetter(), delegate); |
16147 | 165 |
|
23372
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
166 |
// Properties created this way are bound to a delegate |
09707b3e5fb0
8021350: Share script classes between threads/globals within context
hannesw
parents:
19105
diff
changeset
|
167 |
this.flags |= IS_BOUND; |
16147 | 168 |
setCurrentType(property.getCurrentType()); |
169 |
} |
|
170 |
||
171 |
/** |
|
17770 | 172 |
* Constructor for spill properties. Array getters and setters will be created on demand. |
173 |
* |
|
174 |
* @param key the property key |
|
175 |
* @param flags the property flags |
|
176 |
* @param slot spill slot |
|
177 |
*/ |
|
178 |
public AccessorProperty(final String key, final int flags, final int slot) { |
|
179 |
super(key, flags, slot); |
|
180 |
assert (flags & IS_SPILL) == IS_SPILL; |
|
181 |
||
182 |
setCurrentType(Object.class); |
|
183 |
} |
|
184 |
||
185 |
/** |
|
16147 | 186 |
* Constructor. Similar to the constructor with both primitive getters and setters, the difference |
187 |
* here being that only one getter and setter (setter is optional for non writable fields) is given |
|
188 |
* to the constructor, and the rest are created from those. Used e.g. by Nasgen classes |
|
189 |
* |
|
190 |
* @param key the property key |
|
191 |
* @param flags the property flags |
|
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
192 |
* @param slot the property field number or spill slot |
16147 | 193 |
* @param getter the property getter |
194 |
* @param setter the property setter or null if non writable, non configurable |
|
195 |
*/ |
|
19105
a01ba9d17eab
8021571: @fork tests should use VM options passed from project.properties
sundar
parents:
18860
diff
changeset
|
196 |
AccessorProperty(final String key, final int flags, final int slot, final MethodHandle getter, final MethodHandle setter) { |
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
197 |
super(key, flags, slot); |
16147 | 198 |
|
199 |
// we don't need to prep the setters these will never be invalidated as this is a nasgen |
|
200 |
// or known type getter/setter. No invalidations will take place |
|
201 |
||
202 |
final Class<?> getterType = getter.type().returnType(); |
|
203 |
final Class<?> setterType = setter == null ? null : setter.type().parameterType(1); |
|
204 |
||
205 |
assert setterType == null || setterType == getterType; |
|
206 |
||
207 |
if (getterType.isPrimitive()) { |
|
208 |
for (int i = 0; i < NOOF_TYPES; i++) { |
|
209 |
getters[i] = MH.asType( |
|
210 |
Lookup.filterReturnType( |
|
211 |
getter, |
|
212 |
getAccessorType(i).getTypeClass()), |
|
213 |
ACCESSOR_GETTER_TYPES[i]); |
|
214 |
} |
|
215 |
} else { |
|
18847 | 216 |
objectGetter = getter.type() != Lookup.GET_OBJECT_TYPE ? MH.asType(getter, Lookup.GET_OBJECT_TYPE) : getter; |
217 |
objectSetter = setter != null && setter.type() != Lookup.SET_OBJECT_TYPE ? MH.asType(setter, Lookup.SET_OBJECT_TYPE) : setter; |
|
16147 | 218 |
} |
219 |
||
220 |
setCurrentType(getterType); |
|
221 |
} |
|
222 |
||
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
223 |
private static class GettersSetters { |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
224 |
final MethodHandle[] getters; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
225 |
final MethodHandle[] setters; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
226 |
|
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
227 |
public GettersSetters(Class<?> structure) { |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
228 |
final int fieldCount = ObjectClassGenerator.getFieldCount(structure); |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
229 |
getters = new MethodHandle[fieldCount]; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
230 |
setters = new MethodHandle[fieldCount]; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
231 |
for(int i = 0; i < fieldCount; ++i) { |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
232 |
final String fieldName = ObjectClassGenerator.getFieldName(i, Type.OBJECT); |
18847 | 233 |
getters[i] = MH.asType(MH.getter(lookup, structure, fieldName, Type.OBJECT.getTypeClass()), Lookup.GET_OBJECT_TYPE); |
234 |
setters[i] = MH.asType(MH.setter(lookup, structure, fieldName, Type.OBJECT.getTypeClass()), Lookup.SET_OBJECT_TYPE); |
|
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
235 |
} |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
236 |
} |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
237 |
} |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
238 |
|
16147 | 239 |
/** |
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
240 |
* Constructor for dual field AccessorPropertys. |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
241 |
* |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
242 |
* @param key property key |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
243 |
* @param flags property flags |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
244 |
* @param structure structure for objects associated with this property |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
245 |
* @param slot property field number or spill slot |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
246 |
*/ |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
247 |
public AccessorProperty(final String key, final int flags, final Class<?> structure, final int slot) { |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
248 |
super(key, flags, slot); |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
249 |
|
23767 | 250 |
initGetterSetter(structure); |
251 |
} |
|
252 |
||
253 |
private void initGetterSetter(final Class<?> structure) { |
|
254 |
final int slot = getSlot(); |
|
255 |
final String key = getKey(); |
|
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
256 |
/* |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
257 |
* primitiveGetter and primitiveSetter are only used in dual fields mode. Setting them to null also |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
258 |
* works in dual field mode, it only means that the property never has a primitive |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
259 |
* representation. |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
260 |
*/ |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
261 |
primitiveGetter = null; |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
262 |
primitiveSetter = null; |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
263 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
264 |
if (isParameter() && hasArguments()) { |
18859 | 265 |
final MethodHandle arguments = MH.getter(lookup, structure, "arguments", ScriptObject.class); |
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
266 |
|
18859 | 267 |
objectGetter = MH.asType(MH.insertArguments(MH.filterArguments(ScriptObject.GET_ARGUMENT.methodHandle(), 0, arguments), 1, slot), Lookup.GET_OBJECT_TYPE); |
268 |
objectSetter = MH.asType(MH.insertArguments(MH.filterArguments(ScriptObject.SET_ARGUMENT.methodHandle(), 0, arguments), 1, slot), Lookup.SET_OBJECT_TYPE); |
|
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
269 |
} else { |
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
270 |
final GettersSetters gs = GETTERS_SETTERS.get(structure); |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
271 |
objectGetter = gs.getters[slot]; |
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
272 |
objectSetter = gs.setters[slot]; |
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
273 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
274 |
if (!OBJECT_FIELDS_ONLY) { |
18847 | 275 |
final String fieldNamePrimitive = ObjectClassGenerator.getFieldName(slot, PRIMITIVE_TYPE); |
276 |
final Class<?> typeClass = PRIMITIVE_TYPE.getTypeClass(); |
|
277 |
primitiveGetter = MH.asType(MH.getter(lookup, structure, fieldNamePrimitive, typeClass), ACCESSOR_GETTER_PRIMITIVE_TYPE); |
|
278 |
primitiveSetter = MH.asType(MH.setter(lookup, structure, fieldNamePrimitive, typeClass), ACCESSOR_SETTER_PRIMITIVE_TYPE); |
|
16224
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
279 |
} |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
280 |
} |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
281 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
282 |
Class<?> initialType = null; |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
283 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
284 |
if (OBJECT_FIELDS_ONLY || isAlwaysObject()) { |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
285 |
initialType = Object.class; |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
286 |
} else if (!canBePrimitive()) { |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
287 |
info(key + " cannot be primitive"); |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
288 |
initialType = Object.class; |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
289 |
} else { |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
290 |
info(key + " CAN be primitive"); |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
291 |
if (!canBeUndefined()) { |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
292 |
info(key + " is always defined"); |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
293 |
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 |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
294 |
} |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
295 |
} |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
296 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
297 |
// is always object means "is never initialized to undefined, and always of object type |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
298 |
setCurrentType(initialType); |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
299 |
} |
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
300 |
|
0c49ad4e3b55
8006222: Move slot from SpillProperty to Property
jlaskey
parents:
16151
diff
changeset
|
301 |
/** |
16147 | 302 |
* Copy constructor |
303 |
* |
|
304 |
* @param property source property |
|
305 |
*/ |
|
306 |
protected AccessorProperty(final AccessorProperty property) { |
|
307 |
super(property); |
|
308 |
||
309 |
this.getters = property.getters; |
|
310 |
this.primitiveGetter = property.primitiveGetter; |
|
311 |
this.primitiveSetter = property.primitiveSetter; |
|
312 |
this.objectGetter = property.objectGetter; |
|
313 |
this.objectSetter = property.objectSetter; |
|
314 |
||
315 |
setCurrentType(property.getCurrentType()); |
|
316 |
} |
|
317 |
||
23767 | 318 |
private void readObject(final ObjectInputStream s) throws IOException, ClassNotFoundException { |
319 |
s.defaultReadObject(); |
|
320 |
// Restore getters array |
|
321 |
getters = new MethodHandle[NOOF_TYPES]; |
|
322 |
} |
|
323 |
||
16147 | 324 |
private static MethodHandle bindTo(final MethodHandle mh, final Object receiver) { |
325 |
if (mh == null) { |
|
326 |
return null; |
|
327 |
} |
|
328 |
||
329 |
return MH.dropArguments(MH.bindTo(mh, receiver), 0, Object.class); |
|
330 |
} |
|
331 |
||
332 |
@Override |
|
333 |
protected Property copy() { |
|
334 |
return new AccessorProperty(this); |
|
335 |
} |
|
336 |
||
337 |
@Override |
|
18615
3f6e6adcbc1a
8015969: Needs to enforce and document that global "context" and "engine" can't be modified when running via jsr223
sundar
parents:
17774
diff
changeset
|
338 |
public void setObjectValue(final ScriptObject self, final ScriptObject owner, final Object value, final boolean strict) { |
17770 | 339 |
if (isSpill()) { |
340 |
self.spill[getSlot()] = value; |
|
341 |
} else { |
|
342 |
try { |
|
343 |
getSetter(Object.class, self.getMap()).invokeExact((Object)self, value); |
|
344 |
} catch (final Error|RuntimeException e) { |
|
345 |
throw e; |
|
346 |
} catch (final Throwable e) { |
|
347 |
throw new RuntimeException(e); |
|
348 |
} |
|
349 |
} |
|
350 |
} |
|
351 |
||
352 |
@Override |
|
18615
3f6e6adcbc1a
8015969: Needs to enforce and document that global "context" and "engine" can't be modified when running via jsr223
sundar
parents:
17774
diff
changeset
|
353 |
public Object getObjectValue(final ScriptObject self, final ScriptObject owner) { |
17770 | 354 |
if (isSpill()) { |
355 |
return self.spill[getSlot()]; |
|
17774
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
356 |
} |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
357 |
|
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
358 |
try { |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
359 |
return getGetter(Object.class).invokeExact((Object)self); |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
360 |
} catch (final Error|RuntimeException e) { |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
361 |
throw e; |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
362 |
} catch (final Throwable e) { |
0407501fa563
8014219: Make the run-octane harness more deterministic by not measuring elapsed time every iteration. Also got rid of most of the run logic in base.js and call benchmarks directly for the same purpose
lagergren
parents:
17770
diff
changeset
|
363 |
throw new RuntimeException(e); |
17770 | 364 |
} |
365 |
} |
|
366 |
||
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
367 |
// Spill getters and setters are lazily initialized, see JDK-8011630 |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
368 |
private MethodHandle ensureObjectGetter() { |
17770 | 369 |
if (isSpill() && objectGetter == null) { |
370 |
objectGetter = getSpillGetter(); |
|
371 |
} |
|
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
372 |
return objectGetter; |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
373 |
} |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
374 |
|
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
375 |
private MethodHandle ensureObjectSetter() { |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
376 |
if (isSpill() && objectSetter == null) { |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
377 |
objectSetter = getSpillSetter(); |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
378 |
} |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
379 |
return objectSetter; |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
380 |
} |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
381 |
|
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
382 |
@Override |
23767 | 383 |
void initMethodHandles(final Class<?> structure) { |
384 |
if (!ScriptObject.class.isAssignableFrom(structure) || !StructureLoader.isStructureClass(structure.getName())) { |
|
385 |
throw new IllegalArgumentException(); |
|
386 |
} |
|
387 |
if (!isSpill()) { |
|
388 |
initGetterSetter(structure); |
|
389 |
} |
|
390 |
} |
|
391 |
||
392 |
@Override |
|
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
393 |
public MethodHandle getGetter(final Class<?> type) { |
16147 | 394 |
final int i = getAccessorTypeIndex(type); |
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
395 |
ensureObjectGetter(); |
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
396 |
|
16147 | 397 |
if (getters[i] == null) { |
398 |
getters[i] = debug( |
|
18847 | 399 |
createGetter(currentType, type, primitiveGetter, objectGetter), |
400 |
currentType, type, "get"); |
|
16147 | 401 |
} |
402 |
||
17770 | 403 |
return getters[i]; |
16147 | 404 |
} |
405 |
||
406 |
private Property getWiderProperty(final Class<?> type) { |
|
407 |
final AccessorProperty newProperty = new AccessorProperty(this); |
|
408 |
newProperty.invalidate(type); |
|
409 |
return newProperty; |
|
410 |
} |
|
411 |
||
412 |
private PropertyMap getWiderMap(final PropertyMap oldMap, final Property newProperty) { |
|
413 |
final PropertyMap newMap = oldMap.replaceProperty(this, newProperty); |
|
414 |
assert oldMap.size() > 0; |
|
415 |
assert newMap.size() == oldMap.size(); |
|
416 |
return newMap; |
|
417 |
} |
|
418 |
||
419 |
// the final three arguments are for debug printout purposes only |
|
420 |
@SuppressWarnings("unused") |
|
421 |
private static Object replaceMap(final Object sobj, final PropertyMap newMap, final String key, final Class<?> oldType, final Class<?> newType) { |
|
422 |
if (DEBUG_FIELDS) { |
|
423 |
final PropertyMap oldMap = ((ScriptObject)sobj).getMap(); |
|
424 |
info("Type change for '" + key + "' " + oldType + "=>" + newType); |
|
425 |
finest("setting map " + sobj + " from " + Debug.id(oldMap) + " to " + Debug.id(newMap) + " " + oldMap + " => " + newMap); |
|
426 |
} |
|
427 |
((ScriptObject)sobj).setMap(newMap); |
|
428 |
return sobj; |
|
429 |
} |
|
430 |
||
431 |
private MethodHandle generateSetter(final Class<?> forType, final Class<?> type) { |
|
18852
604c1d681b6f
8017084: Use spill properties for large object literals
hannesw
parents:
18847
diff
changeset
|
432 |
ensureObjectSetter(); |
16147 | 433 |
MethodHandle mh = createSetter(forType, type, primitiveSetter, objectSetter); |
434 |
mh = debug(mh, currentType, type, "set"); |
|
435 |
return mh; |
|
436 |
} |
|
437 |
||
438 |
@Override |
|
439 |
public MethodHandle getSetter(final Class<?> type, final PropertyMap currentMap) { |
|
440 |
final int i = getAccessorTypeIndex(type); |
|
441 |
final int ci = currentType == null ? -1 : getAccessorTypeIndex(currentType); |
|
442 |
final Class<?> forType = currentType == null ? type : currentType; |
|
443 |
||
444 |
//if we are asking for an object setter, but are still a primitive type, we might try to box it |
|
17513 | 445 |
MethodHandle mh; |
16147 | 446 |
|
447 |
if (needsInvalidator(i, ci)) { |
|
448 |
final Property newProperty = getWiderProperty(type); |
|
449 |
final PropertyMap newMap = getWiderMap(currentMap, newProperty); |
|
450 |
final MethodHandle widerSetter = newProperty.getSetter(type, newMap); |
|
451 |
final MethodHandle explodeTypeSetter = MH.filterArguments(widerSetter, 0, MH.insertArguments(REPLACE_MAP, 1, newMap, getKey(), currentType, type)); |
|
452 |
if (currentType != null && currentType.isPrimitive() && type == Object.class) { |
|
453 |
//might try a box check on this to avoid widening field to object storage |
|
17513 | 454 |
mh = createGuardBoxedPrimitiveSetter(currentType, generateSetter(currentType, currentType), explodeTypeSetter); |
455 |
} else { |
|
456 |
mh = explodeTypeSetter; |
|
16147 | 457 |
} |
17513 | 458 |
} else { |
459 |
mh = generateSetter(forType, type); |
|
16147 | 460 |
} |
461 |
||
17770 | 462 |
return mh; |
16147 | 463 |
} |
464 |
||
465 |
@Override |
|
466 |
public boolean canChangeType() { |
|
467 |
if (OBJECT_FIELDS_ONLY) { |
|
468 |
return false; |
|
469 |
} |
|
470 |
return currentType != Object.class && (isConfigurable() || isWritable()); |
|
471 |
} |
|
472 |
||
473 |
private boolean needsInvalidator(final int ti, final int fti) { |
|
474 |
return canChangeType() && ti > fti; |
|
475 |
} |
|
476 |
||
477 |
private void invalidate(final Class<?> newType) { |
|
478 |
getters = new MethodHandle[NOOF_TYPES]; |
|
479 |
setCurrentType(newType); |
|
480 |
} |
|
481 |
||
17770 | 482 |
private MethodHandle getSpillGetter() { |
483 |
final int slot = getSlot(); |
|
484 |
MethodHandle getter = slot < SPILL_CACHE_SIZE ? SPILL_ACCESSORS[slot * 2] : null; |
|
485 |
if (getter == null) { |
|
18847 | 486 |
getter = MH.insertArguments(SPILL_ELEMENT_GETTER, 1, slot); |
17770 | 487 |
if (slot < SPILL_CACHE_SIZE) { |
18847 | 488 |
SPILL_ACCESSORS[slot * 2 + 0] = getter; |
17770 | 489 |
} |
490 |
} |
|
491 |
return getter; |
|
492 |
} |
|
493 |
||
494 |
private MethodHandle getSpillSetter() { |
|
495 |
final int slot = getSlot(); |
|
496 |
MethodHandle setter = slot < SPILL_CACHE_SIZE ? SPILL_ACCESSORS[slot * 2 + 1] : null; |
|
497 |
if (setter == null) { |
|
18847 | 498 |
setter = MH.insertArguments(SPILL_ELEMENT_SETTER, 1, slot); |
17770 | 499 |
if (slot < SPILL_CACHE_SIZE) { |
500 |
SPILL_ACCESSORS[slot * 2 + 1] = setter; |
|
501 |
} |
|
502 |
} |
|
503 |
return setter; |
|
504 |
} |
|
505 |
||
16147 | 506 |
private static void finest(final String str) { |
507 |
if (DEBUG_FIELDS) { |
|
508 |
LOG.finest(str); |
|
509 |
} |
|
510 |
} |
|
511 |
||
512 |
private static void info(final String str) { |
|
513 |
if (DEBUG_FIELDS) { |
|
514 |
LOG.info(str); |
|
515 |
} |
|
516 |
} |
|
517 |
||
518 |
private MethodHandle debug(final MethodHandle mh, final Class<?> forType, final Class<?> type, final String tag) { |
|
519 |
if (DEBUG_FIELDS) { |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
16277
diff
changeset
|
520 |
return MethodHandleFactory.addDebugPrintout( |
16147 | 521 |
LOG, |
522 |
mh, |
|
523 |
tag + " '" + getKey() + "' (property="+ Debug.id(this) + ", forType=" + stripName(forType) + ", type=" + stripName(type) + ')'); |
|
524 |
} |
|
525 |
return mh; |
|
526 |
} |
|
527 |
||
528 |
private void setCurrentType(final Class<?> currentType) { |
|
529 |
this.currentType = currentType; |
|
530 |
} |
|
531 |
||
532 |
@Override |
|
533 |
public Class<?> getCurrentType() { |
|
534 |
return currentType; |
|
535 |
} |
|
536 |
||
537 |
private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) { |
|
17246
a1bcf4d2bff1
8013203: A collection of smaller speedups to compilation pipeline
attila
parents:
16523
diff
changeset
|
538 |
return MH.findStatic(lookup, AccessorProperty.class, name, MH.type(rtype, types)); |
16147 | 539 |
} |
540 |
||
541 |
} |