Examples with JavaType com.oracle.truffle.espresso.substitutions.JavaType used on opensource projects

Example 41 with JavaType

use of com.oracle.truffle.espresso.substitutions.JavaType in project graal by oracle.

the class VM method JVM_GetRecordComponents.

@VmImpl(isJni = true)
@TruffleBoundary
@JavaType(internalName = "[Ljava/lang/reflect/RecordComponent;")
public StaticObject JVM_GetRecordComponents(@JavaType(Class.class) StaticObject self) {
    Klass k = self.getMirrorKlass();
    if (!(k instanceof ObjectKlass)) {
        return StaticObject.NULL;
    }
    ObjectKlass klass = (ObjectKlass) k;
    RecordAttribute record = (RecordAttribute) klass.getAttribute(RecordAttribute.NAME);
    if (record == null) {
        return StaticObject.NULL;
    }
    RecordAttribute.RecordComponentInfo[] components = record.getComponents();
    return getMeta().java_lang_reflect_RecordComponent.allocateReferenceArray(components.length, (i) -> components[i].toGuestComponent(getMeta(), klass));
}

Example 42 with JavaType

use of com.oracle.truffle.espresso.substitutions.JavaType in project graal by oracle.

the class VM method JVM_GetVmArguments.

/**
 * Returns all values declared to the {@link EspressoOptions#VMArguments} option during context
 * creation.
 * <p>
 * In practice, this should be the list of arguments passed to the context, but depending on who
 * built it, it may be any arbitrary list of Strings.
 * <p>
 * Note that even if that's the case, it may differs slightly from the expected list of
 * arguments. The Java world expects this to be the arguments passed to the VM creation, which
 * is expected to have passed through the regular java launcher, and have been de-sugarified
 * (/ex: '-m [module]' -> '-Djdk.module.main=[module]').
 * <p>
 * In the Java-on-Truffle case, the VM arguments and the context builder options are equivalent,
 * but that is not true in the regular Espresso launcher case, or in an embedding scenario.
 */
@VmImpl(isJni = true)
@TruffleBoundary
@JavaType(String[].class)
public StaticObject JVM_GetVmArguments() {
    String[] vmArgs = getContext().getVmArguments();
    StaticObject array = getMeta().java_lang_String.allocateReferenceArray(vmArgs.length);
    for (int i = 0; i < vmArgs.length; i++) {
        getInterpreterToVM().setArrayObject(getMeta().toGuestString(vmArgs[i]), i, array);
    }
    return array;
}

Example 43 with JavaType

use of com.oracle.truffle.espresso.substitutions.JavaType in project graal by oracle.

the class VM method JVM_GetClassDeclaredConstructors.

// TODO(tg): inject constructor calltarget.
@VmImpl(isJni = true)
@JavaType(Constructor[].class)
public StaticObject JVM_GetClassDeclaredConstructors(@JavaType(Class.class) StaticObject self, boolean publicOnly) {
    Meta meta = getMeta();
    ArrayList<Method> collectedMethods = new ArrayList<>();
    Klass klass = self.getMirrorKlass();
    klass.ensureLinked();
    for (Method m : klass.getDeclaredConstructors()) {
        if (Name._init_.equals(m.getName()) && (!publicOnly || m.isPublic())) {
            collectedMethods.add(m);
        }
    }
    final Method[] constructors = collectedMethods.toArray(Method.EMPTY_ARRAY);
    EspressoContext context = meta.getContext();
    // TODO(peterssen): Cache guest j.l.reflect.Constructor constructor.
    // Calling the constructor is just for validation, manually setting the fields would be
    // faster.
    Method constructorInit = meta.java_lang_reflect_Constructor.lookupDeclaredMethod(Name._init_, context.getSignatures().makeRaw(Type._void, /* declaringClass */
    Type.java_lang_Class, /* parameterTypes */
    Type.java_lang_Class_array, /* checkedExceptions */
    Type.java_lang_Class_array, /* modifiers */
    Type._int, /* slot */
    Type._int, /* signature */
    Type.java_lang_String, /* annotations */
    Type._byte_array, /* parameterAnnotations */
    Type._byte_array));
    StaticObject arr = meta.java_lang_reflect_Constructor.allocateReferenceArray(constructors.length, new IntFunction<StaticObject>() {

        @Override
        public StaticObject apply(int i) {
            final Method m = constructors[i];
            Attribute rawRuntimeVisibleAnnotations = m.getAttribute(Name.RuntimeVisibleAnnotations);
            StaticObject runtimeVisibleAnnotations = rawRuntimeVisibleAnnotations != null ? StaticObject.wrap(rawRuntimeVisibleAnnotations.getData(), meta) : StaticObject.NULL;
            Attribute rawRuntimeVisibleParameterAnnotations = m.getAttribute(Name.RuntimeVisibleParameterAnnotations);
            StaticObject runtimeVisibleParameterAnnotations = rawRuntimeVisibleParameterAnnotations != null ? StaticObject.wrap(rawRuntimeVisibleParameterAnnotations.getData(), meta) : StaticObject.NULL;
            Attribute rawRuntimeVisibleTypeAnnotations = m.getAttribute(Name.RuntimeVisibleTypeAnnotations);
            StaticObject runtimeVisibleTypeAnnotations = rawRuntimeVisibleTypeAnnotations != null ? StaticObject.wrap(rawRuntimeVisibleTypeAnnotations.getData(), meta) : StaticObject.NULL;
            final Klass[] rawParameterKlasses = m.resolveParameterKlasses();
            StaticObject parameterTypes = meta.java_lang_Class.allocateReferenceArray(m.getParameterCount(), new IntFunction<StaticObject>() {

                @Override
                public StaticObject apply(int j) {
                    return rawParameterKlasses[j].mirror();
                }
            });
            final Klass[] rawCheckedExceptions = m.getCheckedExceptions();
            StaticObject checkedExceptions = meta.java_lang_Class.allocateReferenceArray(rawCheckedExceptions.length, new IntFunction<StaticObject>() {

                @Override
                public StaticObject apply(int j) {
                    return rawCheckedExceptions[j].mirror();
                }
            });
            SignatureAttribute signatureAttribute = (SignatureAttribute) m.getAttribute(Name.Signature);
            StaticObject genericSignature = StaticObject.NULL;
            if (signatureAttribute != null) {
                String sig = m.getConstantPool().symbolAt(signatureAttribute.getSignatureIndex(), "signature").toString();
                genericSignature = meta.toGuestString(sig);
            }
            StaticObject instance = meta.java_lang_reflect_Constructor.allocateInstance();
            constructorInit.invokeDirect(/* this */
            instance, /* declaringKlass */
            m.getDeclaringKlass().mirror(), /* parameterTypes */
            parameterTypes, /* checkedExceptions */
            checkedExceptions, /* modifiers */
            m.getMethodModifiers(), // TODO(peterssen): Fill method slot.
            i, /* signature */
            genericSignature, /* annotations */
            runtimeVisibleAnnotations, /* parameterAnnotations */
            runtimeVisibleParameterAnnotations);
            meta.HIDDEN_CONSTRUCTOR_KEY.setHiddenObject(instance, m);
            meta.HIDDEN_CONSTRUCTOR_RUNTIME_VISIBLE_TYPE_ANNOTATIONS.setHiddenObject(instance, runtimeVisibleTypeAnnotations);
            return instance;
        }
    });
    return arr;
}

