Low-level Runtime substitutions:

- Most of the substitutions just simply link against VM methods.
- Introduction of JNU to store system encodings

Author: Elia Trachsel

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/descriptors/EspressoSymbols.java

@@ -185,6 +185,8 @@ public static void ensureInitialized() {
         public static final Symbol<Type> sun_nio_ch_IOStatus = SYMBOLS.putType("Lsun/nio/ch/IOStatus;");
         public static final Symbol<Type> java_net_spi_InetAddressResolver$LookupPolicy = SYMBOLS.putType("Ljava/net/spi/InetAddressResolver$LookupPolicy;");
         public static final Symbol<Type> sun_nio_ch_Net = SYMBOLS.putType("Lsun/nio/ch/Net;");
+        // libjava
+        public static final Symbol<Type> java_lang_ProcessHandleImpl$Info = SYMBOLS.putType("Ljava/lang/ProcessHandleImpl$Info;");
         // libnio
         public static final Symbol<Type> sun_nio_fs_TruffleFilteredDirectoryStream$ForeignDirectoryStream = SYMBOLS.putType("Lsun/nio/fs/TruffleFilteredDirectoryStream$ForeignDirectoryStream;");
         public static final Symbol<Type> sun_nio_fs_TruffleFilteredDirectoryStream$ForeignIterator = SYMBOLS.putType("Lsun/nio/fs/TruffleFilteredDirectoryStream$ForeignIterator;");
@@ -826,6 +828,14 @@ public static class Names {
         public static final Symbol<Name> SHUT_RD = SYMBOLS.putName("SHUT_RD");
         public static final Symbol<Name> SHUT_WR = SYMBOLS.putName("SHUT_WR");
         public static final Symbol<Name> SHUT_RDWR = SYMBOLS.putName("SHUT_RDWR");
+        // java.lang.ProcessHandleImpl$Info
+        public static final Symbol<Name> command = SYMBOLS.putName("command");
+        public static final Symbol<Name> commandLine = SYMBOLS.putName("commandLine");
+        public static final Symbol<Name> arguments = SYMBOLS.putName("arguments");
+        public static final Symbol<Name> startTime = SYMBOLS.putName("startTime");
+        public static final Symbol<Name> totalTime = SYMBOLS.putName("totalTime");
+        public static final Symbol<Name> user = SYMBOLS.putName("user");
+        public static final Symbol<Name> initialized = SYMBOLS.putName("initialized");
         // java.lang.invoke.*
         // CallSite
         public static final Symbol<Name> target = SYMBOLS.putName("target");

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/InformationLeak.java

@@ -22,7 +22,10 @@
  */
 package com.oracle.truffle.espresso.libs;
 
+import java.io.Console;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.net.InetSocketAddress;
@@ -42,9 +45,13 @@
 /**
  * In the context of the EspressoLibs project, this class is designed to aggregate methods and
  * fields that potentially leak information about the host system. Depending on the context, leaking
- * such information might not be preferable due to security or privacy concerns.
+ * such information might not be preferable due to security or privacy concerns. However, it is
+ * assumed that permission checks are done in the caller's of InformationLeak. Please note it leaks
+ * host information, meaning return types should not be StaticObjects!
  */
 public class InformationLeak {
+    private static final Method IS_TERMINAL_METHOD = getIsTerminalMethod();
+
     private final EspressoContext context;
     private volatile boolean isIPv6Initialized = false;
     private boolean isIPv6Available = false;
@@ -53,6 +60,25 @@ public InformationLeak(EspressoContext ctx) {
         this.context = ctx;
     }
 
+    private static Method getIsTerminalMethod() {
+        try {
+            return Console.class.getMethod("isTerminal");
+        } catch (NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    public long getPid() {
+        return ProcessHandle.current().pid();
+    }
+
+    @TruffleBoundary
+    public ProcessHandle.Info getProcessHandleInfo(long pid) {
+        assert context.getEnv().isCreateProcessAllowed();
+        Optional<ProcessHandle> processHandle = ProcessHandle.of(pid);
+        return processHandle.map(ProcessHandle::info).orElse(null);
+    }
+
     public boolean isIPv6Available() {
         if (isIPv6Initialized) {
             return isIPv6Available;
@@ -91,6 +117,34 @@ public boolean isReusePortAvailable0() {
         }
     }
 
+    public boolean istty() {
+        if (!(context.getEnv().in() == System.in && context.getEnv().out() == System.out)) {
+            return false;
+        }
+        Console console = System.console();
+        if (console == null) {
+            return false;
+        }
+        if (IS_TERMINAL_METHOD != null) {
+            try {
+                return (boolean) IS_TERMINAL_METHOD.invoke(console);
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new Error(e);
+            }
+        } else {
+            return true;
+        }
+    }
+
+    public String consoleEncoding() {
+        if (OS.getCurrent() == OS.Windows) {
+            if (istty()) {
+                throw Throw.throwUnsupported("console encoding for windows is currently unimplemented", context);
+            }
+        }
+        return null;
+    }
+
     @TruffleBoundary
     public int isExclusiveBindAvailable() {
         assert context.getEnv().isSocketIOAllowed();

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/JNU.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.espresso.libs;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * A class to guarantee consistency when encoding and decoding bytes to strings between the guest
+ * and host world.
+ *
+ * The guest gets its charSet for encoding and decoding from System.getProperty("sun.jnu.encoding").
+ * We substitute this with the charSet specified in this class. Then on the host side, we just
+ * simply use the same charSet.
+ */
+public class JNU {
+    private static final Charset charSet = StandardCharsets.UTF_8;
+
+    public static Charset getCharSet() {
+        return charSet;
+    }
+
+    public static String getString(byte[] arr, int index, int length) {
+        return new String(arr, index, length, charSet);
+    }
+}

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/LibsMeta.java

@@ -47,6 +47,7 @@ public final class LibsMeta implements ContextAccess {
     public final ObjectKlass sun_nio_fs_TruffleFilteredDirectoryStream$ForeignIterator;
     public final Field sun_nio_fs_TruffleFilteredDirectoryStream$ForeignIterator_HIDDEN_HOST_REFERENCE;
     public final Method sun_nio_fs_TruffleFilteredDirectoryStream$ForeignIterator_init;
+
     // libzip
     public final ObjectKlass java_util_zip_CRC32;
     public final Field HIDDEN_CRC32;
@@ -55,9 +56,21 @@ public final class LibsMeta implements ContextAccess {
     public final Field java_util_zip_Inflater_outputConsumed;
     public final ObjectKlass java_util_zip_DataFormatException;
 
+    // libjava
+    public final ObjectKlass java_lang_ProcessHandleImpl$Info;
+    public final Field java_lang_ProcessHandleImpl$Info_command;
+    public final Field java_lang_ProcessHandleImpl$Info_commandLine;
+    public final Field java_lang_ProcessHandleImpl$Info_arguments;
+    public final Field java_lang_ProcessHandleImpl$Info_startTime;
+    public final Field java_lang_ProcessHandleImpl$Info_totalTime;
+    public final Field java_lang_ProcessHandleImpl$Info_user;
+    public final ObjectKlass java_lang_SecurityManager;
+    public final Field java_lang_SecurityManager_initialized;
+
     // libnet
     public final ObjectKlass java_net_NetworkInterface;
     public final LibNetMeta net;
+
     // Checkstyle: resume field name check
 
     @Override
@@ -92,6 +105,21 @@ public LibsMeta(EspressoContext ctx) {
         java_util_zip_Inflater_inputConsumed = java_util_zip_Inflater.requireDeclaredField(EspressoSymbols.Names.inputConsumed, EspressoSymbols.Types._int);
         java_util_zip_Inflater_outputConsumed = java_util_zip_Inflater.requireDeclaredField(EspressoSymbols.Names.outputConsumed, EspressoSymbols.Types._int);
 
+        // libjava
+        java_lang_ProcessHandleImpl$Info = knownKlass(EspressoSymbols.Types.java_lang_ProcessHandleImpl$Info);
+        java_lang_ProcessHandleImpl$Info_command = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.command, EspressoSymbols.Types.java_lang_String);
+        java_lang_ProcessHandleImpl$Info_commandLine = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.commandLine, EspressoSymbols.Types.java_lang_String);
+        java_lang_ProcessHandleImpl$Info_arguments = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.arguments, EspressoSymbols.Types.java_lang_String_array);
+        java_lang_ProcessHandleImpl$Info_startTime = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.startTime, EspressoSymbols.Types._long);
+        java_lang_ProcessHandleImpl$Info_totalTime = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.totalTime, EspressoSymbols.Types._long);
+        java_lang_ProcessHandleImpl$Info_user = java_lang_ProcessHandleImpl$Info.requireDeclaredField(EspressoSymbols.Names.user, EspressoSymbols.Types.java_lang_String);
+        java_lang_SecurityManager = knownKlass(EspressoSymbols.Types.java_lang_SecurityManager);
+        if (context.getJavaVersion().java25OrLater()) {
+            java_lang_SecurityManager_initialized = null;
+        } else {
+            java_lang_SecurityManager_initialized = java_lang_SecurityManager.requireDeclaredField(EspressoSymbols.Names.initialized, EspressoSymbols.Types._boolean);
+        }
+
         // libnet
         java_net_NetworkInterface = knownKlass(EspressoSymbols.Types.java_net_NetworkInterface);
         this.net = context.getEnv().isSocketIOAllowed() ? new LibNetMeta() : null;

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/LibsState.java

@@ -49,9 +49,12 @@ public class LibsState {
 
     private final StrongHandles<Inflater> handle2Inflater = new StrongHandles<>();
 
+    private final EspressoContext context;
+
     public final LibsStateNet net;
 
     public LibsState(EspressoContext context, LibsMeta lMeta) {
+        this.context = context;
         this.net = (context.getEnv().isSocketIOAllowed()) ? new LibsStateNet(context, lMeta) : null;
     }
 
@@ -81,6 +84,12 @@ private static EspressoException throwInternalError() {
         return meta.throwExceptionWithMessage(meta.java_lang_InternalError, "the provided handle doesn't correspond to an Inflater");
     }
 
+    public void checkCreateProcessAllowed() {
+        if (!context.getEnv().isCreateProcessAllowed()) {
+            throw Throw.throwSecurityException("process creation is not allowed!", context);
+        }
+    }
+
     public final class LibsStateNet {
         private final EspressoContext context;
         private final LibsMeta lMeta;

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/libjava/impl/Target_java_io_Console.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.espresso.libs.libjava.impl;
+
+import java.io.Console;
+
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.espresso.libs.InformationLeak;
+import com.oracle.truffle.espresso.libs.libjava.LibJava;
+import com.oracle.truffle.espresso.meta.Meta;
+import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
+import com.oracle.truffle.espresso.substitutions.EspressoSubstitutions;
+import com.oracle.truffle.espresso.substitutions.Inject;
+import com.oracle.truffle.espresso.substitutions.JavaType;
+import com.oracle.truffle.espresso.substitutions.Substitution;
+import com.oracle.truffle.espresso.substitutions.VersionFilter;
+
+@EspressoSubstitutions(value = Console.class, group = LibJava.class)
+public final class Target_java_io_Console {
+    @Substitution
+    @TruffleBoundary
+    public static boolean istty(@Inject InformationLeak iL) {
+        return iL.istty();
+    }
+
+    @Substitution(languageFilter = VersionFilter.Java23OrEarlier.class)
+    public static @JavaType(String.class) StaticObject encoding(@Inject InformationLeak iL, @Inject Meta meta) {
+        String encoding = iL.consoleEncoding();
+        return meta.toGuestString(encoding);
+    }
+}

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/libjava/impl/Target_java_lang_ClassLoader.java

@@ -22,12 +22,16 @@
  */
 package com.oracle.truffle.espresso.libs.libjava.impl;
 
+import java.nio.ByteBuffer;
 import java.security.ProtectionDomain;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.espresso.EspressoLanguage;
 import com.oracle.truffle.espresso.classfile.descriptors.Symbol;
 import com.oracle.truffle.espresso.classfile.descriptors.Type;
+import com.oracle.truffle.espresso.ffi.Pointer;
+import com.oracle.truffle.espresso.ffi.nfi.NativeUtils;
 import com.oracle.truffle.espresso.libs.libjava.LibJava;
 import com.oracle.truffle.espresso.runtime.EspressoContext;
 import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
@@ -135,6 +139,39 @@ public static void registerNatives() {
         return ctx.getVM().defineClass(type, loader, pd, buf);
     }
 
+    @Substitution
+    @TruffleBoundary
+    public static @JavaType(Class.class) StaticObject defineClass2(@JavaType(ClassLoader.class) StaticObject loader, @JavaType(String.class) StaticObject name,
+                    @JavaType(ByteBuffer.class) StaticObject data, int off, int len,
+                    @JavaType(ProtectionDomain.class) StaticObject pd,
+                    // TODO: source unused
+                    @SuppressWarnings("unused") @JavaType(String.class) StaticObject source,
+                    @Inject EspressoContext ctx) {
+        if (StaticObject.isNull(data)) {
+            throw ctx.getMeta().throwNullPointerException();
+        }
+        if (len < 0 || off < 0) {
+            throw ctx.getMeta().throwIndexOutOfBoundsExceptionBoundary("ByteBuffer", off, len);
+        }
+
+        // retrieve the GuestBuffer as Array
+        @Pointer
+        TruffleObject dataAddrPointer = ctx.getJNI().GetDirectBufferAddress(data);
+        ByteBuffer dataBuffer = NativeUtils.directByteBuffer(dataAddrPointer, len + off);
+
+        Symbol<Type> type = null;
+        if (StaticObject.notNull(name)) {
+            type = ctx.getVM().nameToInternal(toSlashName(ctx.getMeta().toHostString(name)));
+        }
+
+        // read into array
+        byte[] buf = new byte[len];
+        dataBuffer.get(off, buf);
+
+        return ctx.getVM().defineClass(type, loader, pd, buf);
+
+    }
+
     private static String toSlashName(String name) {
         return name.replace('.', '/');
     }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/libs/libjava/impl/Target_java_lang_PhantomReference.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.truffle.espresso.libs.libjava.impl;
+
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+
+import com.oracle.truffle.espresso.libs.libjava.LibJava;
+import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
+import com.oracle.truffle.espresso.substitutions.EspressoSubstitutions;
+import com.oracle.truffle.espresso.substitutions.Inject;
+import com.oracle.truffle.espresso.substitutions.JavaType;
+import com.oracle.truffle.espresso.substitutions.Substitution;
+import com.oracle.truffle.espresso.substitutions.SubstitutionProfiler;
+import com.oracle.truffle.espresso.substitutions.VersionFilter;
+import com.oracle.truffle.espresso.vm.VM;
+
+@EspressoSubstitutions(value = PhantomReference.class, group = LibJava.class)
+public final class Target_java_lang_PhantomReference {
+    @Substitution(hasReceiver = true, languageFilter = VersionFilter.Java25OrLater.class)
+    public static void clear0(@JavaType(Reference.class) StaticObject ref,
+                    @Inject SubstitutionProfiler profiler, @Inject VM vm) {
+        vm.JVM_ReferenceClear(ref, profiler);
+
+    }
+
+    @Substitution(hasReceiver = true)
+    public static boolean refersTo0(@JavaType(Reference.class) StaticObject ref, @JavaType(Object.class) StaticObject object,
+                    @Inject SubstitutionProfiler profiler, @Inject VM vm) {
+        return vm.JVM_PhantomReferenceRefersTo(ref, object, profiler);
+    }
+
+}