Pritimive memory management for nogil extension

Cython/Compiler/ExprNodes.py

@@ -8739,6 +8739,8 @@ class DictNode(ExprNode):
         #  pairs are evaluated and used one at a time.
         code.mark_pos(self.pos)
         self.allocate_temp_result(code)
+        if hasattr(self.type, 'nogil') and self.type.nogil:
+            code.putln("%s = (struct %s *)malloc(sizeof(struct %s));" % (self.result(), self.type.objstruct_cname, self.type.objstruct_cname))
 
         is_dict = self.type.is_pyobject
         if is_dict:

Cython/Compiler/ModuleNode.py

@@ -1137,11 +1137,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
                     Naming.obj_base_cname))
         elif nogil:
             # Extension type with nogil keyword indicate it is a CPython-free struct
+            code.globalstate.use_utility_code(
+                UtilityCode.load_cached("CythonReferenceCounting", "ObjectHandling.c"))
             code.putln(
                 "// nogil"
             )
             code.putln(
-                "size_t ob_refcnt;"
+                "int ob_refcnt;" # "CyObject_HEAD;" Sometimes the CythonReferenceCounting was put after the nogil extension declaration, WTF!!!
             )
         else:
             code.putln(

Cython/Compiler/PyrexTypes.py

@@ -1371,9 +1371,6 @@ class CythonExtensionType(CythonObjectType):
                 entity_code = "*%s" % entity_code
         return self.base_declaration_code(base_code, entity_code)
 
-    def literal_code(self, value):
-        return '(struct %s *)malloc(sizeof(struct %s))' % (self.objstruct_cname, self.objstruct_cname)
-
     def type_test_code(self, py_arg, notnone=False):
 
         none_check = "((%s) == Py_None)" % py_arg

Cython/Utility/ObjectHandling.c

@@ -1581,6 +1581,51 @@ try_unpack:
     return 0;
 }
 
+/////////////// CythonReferenceCounting.proto ///////////////
+
+#include <stdlib.h>
+#include <stddef.h>
+
+#if !defined(__GNUC__)
+#define GCC_VERSION (__GNUC__ * 10000 \
+                     + __GNUC_MINOR__ * 100 \
+                     + __GNUC_PATCHLEVEL__)
+/* Test for GCC > 4.9.0 */
+#if GCC_VERSION < 40900
+#error atomic.h works only with GCC newer than version 4.9
+#endif /* GNUC >= 4.9 */
+
+#endif /* Has GCC */
+
+// #include <stdatomic.h>
+
+/* CyObject_HEAD defines the initial segment of every CyObject. */
+#define CyObject_HEAD                   \
+    int ob_refcnt;               \
+    void (*cdealloc)();
+
+struct CyObject {
+  CyObject_HEAD
+};
+
+/* Cast argument to PyObject* type. */
+#define _CyObject_CAST(op) ((struct CyObject*)(op))
+
+// XXX: Without scope analysis this is useless...
+/*
+static inline void _Cy_DECREF(struct CyObject *op) {
+  if (atomic_fetch_sub(&(op->ob_refcnt), 1) == 1) {
+    op->cdealloc(op);
+  }
+}
+
+static inline void _Cy_INCREF(struct CyObject *op) {
+  atomic_fetch_add(&(op->ob_refcnt), 1);
+}
+
+#define Cy_INCREF(op) _Cy_INCREF(_CyObject_CAST(op))
+#define Cy_DECREF(op) _Cy_DECREF(_CyObject_CAST(op))
+*/
 
 /////////////// UnpackUnboundCMethod.proto ///////////////