use system libffi for older releases of Mac OS

Author: lawrence-danna-apple

Modules/_ctypes/callbacks.c

@@ -18,7 +18,7 @@ CThunkObject_dealloc(PyObject *myself)
     Py_XDECREF(self->callable);
     Py_XDECREF(self->restype);
     if (self->pcl_write)
-        ffi_closure_free(self->pcl_write);
+        Py_ffi_closure_free(self->pcl_write);
     PyObject_GC_Del(self);
 }
 
@@ -361,8 +361,7 @@ CThunkObject *_ctypes_alloc_callback(PyObject *callable,
 
     assert(CThunk_CheckExact((PyObject *)p));
 
-    p->pcl_write = ffi_closure_alloc(sizeof(ffi_closure),
-                                                                         &p->pcl_exec);
+    p->pcl_write = Py_ffi_closure_alloc(sizeof(ffi_closure), &p->pcl_exec);
     if (p->pcl_write == NULL) {
         PyErr_NoMemory();
         goto error;
@@ -408,13 +407,29 @@ CThunkObject *_ctypes_alloc_callback(PyObject *callable,
                      "ffi_prep_cif failed with %d", result);
         goto error;
     }
-#if defined(X86_DARWIN) || defined(POWERPC_DARWIN)
-    result = ffi_prep_closure(p->pcl_write, &p->cif, closure_fcn, p);
+#if HAVE_FFI_PREP_CLOSURE_LOC
+#   if USING_APPLE_OS_LIBFFI
+#      define HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME __builtin_available(macos 11, ios 13, watchos 6, tvos 13, *)
+#   else
+#      define HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME true
+#   endif
+    if (HAVE_FFI_PREP_CLOSURE_LOC_RUNTIME) {
+        result = ffi_prep_closure_loc(p->pcl_write, &p->cif, closure_fcn,
+                                    p,
+                                    p->pcl_exec);
+    } else
+#endif
+    {
+#if USING_APPLE_OS_LIBFFI && defined(__arm64__)
+        PyErr_Format(PyExc_NotImplementedError, "ffi_prep_closure_loc() is missing");
+        goto error;
 #else
-    result = ffi_prep_closure_loc(p->pcl_write, &p->cif, closure_fcn,
-                                  p,
-                                  p->pcl_exec);
+        #pragma clang diagnostic push
+        #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        result = ffi_prep_closure(p->pcl_write, &p->cif, closure_fcn, p);
+        #pragma clang diagnostic pop
 #endif
+    }
     if (result != FFI_OK) {
         PyErr_Format(PyExc_RuntimeError,
                      "ffi_prep_closure failed with %d", result);

Modules/_ctypes/callproc.c

@@ -57,6 +57,8 @@
 #include "Python.h"
 #include "structmember.h"         // PyMemberDef
 
+#include <stdbool.h>
+
 #ifdef MS_WIN32
 #include <windows.h>
 #include <tchar.h>
@@ -837,26 +839,52 @@ static int _call_function_pointer(int flags,
         cc = FFI_STDCALL;
 #endif
 
-#if HAVE_FFI_PREP_CIF_VAR
+#   if USING_APPLE_OS_LIBFFI
+#      define HAVE_FFI_PREP_CIF_VAR_RUNTIME __builtin_available(macos 11, ios 13, watchos 6, tvos 13, *)
+#   elif HAVE_FFI_PREP_CIF_VAR
+#      define HAVE_FFI_PREP_CIF_VAR_RUNTIME true
+#   else
+#      define HAVE_FFI_PREP_CIF_VAR_RUNTIME false
+#   endif
+
     /* Everyone SHOULD set f.variadic=True on variadic function pointers, but
      * lots of existing code will not.  If there's at least one arg and more
      * args are passed than are defined in the prototype, then it must be a
      * variadic function. */
-    if ((flags & FUNCFLAG_VARIADIC) ||
-        (argtypecount != 0 && argcount > argtypecount))
-    {
-        if (FFI_OK != ffi_prep_cif_var(&cif,
-                                       cc,
-                                       argtypecount,
-                                       argcount,
-                                       restype,
-                                       atypes)) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "ffi_prep_cif_var failed");
+    bool is_variadic = (flags & FUNCFLAG_VARIADIC) || (argtypecount != 0 && argcount > argtypecount);
+    (void) is_variadic;
+
+#if defined(__APPLE__) && defined(__arm64__)
+    if (is_variadic) {
+        if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) {
+        } else {
+            PyErr_SetString(PyExc_NotImplementedError, "ffi_prep_cif_var() is missing");
             return -1;
         }
-    } else {
+    }
+#endif
+
+    bool called_ffi_prep_cif_var = false;
+
+#if HAVE_FFI_PREP_CIF_VAR
+    if (is_variadic) {
+        if (HAVE_FFI_PREP_CIF_VAR_RUNTIME) {
+            if (FFI_OK != ffi_prep_cif_var(&cif,
+                                        cc,
+                                        argtypecount,
+                                        argcount,
+                                        restype,
+                                        atypes)) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                "ffi_prep_cif_var failed");
+                return -1;
+            }
+            called_ffi_prep_cif_var = true;
+        }
+    }
 #endif
