Use the same errno pointer in SVM NFI ErrnoMirror and NFIState

* This will be helpful when SVM supports the NFI Panama backend
  and allows mixing NFI backends like on JVM.

Author: eregon

substratevm/src/com.oracle.svm.truffle.nfi/src/com/oracle/svm/truffle/nfi/Target_com_oracle_truffle_nfi_backend_spi_NFIState.java

@@ -25,13 +25,52 @@
 package com.oracle.svm.truffle.nfi;
 
 import com.oracle.svm.core.annotate.Alias;
+import com.oracle.svm.core.annotate.Substitute;
 import com.oracle.svm.core.annotate.TargetClass;
+import com.oracle.svm.core.heap.VMOperationInfos;
+import com.oracle.svm.core.thread.JavaVMOperation;
+import com.oracle.svm.core.thread.PlatformThreads;
+import com.oracle.truffle.api.CompilerDirectives;
+import org.graalvm.nativeimage.IsolateThread;
 
 @TargetClass(className = "com.oracle.truffle.nfi.backend.spi.NFIState", onlyWith = TruffleNFIFeature.IsEnabled.class)
 final class Target_com_oracle_truffle_nfi_backend_spi_NFIState {
 
     @Alias boolean hasPendingException;
 
+    @Substitute
+    private static long initNfiErrnoAddress(Thread thread) {
+        var op = new GetErrnoMirrorAddressOperation(thread);
+        op.enqueue();
+        long address = op.result;
+        if (address == 0) {
+            throw CompilerDirectives.shouldNotReachHere("Could not find the IsolateThread for " + thread);
+        }
+        return address;
+    }
+
+    @Substitute
+    private void freeNfiErrnoAddress() {
+    }
+
+    private static class GetErrnoMirrorAddressOperation extends JavaVMOperation {
+        private final Thread thread;
+        private long result = 0;
+
+        GetErrnoMirrorAddressOperation(Thread thread) {
+            super(VMOperationInfos.get(GetErrnoMirrorAddressOperation.class, "Get ErrnoMirror address", SystemEffect.SAFEPOINT));
+            this.thread = thread;
+        }
+
+        @Override
+        protected void operate() {
+            IsolateThread isolateThread = PlatformThreads.getIsolateThread(thread);
+            if (isolateThread.isNonNull()) {
+                this.result = ErrnoMirror.errnoMirror.getAddress(isolateThread).rawValue();
+            }
+        }
+    }
+
     @Alias
     native void setPendingException(Throwable t);
 }

truffle/src/com.oracle.truffle.nfi.backend.spi/src/com/oracle/truffle/nfi/backend/spi/NFIState.java

@@ -45,7 +45,12 @@
 import java.lang.reflect.Field;
 
 /**
- * Thread-local state of the NFI that is shared between different backends.
+ * Thread-local state of the NFI that is shared between different backends. All methods should only
+ * be called from the corresponding thread to which this state belongs (for thread-safety reasons
+ * and because the SVM NFI backend relies on it by using a FastThreadLocalBytes for the errno
+ * pointer, which means the errno pointer points inside the IsolateThread), except the constructor
+ * and {@link #dispose()} which may be called from another thread, as Truffle hooks which call those
+ * are not guaranteed to be called from the corresponding thread.
  */
 public final class NFIState {
 
@@ -76,9 +81,8 @@ public final class NFIState {
     // for faster query from JNI
     boolean hasPendingException;
 
-    public NFIState() {
-        this.nfiErrnoAddress = UNSAFE.allocateMemory(Integer.BYTES);
-        UNSAFE.putInt(nfiErrnoAddress, 0);
+    public NFIState(Thread thread) {
+        this.nfiErrnoAddress = initNfiErrnoAddress(thread);
     }
 
     public int getNFIErrno() {
@@ -104,7 +108,17 @@ public void clearPendingException() {
         hasPendingException = false;
     }
 
-    public void dispose() {
+    private static long initNfiErrnoAddress(@SuppressWarnings("unused") Thread thread) {
+        long address = UNSAFE.allocateMemory(Integer.BYTES);
+        UNSAFE.putInt(address, 0);
+        return address;
+    }
+
+    private void freeNfiErrnoAddress() {
         UNSAFE.freeMemory(this.nfiErrnoAddress);
     }
+
+    public void dispose() {
+        freeNfiErrnoAddress();
+    }
 }

truffle/src/com.oracle.truffle.nfi/src/com/oracle/truffle/nfi/NFILanguage.java

@@ -61,7 +61,7 @@ public class NFILanguage extends TruffleLanguage<NFIContext> {
 
     private final Assumption singleContextAssumption = Truffle.getRuntime().createAssumption("NFI single context");
 
-    final ContextThreadLocal<NFIState> nfiState = locals.createContextThreadLocal((ctx, thread) -> new NFIState());
+    final ContextThreadLocal<NFIState> nfiState = locals.createContextThreadLocal((ctx, thread) -> new NFIState(thread));
 
     protected void setPendingException(Throwable pendingException) {
         TruffleStackTrace.fillIn(pendingException);