1 /*
2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
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.experimental.value;
27
28 import java.lang.invoke.MethodHandle;
29 import java.lang.invoke.MethodHandles;
30 import java.lang.invoke.MethodHandles.Lookup;
31 import java.lang.invoke.MethodType;
32 import java.lang.reflect.Field;
33 import java.lang.reflect.Method;
34 import java.lang.reflect.Modifier;
35 import java.util.Arrays;
36 import java.util.List;
37 import java.util.Map;
38 import java.util.Objects;
39 import java.util.Optional;
40 import java.util.concurrent.ConcurrentHashMap;
41 import java.util.stream.Stream;
42
43 import jdk.experimental.value.ValueType.ValueHandleKind.ValueHandleKey;
44 import jdk.experimental.bytecode.MacroCodeBuilder.CondKind;
45 import jdk.experimental.bytecode.TypeTag;
46 import jdk.internal.misc.Unsafe;
47 import sun.invoke.util.BytecodeDescriptor;
48 import sun.invoke.util.Wrapper;
49 import valhalla.shady.MinimalValueTypes_1_0;
50
51 // Rough place holder just now...
52 public class ValueType<T> {
53
54 static final Unsafe UNSAFE = Unsafe.getUnsafe();
55
56 enum ValueHandleKind {
57 BOX,
58 UNBOX,
59 DEFAULT,
60 EQ,
61 HASH,
62 WITHER() {
63 @Override
64 ValueHandleKey key(Object fieldName) {
65 return new ValueHandleKey(this, fieldName);
66 }
67 },
68 NEWARRAY,
69 VALOAD,
70 VASTORE,
71 MULTINEWARRAY() {
72 @Override
73 ValueHandleKey key(Object dims) {
74 return new ValueHandleKey(this, dims);
75 }
76 },
77 IDENTITY,
78 GETTER() {
79 @Override
80 ValueHandleKey key(Object fieldName) {
81 return new ValueHandleKey(this, fieldName);
82 }
83 };
84
85 ValueHandleKey key() {
86 return new ValueHandleKey(this, null);
87 }
88
89 ValueHandleKey key(Object optArg) {
90 throw new IllegalStateException();
91 }
92
93 static class ValueHandleKey {
94 ValueHandleKind kind;
95 Optional<Object> optArg;
96
97 ValueHandleKey(ValueHandleKind kind, Object optArg) {
98 this.kind = kind;
99 this.optArg = Optional.ofNullable(optArg);
100 }
101
102 @Override
103 public boolean equals(Object obj) {
104 if (obj instanceof ValueHandleKey) {
105 ValueHandleKey that = (ValueHandleKey)obj;
106 return Objects.equals(kind, that.kind) &&
107 Objects.equals(optArg, that.optArg);
108 } else {
109 return false;
110 }
111 }
112
113 @Override
114 public int hashCode() {
115 return Objects.hashCode(kind) * 31 + Objects.hashCode(optArg);
116 }
117 }
118 }
119
120 private static final Lookup IMPL_LOOKUP;
121
122 static {
123 try {
124 Field f = Lookup.class.getDeclaredField("IMPL_LOOKUP");
125 f.setAccessible(true);
126 IMPL_LOOKUP = (Lookup)f.get(null);
127 } catch (ReflectiveOperationException ex) {
128 throw new AssertionError(ex);
129 }
130 }
131
132 private static final ConcurrentHashMap<Class<?>, ValueType<?>> BOX_TO_VT = new ConcurrentHashMap<>();
133
134 public static boolean classHasValueType(Class<?> x) {
135 if (!MinimalValueTypes_1_0.isValueCapable(x)) {
136 return false;
137 }
138 return MinimalValueTypes_1_0.getValueTypeClass(x) != null;
139 }
140
141 @SuppressWarnings("unchecked")
142 public static <T> ValueType<T> forClass(Class<T> x) {
143 if (!MinimalValueTypes_1_0.isValueCapable(x)) {
144 throw new IllegalArgumentException("Class " + x + " not a value capable class");
145 }
146
147 ValueType<T> vt = (ValueType<T>) BOX_TO_VT.get(x);
148 if (vt != null) {
149 return vt;
150 }
151
152 Class<T> valueClass = (Class<T>) MinimalValueTypes_1_0.getValueTypeClass(x);
153 vt = new ValueType<T>(x, valueClass);
154 ValueType<T> old = (ValueType<T>) BOX_TO_VT.putIfAbsent(x, vt);
155 if (old != null) {
156 vt = old;
157 }
158 return vt;
159 }
160
161 private Lookup boxLookup;
162 private Lookup valueLookup;
163 private Map<ValueHandleKind.ValueHandleKey, MethodHandle> handleMap = new ConcurrentHashMap<>();
164
165 private ValueType(Class<T> boxClass, Class<T> valueClass) {
166 this.boxLookup = IMPL_LOOKUP.in(boxClass);
167 this.valueLookup = IMPL_LOOKUP.in(valueClass);
168 }
169
170 @SuppressWarnings("unchecked")
171 public Class<T> boxClass() {
172 return (Class<T>)boxLookup.lookupClass();
173 }
174
175 public Class<?> sourceClass() {
176 return boxClass();
177 }
178
179 public Class<?> valueClass() {
180 return valueLookup.lookupClass();
181 }
182
183 public Class<?> arrayValueClass() {
184 return arrayValueClass(1);
185 }
186
187 public Class<?> arrayValueClass(int dims) {
188 String dimsStr = "[[[[[[[[[[[[[[[[";
189 if (dims < 1 || dims > 16) {
190 throw new IllegalArgumentException("cannot create array class for dimension > 16");
191 }
192 String cn = dimsStr.substring(0, dims) + "Q" + valueClass().getName() + ";";
193 return MinimalValueTypes_1_0.loadValueTypeClass(boxLookup.lookupClass(), cn);
194 }
195
196 public String toString() {
197 return "ValueType boxClass=" + boxClass() + " valueClass=" + valueClass();
198 }
199
200 String mhName(String opName) {
201 return sourceClass().getName() + "_" + opName;
202 }
203
204 public MethodHandle defaultValueConstant() {
205 ValueHandleKey key = ValueHandleKind.DEFAULT.key();
206 MethodHandle result = handleMap.get(key);
207 if (result == null) {
208 result = MethodHandleBuilder.loadCode(boxLookup, mhName("default"), MethodType.methodType(valueClass()),
209 C -> {
210 C.vdefault(valueClass()).vreturn();
211 });
212 handleMap.put(key, result);
213 }
214 return result;
215 }
216
217 public MethodHandle substitutabilityTest() {
218 ValueHandleKey key = ValueHandleKind.EQ.key();
219 MethodHandle result = handleMap.get(key);
220 if (result == null) {
221 result = MethodHandleBuilder.loadCode(valueLookup, mhName("subTest"), MethodType.methodType(boolean.class, valueClass(), valueClass()),
222 C -> {
223 for (Field f : valueFields()) {
224 String fDesc = BytecodeDescriptor.unparse(f.getType());
225 C.vload(0).vgetfield(valueClass(), f.getName(), fDesc);
226 C.vload(1).vgetfield(valueClass(), f.getName(), fDesc);
227 if (f.getType().isPrimitive()) {
228 C.ifcmp(fDesc, CondKind.NE, "fail");
229 } else {
230 C.invokestatic(Objects.class, "equals", "(Ljava/lang/Object;Ljava/lang/Object;)Z", false);
231 C.const_(0).ifcmp(TypeTag.I, CondKind.EQ, "fail");
232 }
233 }
234 C.const_(1);
235 C.ireturn();
236 C.label("fail");
237 C.const_(0);
238 C.ireturn();
239 });
240 handleMap.put(key, result);
241 }
242 return result;
243 }
244
245 public MethodHandle substitutabilityHashCode() {
246 ValueHandleKey key = ValueHandleKind.HASH.key();
247 MethodHandle result = handleMap.get(key);
248 if (result == null) {
249 result = MethodHandleBuilder.loadCode(valueLookup, mhName("subHash"), MethodType.methodType(int.class, valueClass()),
250 C -> {
251 C.withLocal("res", "I");
252 C.const_(1).store("res");
253 for (Field f : valueFields()) {
254 String desc = BytecodeDescriptor.unparse(f.getType());
255 C.vload(0).vgetfield(valueClass(), f.getName(), desc);
256 if (f.getType().isPrimitive()) {
257 C.invokestatic(Wrapper.asWrapperType(f.getType()), "hashCode", "(" + desc + ")I", false);
258 } else {
259 C.invokestatic(Objects.class, "hashCode", "(Ljava/lang/Object;)I", false);
260 }
261 C.load("res").const_(31).imul();
262 C.iadd().store("res");
263 }
264 C.load("res").ireturn();
265 });
266 handleMap.put(key, result);
267 }
268 return result;
269 }
270
271 //Todo: when 'vwithfield' is ready, this handle could be greatly simplified
272 public MethodHandle findWither(Lookup lookup, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {
273 ValueHandleKey key = ValueHandleKind.WITHER.key(List.of(name, type));
274 MethodHandle result = handleMap.get(key);
275 if (result == null) {
276 MethodHandle mh = boxLookup.findGetter(boxClass(), name, type);
277 Field field = MethodHandles.reflectAs(Field.class, mh);
278 Class<?> erasedType = type.isPrimitive() ?
279 type : Object.class;
280 Method unsafeMethod = Stream.of(UNSAFE.getClass().getDeclaredMethods())
281 .filter(m -> m.getName().startsWith("put") &&
282 Arrays.asList(m.getParameterTypes()).equals(Arrays.asList(Object.class, long.class, erasedType)))
283 .findFirst().get();
284 long fieldOffset = UNSAFE.objectFieldOffset(field);
285 result = MethodHandleBuilder.loadCode(boxLookup, mhName("wither$" + name), MethodType.methodType(valueClass(), MethodHandle.class, valueClass(), type),
286 C -> {
287 C.withLocal("boxedVal", BytecodeDescriptor.unparse(boxClass()))
288 .load(1)
289 .vbox(boxClass())
290 .store("boxedVal")
291 .load(0)
292 .load("boxedVal")
293 .const_(fieldOffset)
294 .load(2);
295 MethodType unsafeMT = MethodType.methodType(unsafeMethod.getReturnType(), unsafeMethod.getParameterTypes());
296 C.invokevirtual(MethodHandle.class, "invokeExact", BytecodeDescriptor.unparse(unsafeMT), false)
297 .load("boxedVal")
298 .vunbox(valueClass())
299 .vreturn();
300 }).bindTo(MethodHandles.lookup().unreflect(unsafeMethod).bindTo(UNSAFE));
301 handleMap.put(key, result);
302 }
303 //force access-check
304 lookup.findGetter(boxClass(), name, type);
305 return result;
306 }
307
308 public MethodHandle unbox() {
309 ValueHandleKey key = ValueHandleKind.UNBOX.key();
310 MethodHandle result = handleMap.get(key);
311 if (result == null) {
312 result = MethodHandleBuilder.loadCode(boxLookup, mhName("unbox"), MethodType.methodType(valueClass(), boxClass()),
313 C -> {
314 C.load(0).vunbox(valueClass()).vreturn();
315 });
316 handleMap.put(key, result);
317 }
318 return result;
319 }
320
321 public MethodHandle box() {
322 ValueHandleKey key = ValueHandleKind.BOX.key();
323 MethodHandle result = handleMap.get(key);
324 if (result == null) {
325 result = MethodHandleBuilder.loadCode(boxLookup, mhName("box"), MethodType.methodType(boxClass(), valueClass()),
326 C -> {
327 C.vload(0).vbox(boxClass()).areturn();
328 });
329 handleMap.put(key, result);
330 }
331 return result;
332 }
333
334 public MethodHandle newArray() {
335 Class<?> arrayValueClass = arrayValueClass();
336 ValueHandleKey key = ValueHandleKind.NEWARRAY.key();
337 MethodHandle result = handleMap.get(key);
338 if (result == null) {
339 result = MethodHandleBuilder.loadCode(boxLookup, mhName("newArray"), MethodType.methodType(arrayValueClass, int.class),
340 C -> {
341 C.load(0).anewarray(valueClass()).areturn();
342 });
343 handleMap.put(key, result);
344 }
345 return result;
346 }
347
348 public MethodHandle arrayGetter() {
349 Class<?> arrayValueClass = arrayValueClass();
350 ValueHandleKey key = ValueHandleKind.VALOAD.key();
351 MethodHandle result = handleMap.get(key);
352 if (result == null) {
353 result = MethodHandleBuilder.loadCode(boxLookup, mhName("arrayGet"), MethodType.methodType(valueClass(), arrayValueClass, int.class),
354 C -> {
355 C.load(0).load(1).vaload().vreturn();
356 });
357 handleMap.put(key, result);
358 }
359 return result;
360 }
361
362 public MethodHandle arraySetter() {
363 Class<?> arrayValueClass = arrayValueClass();
364 ValueHandleKey key = ValueHandleKind.VASTORE.key();
365 MethodHandle result = handleMap.get(key);
366 if (result == null) {
367 result = MethodHandleBuilder.loadCode(boxLookup, mhName("arraySet"), MethodType.methodType(void.class, arrayValueClass, int.class, valueClass()),
368 C -> {
369 C.load(0).load(1).load(2).vastore().return_();
370 });
371 handleMap.put(key, result);
372 }
373 return result;
374 }
375
376 public MethodHandle newMultiArray(int dims) {
377 Class<?> arrayValueClass = arrayValueClass(dims);
378 ValueHandleKey key = ValueHandleKind.MULTINEWARRAY.key(dims);
379 MethodHandle result = handleMap.get(key);
380 Class<?>[] params = new Class<?>[dims];
381 Arrays.fill(params, int.class);
382 if (result == null) {
383 result = MethodHandleBuilder.loadCode(boxLookup, mhName("newMultiArray"), MethodType.methodType(arrayValueClass, params),
384 C -> {
385 for (int i = 0 ; i < dims ; i++) {
386 C.load(i);
387 }
388 C.multianewarray(arrayValueClass, (byte)dims).areturn();
389 });
390 handleMap.put(key, result);
391 }
392 return result;
393 }
394
395 public MethodHandle identity() {
396 ValueHandleKey key = ValueHandleKind.IDENTITY.key();
397 MethodHandle result = handleMap.get(key);
398 if (result == null) {
399 result = MethodHandleBuilder.loadCode(boxLookup, mhName("identity"), MethodType.methodType(valueClass(), valueClass()),
400 C -> C.vload(0).vreturn());
401 handleMap.put(key, result);
402 }
403 return result;
404 }
405
406 public MethodHandle findGetter(Lookup lookup, String name, Class<?> type) throws NoSuchFieldException, IllegalAccessException {
407 ValueHandleKey key = ValueHandleKind.GETTER.key(List.of(name, type));
408 MethodHandle result = handleMap.get(key);
409 if (result == null) {
410 String fieldType = BytecodeDescriptor.unparse(type);
411 result = MethodHandleBuilder.loadCode(boxLookup, mhName("getter$" + name), MethodType.methodType(type, valueClass()),
412 C -> C.vload(0).vgetfield(valueClass(), name, fieldType).return_(fieldType));
413 handleMap.put(key, result);
414 }
415 //force access-check
416 lookup.findGetter(boxClass(), name, type);
417 return result;
418 }
419
420 private Field[] valueFields() {
421 int valFieldMask = Modifier.FINAL;
422 return Stream.of(sourceClass().getDeclaredFields())
423 .filter(f -> (f.getModifiers() & (valFieldMask | Modifier.STATIC)) == valFieldMask)
424 .toArray(Field[]::new);
425 }
426
427 }