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

Example 1 with JavaType

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

the class JniEnv method CallStaticObjectMethodVarargs.

// endregion CallNonvirtual*Method
// region CallStatic*Method
@JniImpl
@JavaType(Object.class)
public StaticObject CallStaticObjectMethodVarargs(@JavaType(Class.class) StaticObject clazz, @Handle(Method.class) long methodId, @Pointer TruffleObject varargsPtr) {
    Method method = methodIds.getObject(methodId);
    assert method.isStatic();
    assert (clazz.getMirrorKlass()) == method.getDeclaringKlass();
    Object result = method.invokeDirect(null, popVarArgs(varargsPtr, method.getParsedSignature()));
    return getMeta().asObject(result);
}

Example 2 with JavaType

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

the class JniEnv method FindClass.

/**
 * <h3>jclass FindClass(JNIEnv *env, const char *name);</h3>
 *
 * <p>
 * FindClass locates the class loader associated with the current native method; that is, the
 * class loader of the class that declared the native method. If the native method belongs to a
 * system class, no class loader will be involved. Otherwise, the proper class loader will be
 * invoked to load and link the named class. Since Java 2 SDK release 1.2, when FindClass is
 * called through the Invocation Interface, there is no current native method or its associated
 * class loader. In that case, the result of {@link ClassLoader#getSystemClassLoader} is used.
 * This is the class loader the virtual machine creates for applications, and is able to locate
 * classes listed in the java.class.path property. The name argument is a fully-qualified class
 * name or an array type signature .
 * <p>
 * For example, the fully-qualified class name for the {@code java.lang.String} class is:
 *
 * <pre>
 * "java/lang/String"}
 * </pre>
 *
 * <p>
 * The array type signature of the array class {@code java.lang.Object[]} is:
 *
 * <pre>
 * "[Ljava/lang/Object;"
 * </pre>
 *
 * @param namePtr a fully-qualified class name (that is, a package name, delimited by "/",
 *            followed by the class name). If the name begins with "[" (the array signature
 *            character), it returns an array class. The string is encoded in modified UTF-8.
 * @return Returns a class object from a fully-qualified name, or NULL if the class cannot be
 *         found.
 * @throws ClassFormatError if the class data does not specify a valid class.
 * @throws ClassCircularityError if a class or interface would be its own superclass or
 *             superinterface.
 * @throws NoClassDefFoundError if no definition for a requested class or interface can be
 *             found.
 * @throws OutOfMemoryError if the system runs out of memory.
 */
@TruffleBoundary
@JniImpl
@JavaType(Class.class)
public StaticObject FindClass(@Pointer TruffleObject namePtr, @Inject SubstitutionProfiler profiler) {
    String name = NativeUtils.interopPointerToString(namePtr);
    Meta meta = getMeta();
    if (name == null || (name.indexOf('.') > -1)) {
        profiler.profile(7);
        throw meta.throwExceptionWithMessage(meta.java_lang_NoClassDefFoundError, name);
    }
    String internalName = name;
    if (!name.startsWith("[")) {
        // Force 'L' type.
        internalName = "L" + name + ";";
    }
    if (!Validation.validTypeDescriptor(ByteSequence.create(internalName), true)) {
        profiler.profile(6);
        throw meta.throwExceptionWithMessage(meta.java_lang_NoClassDefFoundError, name);
    }
    StaticObject protectionDomain = StaticObject.NULL;
    StaticObject loader = StaticObject.NULL;
    // security stack walk
    StaticObject caller = getVM().JVM_GetCallerClass(0, profiler);
    if (StaticObject.notNull(caller)) {
        Klass callerKlass = caller.getMirrorKlass();
        loader = callerKlass.getDefiningClassLoader();
        if (StaticObject.isNull(loader) && Type.java_lang_ClassLoader$NativeLibrary.equals(callerKlass.getType())) {
            StaticObject result = (StaticObject) getMeta().java_lang_ClassLoader$NativeLibrary_getFromClass.invokeDirect(null);
            loader = result.getMirrorKlass().getDefiningClassLoader();
            protectionDomain = getVM().JVM_GetProtectionDomain(result);
        }
    } else {
        loader = (StaticObject) getMeta().java_lang_ClassLoader_getSystemClassLoader.invokeDirect(null);
    }
    StaticObject guestClass = StaticObject.NULL;
    try {
        String dotName = name.replace('/', '.');
        guestClass = (StaticObject) getMeta().java_lang_Class_forName_String_boolean_ClassLoader.invokeDirect(null, meta.toGuestString(dotName), false, loader);
        EspressoError.guarantee(StaticObject.notNull(guestClass), "Class.forName returned null");
    } catch (EspressoException e) {
        profiler.profile(5);
        if (InterpreterToVM.instanceOf(e.getGuestException(), meta.java_lang_ClassNotFoundException)) {
            profiler.profile(4);
            throw meta.throwExceptionWithMessage(meta.java_lang_NoClassDefFoundError, name);
        }
        throw e;
    }
    meta.HIDDEN_PROTECTION_DOMAIN.setHiddenObject(guestClass, protectionDomain);
    // FindClass should initialize the class.
    guestClass.getMirrorKlass().safeInitialize();
    return guestClass;
}

