38 import jdk.experimental.value.MethodHandleBuilder.IsolatedMethodBuilder.IsolatedMethodPoolHelper;
39 import jdk.internal.misc.Unsafe;
40 import sun.security.action.GetPropertyAction;
41 import valhalla.shady.MinimalValueTypes_1_0;
42
43 import java.lang.invoke.MethodHandle;
44 import java.lang.invoke.MethodHandles.Lookup;
45 import java.lang.invoke.MethodType;
46 import java.util.*;
47 import java.util.function.Consumer;
48 import java.util.function.Function;
49
50 /**
51 * Utility class for building method handles.
52 */
53 public class MethodHandleBuilder {
54
55 static final Unsafe UNSAFE = Unsafe.getUnsafe();
56
57 static final boolean ENABLE_POOL_PATCHES;
58 static final boolean MANGLE_CLASS_INFO;
59
60 static {
61 Properties props = GetPropertyAction.privilegedGetProperties();
62 ENABLE_POOL_PATCHES = Boolean.parseBoolean(
63 props.getProperty("valhalla.enablePoolPatches"));
64 MANGLE_CLASS_INFO = Boolean.parseBoolean(
65 props.getProperty("valhalla.mangleClassInfo"));
66 }
67
68 public static MethodHandle loadCode(Lookup lookup, String name, MethodType type, Consumer<? super MethodHandleCodeBuilder> builder) {
69 return loadCode(lookup, name, type.toMethodDescriptorString(), builder);
70 }
71
72 public static MethodHandle loadCode(Lookup lookup, String name, String type, Consumer<? super MethodHandleCodeBuilder> builder) {
73 return loadCode(lookup, name, name, type, MethodHandleCodeBuilder::new,
74 clazz -> {
75 try {
76 return lookup.findStatic(clazz, name, MethodType.fromMethodDescriptorString(type, lookup.lookupClass().getClassLoader()));
77 } catch (ReflectiveOperationException ex) {
78 throw new IllegalStateException(ex);
79 }
80 },
81 builder);
82 }
83
84 protected static <Z, C extends CodeBuilder<Class<?>, String, byte[], ?>> Z loadCode(
85 Lookup lookup, String className, String methodName, String type,
200 public String nullType() {
201 return basicTypeHelper.nullType();
202 }
203 }
204
205 static class IsolatedMethodPoolHelper implements PoolHelper<Class<?>, String, byte[]> {
206 BasicPoolHelper basicPoolHelper = new BasicPoolHelper();
207 String clazz;
208
209 IsolatedMethodPoolHelper(String clazz) {
210 this.clazz = clazz;
211 }
212
213 String from(Class<?> c) {
214 String name;
215 boolean isValue = MinimalValueTypes_1_0.isValueType(c);
216 if (c == THIS_CLASS) {
217 //THIS_CLASS cannot be a DVT (by construction) - never mangle
218 name = clazz;
219 } else {
220 name = (isValue && MANGLE_CLASS_INFO) ?
221 ";Q" + c.getName() + ";" : //mangle DVT name
222 c.getName();
223 }
224 return name.replaceAll("\\.", "/");
225 }
226
227 @Override
228 public int putClass(Class<?> symbol) {
229 return basicPoolHelper.putClass(from(symbol));
230 }
231
232 @Override
233 public int putFieldRef(Class<?> owner, CharSequence name, String type) {
234 return basicPoolHelper.putFieldRef(from(owner), name, type);
235 }
236
237 @Override
238 public int putMethodRef(Class<?> owner, CharSequence name, String type, boolean isInterface) {
239 return basicPoolHelper.putMethodRef(from(owner), name, type, isInterface);
240 }
241
|
38 import jdk.experimental.value.MethodHandleBuilder.IsolatedMethodBuilder.IsolatedMethodPoolHelper;
39 import jdk.internal.misc.Unsafe;
40 import sun.security.action.GetPropertyAction;
41 import valhalla.shady.MinimalValueTypes_1_0;
42
43 import java.lang.invoke.MethodHandle;
44 import java.lang.invoke.MethodHandles.Lookup;
45 import java.lang.invoke.MethodType;
46 import java.util.*;
47 import java.util.function.Consumer;
48 import java.util.function.Function;
49
50 /**
51 * Utility class for building method handles.
52 */
53 public class MethodHandleBuilder {
54
55 static final Unsafe UNSAFE = Unsafe.getUnsafe();
56
57 static final boolean ENABLE_POOL_PATCHES;
58
59 static {
60 Properties props = GetPropertyAction.privilegedGetProperties();
61 ENABLE_POOL_PATCHES = Boolean.parseBoolean(
62 props.getProperty("valhalla.enablePoolPatches"));
63 }
64
65 public static MethodHandle loadCode(Lookup lookup, String name, MethodType type, Consumer<? super MethodHandleCodeBuilder> builder) {
66 return loadCode(lookup, name, type.toMethodDescriptorString(), builder);
67 }
68
69 public static MethodHandle loadCode(Lookup lookup, String name, String type, Consumer<? super MethodHandleCodeBuilder> builder) {
70 return loadCode(lookup, name, name, type, MethodHandleCodeBuilder::new,
71 clazz -> {
72 try {
73 return lookup.findStatic(clazz, name, MethodType.fromMethodDescriptorString(type, lookup.lookupClass().getClassLoader()));
74 } catch (ReflectiveOperationException ex) {
75 throw new IllegalStateException(ex);
76 }
77 },
78 builder);
79 }
80
81 protected static <Z, C extends CodeBuilder<Class<?>, String, byte[], ?>> Z loadCode(
82 Lookup lookup, String className, String methodName, String type,
197 public String nullType() {
198 return basicTypeHelper.nullType();
199 }
200 }
201
202 static class IsolatedMethodPoolHelper implements PoolHelper<Class<?>, String, byte[]> {
203 BasicPoolHelper basicPoolHelper = new BasicPoolHelper();
204 String clazz;
205
206 IsolatedMethodPoolHelper(String clazz) {
207 this.clazz = clazz;
208 }
209
210 String from(Class<?> c) {
211 String name;
212 boolean isValue = MinimalValueTypes_1_0.isValueType(c);
213 if (c == THIS_CLASS) {
214 //THIS_CLASS cannot be a DVT (by construction) - never mangle
215 name = clazz;
216 } else {
217 name = isValue ?
218 MinimalValueTypes_1_0.mangleValueClassName(c.getName()) :
219 c.getName();
220 }
221 return name.replaceAll("\\.", "/");
222 }
223
224 @Override
225 public int putClass(Class<?> symbol) {
226 return basicPoolHelper.putClass(from(symbol));
227 }
228
229 @Override
230 public int putFieldRef(Class<?> owner, CharSequence name, String type) {
231 return basicPoolHelper.putFieldRef(from(owner), name, type);
232 }
233
234 @Override
235 public int putMethodRef(Class<?> owner, CharSequence name, String type, boolean isInterface) {
236 return basicPoolHelper.putMethodRef(from(owner), name, type, isInterface);
237 }
238
|