+
+    if (!called_ffi_prep_cif_var) {
         if (FFI_OK != ffi_prep_cif(&cif,
                                    cc,
                                    argcount,
@@ -866,9 +894,7 @@ static int _call_function_pointer(int flags,
                             "ffi_prep_cif failed");
             return -1;
         }
-#if HAVE_FFI_PREP_CIF_VAR
     }
-#endif
 
     if (flags & (FUNCFLAG_USE_ERRNO | FUNCFLAG_USE_LASTERROR)) {
         error_object = _ctypes_get_errobj(&space);

Modules/_ctypes/ctypes.h

@@ -367,6 +367,14 @@ PyObject *_ctypes_get_errobj(int **pspace);
 extern PyObject *ComError;
 #endif
 
+#if USING_MALLOC_CLOSURE_DOT_C
+void Py_ffi_closure_free(void *p);
+void *Py_ffi_closure_alloc(size_t size, void** codeloc);
+#else
+#define Py_ffi_closure_free ffi_closure_free
+#define Py_ffi_closure_alloc ffi_closure_alloc
+#endif
+
 /*
  Local Variables:
  compile-command: "python setup.py -q build install --home ~"

Modules/_ctypes/malloc_closure.c

@@ -89,16 +89,27 @@ static void more_core(void)
 /******************************************************************/
 
 /* put the item back into the free list */
-void ffi_closure_free(void *p)
+void Py_ffi_closure_free(void *p)
 {
+#if USING_APPLE_OS_LIBFFI
+    if (__builtin_available(macos 11, ios 13, watchos 6, tvos 13, *)) {
+        ffi_closure_free(p);
+        return;
+    }
+#endif
     ITEM *item = (ITEM *)p;
     item->next = free_list;
     free_list = item;
 }
 
 /* return one item from the free list, allocating more if needed */
-void *ffi_closure_alloc(size_t ignored, void** codeloc)
+void *Py_ffi_closure_alloc(size_t size, void** codeloc)
 {
+#if USING_APPLE_OS_LIBFFI
+    if (__builtin_available(macos 11, ios 13, watchos 6, tvos 13, *)) {
+        return ffi_closure_alloc(size, codeloc);
+    }
+#endif
     ITEM *item;
     if (!free_list)
         more_core();

setup.py

@@ -2151,7 +2151,8 @@ def configure_ctypes(self, ext):
     def detect_ctypes(self):
         # Thomas Heller's _ctypes module
 
-        if not sysconfig.get_config_var("LIBFFI_INCLUDEDIR") and is_macosx_at_least((10,15)):
+        if (not sysconfig.get_config_var("LIBFFI_INCLUDEDIR") and
+            (is_macosx_at_least((10,15)) or '-arch arm64' in sysconfig.get_config_var("CFLAGS"))):
             self.use_system_libffi = True
         else:
             self.use_system_libffi = '--with-system-ffi' in sysconfig.get_config_var("CONFIG_ARGS")
@@ -2168,6 +2169,7 @@ def detect_ctypes(self):
 
         if MACOS:
             sources.append('_ctypes/malloc_closure.c')
+            extra_compile_args.append('-DUSING_MALLOC_CLOSURE_DOT_C=1')
             sources.append('_ctypes/darwin/dlfcn_simple.c')
             extra_compile_args.append('-DMACOSX')
             include_dirs.append('_ctypes/darwin')
@@ -2209,6 +2211,7 @@ def detect_ctypes(self):
         if MACOS:
             if not self.use_system_libffi:
                 return
+            ext.extra_compile_args.append("-DUSING_APPLE_OS_LIBFFI=1")
             ffi_in_sdk = os.path.join(macosx_sdk_root(), "usr/include/ffi")
             if os.path.exists(ffi_in_sdk):
                 ffi_inc = ffi_in_sdk
@@ -2235,13 +2238,10 @@ def detect_ctypes(self):
 
         if ffi_inc and ffi_lib:
             ffi_headers = glob(os.path.join(ffi_inc, '*.h'))
-            if grep_headers_for('ffi_closure_alloc', ffi_headers):
-                try:
-                    sources.remove('_ctypes/malloc_closure.c')
-                except ValueError:
-                    pass
             if grep_headers_for('ffi_prep_cif_var', ffi_headers):
                 ext.extra_compile_args.append("-DHAVE_FFI_PREP_CIF_VAR=1")
+            if grep_headers_for('ffi_prep_closure_loc', ffi_headers):
+                ext.extra_compile_args.append("-DHAVE_FFI_PREP_CLOSURE_LOC=1")
             ext.include_dirs.append(ffi_inc)
             ext.libraries.append(ffi_lib)
             self.use_system_libffi = True