Add Garbage collection for CDataObject memory

Author: msimacek

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

@@ -60,6 +60,7 @@
 import com.oracle.graal.python.builtins.modules.ctypes.FFIType.FFI_TYPES;
 import com.oracle.graal.python.builtins.modules.ctypes.memory.Pointer;
 import com.oracle.graal.python.builtins.modules.ctypes.memory.PointerNodes;
+import com.oracle.graal.python.builtins.modules.ctypes.memory.PointerReference;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetBaseClassNode;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.InlinedIsSameTypeNode;
 import com.oracle.graal.python.nodes.PRaiseNode;
@@ -332,14 +333,19 @@ public abstract static class CreateCDataObjectNode extends Node {
         public abstract CDataObject execute(Node inliningTarget, Object type, Pointer pointer, int size, boolean needsfree);
 
         @Specialization
-        static CDataObject doCreate(Object type, Pointer pointer, int size, boolean needsfree,
+        static CDataObject doCreate(Node inliningTarget, Object type, Pointer pointer, int size, boolean needsfree,
                         @Cached IsSubtypeNode isSubtypeNode,
                         @Cached PythonObjectFactory factory) {
+            CDataObject result;
             if (isSubtypeNode.execute(type, PyCFuncPtr)) {
-                return factory.createPyCFuncPtrObject(type, pointer, size, needsfree);
+                result = factory.createPyCFuncPtrObject(type, pointer, size, needsfree);
             } else {
-                return factory.createCDataObject(type, pointer, size, needsfree);
+                result = factory.createCDataObject(type, pointer, size, needsfree);
             }
+            if (needsfree) {
+                new PointerReference(result, pointer, PythonContext.get(inliningTarget).getSharedFinalizer());
+            }
+            return result;
         }
     }
 

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

@@ -674,6 +674,42 @@ static long doNFIPointer(Node inliningTarget, MemoryBlock memory, NFIPointerStor
         }
     }
 
+    @GenerateUncached
+    @GenerateInline
+    @GenerateCached(false)
+    public abstract static class FreeNode extends Node {
+        public final void execute(Node inliningTarget, Pointer pointer) {
+            execute(inliningTarget, pointer.memory.storage, pointer.offset);
+            pointer.memory.storage = Pointer.NULL.memory.storage;
+        }
+
+        abstract void execute(Node inliningTarget, Storage storage, int offset);
+
+        @Specialization
+        void doNativeMemory(LongPointerStorage storage, int offset) {
+            // TODO check permissions
+            UNSAFE.freeMemory(storage.pointer + offset);
+        }
+
+        @Specialization
+        @SuppressWarnings("unused")
+        void doNFIPointer(NFIPointerStorage storage, int offset) {
+            /*
+             * TODO This should call free using NFI. If it ever does, we should probably update
+             * PointerReference to use a call target around this
+             */
+        }
+
+        @Fallback
+        @SuppressWarnings("unused")
+        void doNothing(Storage storage, int offset) {
+        }
+
+        public static FreeNode getUncached() {
+            return PointerNodesFactory.FreeNodeGen.getUncached();
+        }
+    }
+
     @GenerateUncached
     @GenerateInline
     @GenerateCached(false)

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

@@ -0,0 +1,17 @@
+package com.oracle.graal.python.builtins.modules.ctypes.memory;
+
+import com.oracle.graal.python.builtins.modules.ctypes.CDataObject;
+import com.oracle.graal.python.runtime.AsyncHandler;
+
+public class PointerReference extends AsyncHandler.SharedFinalizer.FinalizableReference {
+
+    public PointerReference(CDataObject cDataObject, Pointer pointer, AsyncHandler.SharedFinalizer sharedFinalizer) {
+        super(cDataObject, pointer, sharedFinalizer);
+    }
+
+    @Override
+    public AsyncHandler.AsyncAction release() {
+        // This node currently doesn't need a call target
+        return (context) -> PointerNodes.FreeNode.getUncached().execute(null, (Pointer) getReference());
+    }
+}