Example 44 with JavaType

use of com.oracle.truffle.espresso.substitutions.JavaType in project graal by oracle.

the class VM method JVM_GetNestMembers.

@VmImpl(isJni = true)
@JavaType(Class[].class)
public StaticObject JVM_GetNestMembers(@JavaType(Class.class) StaticObject current) {
    Klass k = current.getMirrorKlass();
    Klass[] nestMembers = k.getNestMembers();
    StaticObject[] array = new StaticObject[nestMembers.length];
    for (int i = 0; i < nestMembers.length; i++) {
        array[i] = nestMembers[i].mirror();
    }
    return StaticObject.createArray(getMeta().java_lang_Class_array, array);
}

Example 45 with JavaType

use of com.oracle.truffle.espresso.substitutions.JavaType in project graal by oracle.

the class VM method JVM_Clone.

@VmImpl(isJni = true)
@JavaType(Object.class)
public static StaticObject JVM_Clone(@JavaType(Object.class) StaticObject self, @Inject Meta meta, @Inject SubstitutionProfiler profiler) {
    assert StaticObject.notNull(self);
    char exceptionBranch = 3;
    if (self.isArray()) {
        // Arrays are always cloneable.
        if (self.isForeignObject()) {
            return cloneForeignArray(self, meta, InteropLibrary.getUncached(self.rawForeignObject()), ToEspressoNodeGen.getUncached(), profiler, exceptionBranch);
        }
        return self.copy();
    }
    if (self.isForeignObject()) {
        profiler.profile(exceptionBranch);
        throw meta.throwExceptionWithMessage(meta.java_lang_CloneNotSupportedException, "Clone not supported for non-array foreign objects");
    }
    if (!meta.java_lang_Cloneable.isAssignableFrom(self.getKlass())) {
        profiler.profile(0);
        throw meta.throwException(meta.java_lang_CloneNotSupportedException);
    }
    if (InterpreterToVM.instanceOf(self, meta.java_lang_ref_Reference)) {
        // Non-strong references are not cloneable.
        if (// 
        InterpreterToVM.instanceOf(self, meta.java_lang_ref_WeakReference) || // 
        InterpreterToVM.instanceOf(self, meta.java_lang_ref_SoftReference) || // 
        InterpreterToVM.instanceOf(self, meta.java_lang_ref_FinalReference) || InterpreterToVM.instanceOf(self, meta.java_lang_ref_PhantomReference)) {
            profiler.profile(1);
            throw meta.throwExceptionWithMessage(meta.java_lang_CloneNotSupportedException, self.getKlass().getName().toString());
        }
    }
    final StaticObject clone = self.copy();
    // If the original object is finalizable, so is the copy.
    assert self.getKlass() instanceof ObjectKlass;
    if (((ObjectKlass) self.getKlass()).hasFinalizer()) {
        profiler.profile(2);
        meta.java_lang_ref_Finalizer_register.invokeDirect(null, clone);
    }
    return clone;
}