private static Field getReflectionSlotField(Class<?> reflectionClass) {
try {
Field field = reflectionClass.getDeclaredField("slot");
field.setAccessible(true);
return field;
} catch (NoSuchFieldException | SecurityException e) {
throw new GraalInternalError(e);
}
}
public ResolvedJavaMethod lookupJavaConstructor(Constructor<?> reflectionConstructor) {
try {
Class<?> holder = reflectionConstructor.getDeclaringClass();
final int slot = reflectionConstructorSlot.getInt(reflectionConstructor);
final long metaspaceMethod = runtime.getCompilerToVM().getMetaspaceMethod(holder, slot);
return HotSpotResolvedJavaMethod.fromMetaspace(metaspaceMethod);
} catch (IllegalArgumentException | IllegalAccessException e) {
throw new GraalInternalError(e);
}
}
public ResolvedJavaField lookupJavaField(Field reflectionField) {
String name = reflectionField.getName();
Class<?> fieldHolder = reflectionField.getDeclaringClass();
Class<?> fieldType = reflectionField.getType();
// java.lang.reflect.Field's modifiers should be enough here since VM internal modifier bits
// are not used (yet).
final int modifiers = reflectionField.getModifiers();
final long offset =
Modifier.isStatic(modifiers)
? unsafe.staticFieldOffset(reflectionField)
: unsafe.objectFieldOffset(reflectionField);
ResolvedJavaType holder = HotSpotResolvedObjectType.fromClass(fieldHolder);
ResolvedJavaType type = HotSpotResolvedObjectType.fromClass(fieldType);
if (offset != -1) {
HotSpotResolvedObjectType resolved = (HotSpotResolvedObjectType) holder;
return resolved.createField(name, type, offset, modifiers);
} else {
throw GraalInternalError.shouldNotReachHere("unresolved field " + reflectionField);
}
}
public TypeUniverse() {
Providers providers =
Graal.getRequiredCapability(RuntimeProvider.class).getHostBackend().getProviders();
metaAccess = providers.getMetaAccess();
constantReflection = providers.getConstantReflection();
snippetReflection = Graal.getRequiredCapability(SnippetReflectionProvider.class);
Unsafe theUnsafe = null;
try {
theUnsafe = Unsafe.getUnsafe();
} catch (Exception e) {
try {
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
theUnsafe = (Unsafe) theUnsafeField.get(null);
} catch (Exception e1) {
throw (InternalError) new InternalError("unable to initialize unsafe").initCause(e1);
}
}
unsafe = theUnsafe;
Class<?>[] initialClasses = {
void.class,
boolean.class,
byte.class,
short.class,
char.class,
int.class,
float.class,
long.class,
double.class,
Object.class,
Class.class,
ClassLoader.class,
String.class,
Serializable.class,
Cloneable.class,
Test.class,
TestMetaAccessProvider.class,
List.class,
Collection.class,
Map.class,
Queue.class,
HashMap.class,
LinkedHashMap.class,
IdentityHashMap.class,
AbstractCollection.class,
AbstractList.class,
ArrayList.class
};
for (Class<?> c : initialClasses) {
addClass(c);
}
for (Field f : Constant.class.getDeclaredFields()) {
int mods = f.getModifiers();
if (f.getType() == Constant.class
&& Modifier.isPublic(mods)
&& Modifier.isStatic(mods)
&& Modifier.isFinal(mods)) {
try {
Constant c = (Constant) f.get(null);
if (c != null) {
constants.add(c);
}
} catch (Exception e) {
}
}
}
for (Class<?> c : classes) {
if (c != void.class && !c.isArray()) {
constants.add(snippetReflection.forObject(Array.newInstance(c, 42)));
}
}
constants.add(snippetReflection.forObject(new ArrayList<>()));
constants.add(snippetReflection.forObject(new IdentityHashMap<>()));
constants.add(snippetReflection.forObject(new LinkedHashMap<>()));
constants.add(snippetReflection.forObject(new TreeMap<>()));
constants.add(snippetReflection.forObject(new ArrayDeque<>()));
constants.add(snippetReflection.forObject(new LinkedList<>()));
constants.add(snippetReflection.forObject("a string"));
constants.add(snippetReflection.forObject(42));
constants.add(snippetReflection.forObject(String.class));
constants.add(snippetReflection.forObject(String[].class));
}