Add boundary around copyMemory and setMemory calls

Author: msimacek

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ctypes/CFieldBuiltins.java

@@ -652,8 +652,7 @@ static Object z_set(@SuppressWarnings("unused") FieldSet setfunc, Pointer ptr, O
                         @Shared @Cached PointerNodes.PointerFromLongNode pointerFromLongNode,
                         @CachedLibrary(limit = "1") PythonBufferAccessLibrary bufferLib,
                         @Shared @Cached PointerNodes.WritePointerNode writePointerNode,
-                        @Shared @Cached PRaiseNode raiseNode,
-                        @Shared @Cached PythonObjectFactory factory) {
+                        @Shared @Cached PRaiseNode raiseNode) {
             if (value == PNone.NONE) {
                 writePointerNode.execute(inliningTarget, ptr, Pointer.NULL);
                 return PNone.NONE;
@@ -688,7 +687,7 @@ static Object Z_set(@SuppressWarnings("unused") FieldSet setfunc, Pointer ptr, O
                         @Cached TruffleString.CopyToByteArrayNode copyToByteArrayNode,
                         @Shared @Cached PointerNodes.WritePointerNode writePointerNode,
                         @Shared @Cached PRaiseNode raiseNode,
-                        @Shared @Cached PythonObjectFactory factory) { // CTYPES_UNICODE
+                        @Cached PythonObjectFactory factory) { // CTYPES_UNICODE
             if (value == PNone.NONE) {
                 writePointerNode.execute(inliningTarget, ptr, Pointer.NULL);
                 return PNone.NONE;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ctypes/memory/PointerNodes.java

@@ -134,8 +134,8 @@ static void doPointerArray(Node inliningTarget, byte[] dst, int dstOffset, Memor
 
         @Specialization
         static void doNativeMemory(Node inliningTarget, byte[] dst, int dstOffset, @SuppressWarnings("unused") MemoryBlock srcMemory, LongPointerStorage src, int srcOffset, int size) {
-            Unsafe unsafe = PythonContext.get(inliningTarget).getUnsafe();
-            unsafe.copyMemory(null, src.pointer + srcOffset, dst, byteArrayOffset(dstOffset), size);
+            PythonContext context = PythonContext.get(inliningTarget);
+            context.copyNativeMemory(dst, dstOffset, src.pointer + srcOffset, size);
         }
     }
 
@@ -327,8 +327,8 @@ static void doMemoryView(@SuppressWarnings("unused") MemoryBlock dstMemory, Memo
 
         @Specialization
         static void doNativeMemory(Node inliningTarget, @SuppressWarnings("unused") MemoryBlock dstMemory, LongPointerStorage dst, int dstOffset, byte[] src, int srcOffset, int size) {
-            Unsafe unsafe = PythonContext.get(inliningTarget).getUnsafe();
-            unsafe.copyMemory(src, byteArrayOffset(srcOffset), null, dst.pointer + dstOffset, size);
+            PythonContext context = PythonContext.get(inliningTarget);
+            context.copyNativeMemory(dst.pointer + dstOffset, src, srcOffset, size);
         }
 
         @Specialization
@@ -627,7 +627,7 @@ static long doBytes(Node inliningTarget, MemoryBlock memory, ByteArrayStorage st
             // We need to copy the whole memory block to keep the pointer offsets consistent
             PythonContext context = PythonContext.get(inliningTarget);
             long pointer = context.allocateNativeMemory(len);
-            context.getUnsafe().copyMemory(storage.bytes, byteArrayOffset(0), null, pointer, len);
+            context.copyNativeMemory(pointer, storage.bytes, 0, len);
             memory.storage = new LongPointerStorage(pointer);
             return pointer + offset;
         }
@@ -637,7 +637,7 @@ static long doZero(Node inliningTarget, MemoryBlock memory, ZeroStorage storage,
             int len = storage.size;
             PythonContext context = PythonContext.get(inliningTarget);
             long pointer = context.allocateNativeMemory(len);
-            context.getUnsafe().setMemory(pointer, len, (byte) 0);
+            context.setNativeMemory(pointer, len, (byte) 0);
             memory.storage = new LongPointerStorage(pointer);
             return pointer + offset;
         }
@@ -873,8 +873,4 @@ static ByteArrayStorage convert(Node inliningTarget, MemoryBlock memory, Pointer
             return newStorage;
         }
     }
-
-    private static long byteArrayOffset(int offset) {
-        return (long) Unsafe.ARRAY_BYTE_BASE_OFFSET + (long) Unsafe.ARRAY_BYTE_INDEX_SCALE * (long) offset;
-    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonContext.java

@@ -2534,16 +2534,50 @@ public Unsafe getUnsafe() {
             return UnsafeWrapper.UNSAFE;
         }
         CompilerDirectives.transferToInterpreterAndInvalidate();
-        throw new RuntimeException("NAtive access not allowed, cannot manipulate native memory");
+        throw new RuntimeException("Native access not allowed, cannot manipulate native memory");
     }
 
-    @TruffleBoundary
     public long allocateNativeMemory(long size) {
-        return getUnsafe().allocateMemory(size);
+        return allocateNativeMemoryBoundary(getUnsafe(), size);
     }
 
     @TruffleBoundary
+    private static long allocateNativeMemoryBoundary(Unsafe unsafe, long size) {
+        return unsafe.allocateMemory(size);
+    }
+
     public void freeNativeMemory(long address) {
-        getUnsafe().freeMemory(address);
+        freeNativeMemoryBoundary(getUnsafe(), address);
+    }
+
+    @TruffleBoundary
+    private static void freeNativeMemoryBoundary(Unsafe unsafe, long address) {
+        unsafe.freeMemory(address);
+    }
+
+    public void copyNativeMemory(long dst, byte[] src, int srcOffset, int size) {
+        copyNativeMemoryBoundary(getUnsafe(), null, dst, src, byteArrayOffset(srcOffset), size);
+    }
+
+    public void copyNativeMemory(byte[] dst, int dstOffset, long src, int size) {
+        copyNativeMemoryBoundary(getUnsafe(), dst, byteArrayOffset(dstOffset), null, src, size);
+    }
+
+    private static long byteArrayOffset(int offset) {
+        return (long) Unsafe.ARRAY_BYTE_BASE_OFFSET + (long) Unsafe.ARRAY_BYTE_INDEX_SCALE * (long) offset;
+    }
+
+    @TruffleBoundary
+    private static void copyNativeMemoryBoundary(Unsafe unsafe, Object dst, long dstOffset, Object src, long srcOffset, int size) {
+        unsafe.copyMemory(src, srcOffset, dst, dstOffset, size);
+    }
+
+    public void setNativeMemory(long pointer, int size, byte value) {
+        setNativeMemoryBoundary(getUnsafe(), pointer, size, value);
+    }
+
+    @TruffleBoundary
+    private static void setNativeMemoryBoundary(Unsafe unsafe, long pointer, int size, byte value) {
+        unsafe.setMemory(pointer, size, value);
     }
 }