Example 3 with JavaType

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

the class JniEnv method NewObjectVarargs.

@JniImpl
@JavaType(Object.class)
public StaticObject NewObjectVarargs(@JavaType(Class.class) StaticObject clazz, @Handle(Method.class) long methodId, @Pointer TruffleObject varargsPtr) {
    Method method = methodIds.getObject(methodId);
    assert method.isConstructor();
    Klass klass = clazz.getMirrorKlass();
    if (klass.isInterface() || klass.isAbstract()) {
        Meta meta = getMeta();
        throw meta.throwException(meta.java_lang_InstantiationException);
    }
    klass.initialize();
    StaticObject instance;
    if (CompilerDirectives.isPartialEvaluationConstant(klass)) {
        instance = klass.allocateInstance();
    } else {
        instance = allocateBoundary(klass);
    }
    method.invokeDirect(instance, popVarArgs(varargsPtr, method.getParsedSignature()));
    return instance;
}

Example 4 with JavaType

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

the class JniEnv method ToReflectedField.

/**
 * <h3>jobject ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
 * </h3>
 * <p>
 * Converts a field ID derived from cls to a java.lang.reflect.Field object. isStatic must be
 * set to JNI_TRUE if fieldID refers to a static field, and JNI_FALSE otherwise.
 * <p>
 * Throws OutOfMemoryError and returns 0 if fails.
 */
@JniImpl
@JavaType(java.lang.reflect.Field.class)
public StaticObject ToReflectedField(@JavaType(Class.class) StaticObject unused, @Handle(Field.class) long fieldId, @SuppressWarnings("unused") boolean isStatic) {
    Field field = fieldIds.getObject(fieldId);
    assert field.getDeclaringKlass().isAssignableFrom(unused.getMirrorKlass());
    StaticObject fields = getVM().JVM_GetClassDeclaredFields(field.getDeclaringKlass().mirror(), false);
    for (StaticObject declField : fields.<StaticObject[]>unwrap()) {
        assert InterpreterToVM.instanceOf(declField, getMeta().java_lang_reflect_Field);
        Field f = (Field) getMeta().HIDDEN_FIELD_KEY.getHiddenObject(declField);
        if (field == f) {
            return declField;
        }
    }
    throw EspressoError.shouldNotReachHere("Field not found ", field);
}

Example 5 with JavaType

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

the class JniEnv method RegisterNative.

// endregion DirectBuffers
// region Register/Unregister natives
@JniImpl
@TruffleBoundary
public int RegisterNative(@JavaType(Class.class) StaticObject clazz, @Pointer TruffleObject methodNamePtr, @Pointer TruffleObject methodSignaturePtr, @Pointer TruffleObject closure) {
    String methodName = NativeUtils.interopPointerToString(methodNamePtr);
    String methodSignature = NativeUtils.interopPointerToString(methodSignaturePtr);
    assert methodName != null && methodSignature != null;
    Symbol<Name> name = getNames().lookup(methodName);
    Symbol<Signature> signature = getSignatures().lookupValidSignature(methodSignature);
    Meta meta = getMeta();
    if (name == null || signature == null) {
        setPendingException(Meta.initException(meta.java_lang_NoSuchMethodError));
        return JNI_ERR;
    }
    Method targetMethod = clazz.getMirrorKlass().lookupDeclaredMethod(name, signature);
    if (targetMethod != null && targetMethod.isNative()) {
        targetMethod.unregisterNative();
        getSubstitutions().removeRuntimeSubstitution(targetMethod);
    } else {
        setPendingException(Meta.initException(meta.java_lang_NoSuchMethodError));
        return JNI_ERR;
    }
    Substitutions.EspressoRootNodeFactory factory = null;
    // Lookup known VM methods to shortcut native boudaries.
    factory = lookupKnownVmMethods(closure, targetMethod);
    if (factory == null) {
        NativeSignature ns = Method.buildJniNativeSignature(targetMethod.getParsedSignature());
        final TruffleObject boundNative = getNativeAccess().bindSymbol(closure, ns);
        factory = createJniRootNodeFactory(() -> new NativeMethodNode(boundNative, targetMethod.getMethodVersion()), targetMethod);
    }
    Symbol<Type> classType = clazz.getMirrorKlass().getType();
    getSubstitutions().registerRuntimeSubstitution(classType, name, signature, factory, true);
    return JNI_OK;
}