ffi 1.9.24 → 1.16.3

data/ext/ffi_c/Types.h

@@ -51,20 +51,19 @@ typedef enum {
     NATIVE_FLOAT64,
     NATIVE_LONGDOUBLE,
     NATIVE_POINTER,
-    NATIVE_CALLBACK,
     NATIVE_FUNCTION,
     NATIVE_BUFFER_IN,
     NATIVE_BUFFER_OUT,
     NATIVE_BUFFER_INOUT,
     NATIVE_CHAR_ARRAY,
     NATIVE_BOOL,
-    
+
     /** An immutable string.  Nul terminated, but only copies in to the native function */
     NATIVE_STRING,
-    
+
     /** The function takes a variable number of arguments */
     NATIVE_VARARGS,
-    
+
     /** Struct-by-value param or result */
     NATIVE_STRUCT,
 

data/ext/ffi_c/Variadic.c

@@ -33,14 +33,12 @@
 #include <sys/types.h>
 
 #include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
+#include <stdint.h>
+#include <stdbool.h>
 #include <ruby.h>
+#if HAVE_RB_EXT_RACTOR_SAFE
+#include <ruby/ractor.h>
+#endif
 
 #include <ffi.h>
 #include "rbffi.h"
@@ -67,35 +65,65 @@ typedef struct VariadicInvoker_ {
     bool blocking;
 } VariadicInvoker;
 
-
 static VALUE variadic_allocate(VALUE klass);
 static VALUE variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes,
         VALUE rbReturnType, VALUE options);
-static void variadic_mark(VariadicInvoker *);
+static void variadic_mark(void *);
+static void variadic_compact(void *);
+static size_t variadic_memsize(const void *);
 
 static VALUE classVariadicInvoker = Qnil;
 
+static const rb_data_type_t variadic_data_type = {
+  .wrap_struct_name = "FFI::VariadicInvoker",
+  .function = {
+      .dmark = variadic_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = variadic_memsize,
+      ffi_compact_callback( variadic_compact )
+  },
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
+};
+
 
 static VALUE
 variadic_allocate(VALUE klass)
 {
     VariadicInvoker *invoker;
-    VALUE obj = Data_Make_Struct(klass, VariadicInvoker, variadic_mark, -1, invoker);
+    VALUE obj = TypedData_Make_Struct(klass, VariadicInvoker, &variadic_data_type, invoker);
 
-    invoker->rbAddress = Qnil;
-    invoker->rbEnums = Qnil;
-    invoker->rbReturnType = Qnil;
+    RB_OBJ_WRITE(obj, &invoker->rbAddress, Qnil);
+    RB_OBJ_WRITE(obj, &invoker->rbEnums, Qnil);
+    RB_OBJ_WRITE(obj, &invoker->rbReturnType, Qnil);
     invoker->blocking = false;
 
     return obj;
 }
 
 static void
-variadic_mark(VariadicInvoker *invoker)
+variadic_mark(void *data)
+{
+    VariadicInvoker *invoker = (VariadicInvoker *)data;
+    rb_gc_mark_movable(invoker->rbEnums);
+    rb_gc_mark_movable(invoker->rbAddress);
+    rb_gc_mark_movable(invoker->rbReturnType);
+}
+
+static void
+variadic_compact(void *data)
+{
+    VariadicInvoker *invoker = (VariadicInvoker *)data;
+    ffi_gc_location(invoker->rbEnums);
+    ffi_gc_location(invoker->rbAddress);
+    ffi_gc_location(invoker->rbReturnType);
+}
+
+static size_t
+variadic_memsize(const void *data)
 {
-    rb_gc_mark(invoker->rbEnums);
-    rb_gc_mark(invoker->rbAddress);
-    rb_gc_mark(invoker->rbReturnType);
+    return sizeof(VariadicInvoker);
 }
 
 static VALUE
@@ -113,10 +141,10 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     Check_Type(options, T_HASH);
     convention = rb_hash_aref(options, ID2SYM(rb_intern("convention")));
 
-    Data_Get_Struct(self, VariadicInvoker, invoker);
-    invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums")));
-    invoker->rbAddress = rbFunction;
-    invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
+    RB_OBJ_WRITE(self, &invoker->rbEnums, rb_hash_aref(options, ID2SYM(rb_intern("enums"))));
+    RB_OBJ_WRITE(self, &invoker->rbAddress, rbFunction);
+    invoker->function = rbffi_AbstractMemory_Cast(rbFunction, &rbffi_pointer_data_type)->address;
     invoker->blocking = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("blocking"))));
 
 #if defined(X86_WIN32)
@@ -127,13 +155,13 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     invoker->abi = FFI_DEFAULT_ABI;
 #endif
 
-    invoker->rbReturnType = rbffi_Type_Lookup(rbReturnType);
+    RB_OBJ_WRITE(self, &invoker->rbReturnType, rbffi_Type_Lookup(rbReturnType));
     if (!RTEST(invoker->rbReturnType)) {
         VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
         rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
     }
 
-    Data_Get_Struct(rbReturnType, Type, invoker->returnType);
+    TypedData_Get_Struct(rbReturnType, Type, &rbffi_type_data_type, invoker->returnType);
 
     invoker->paramCount = -1;
 
@@ -147,7 +175,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
             VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL);
             rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName));
         }
-        Data_Get_Struct(rbType, Type, type);
+        TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, type);
         if (type->nativeType != NATIVE_VARARGS) {
             rb_ary_push(fixed, entry);
         }
@@ -155,7 +183,7 @@ variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE
     /*
      * @fixed and @type_map are used by the parameter mangling ruby code
      */
-    rb_iv_set(self, "@fixed", fixed);
+    rb_iv_set(self, "@fixed", rb_obj_freeze(fixed));
     rb_iv_set(self, "@type_map", rb_hash_aref(options, ID2SYM(rb_intern("type_map"))));
 
     return retval;
@@ -173,54 +201,64 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     ffi_type* ffiReturnType;
     Type** paramTypes;
     VALUE* argv;
-    int paramCount = 0, fixedCount = 0, i;
+    VALUE* callbackParameters;
+    int paramCount = 0, fixedCount = 0, callbackCount = 0, i;
     ffi_status ffiStatus;
     rbffi_frame_t frame = { 0 };
 
     Check_Type(parameterTypes, T_ARRAY);
     Check_Type(parameterValues, T_ARRAY);
 
-    Data_Get_Struct(self, VariadicInvoker, invoker);
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
     paramCount = (int) RARRAY_LEN(parameterTypes);
     paramTypes = ALLOCA_N(Type *, paramCount);
     ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
     params = ALLOCA_N(FFIStorage, paramCount);
     ffiValues = ALLOCA_N(void*, paramCount);
     argv = ALLOCA_N(VALUE, paramCount);
+    callbackParameters = ALLOCA_N(VALUE, paramCount);
     retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
 
     for (i = 0; i < paramCount; ++i) {
         VALUE rbType = rb_ary_entry(parameterTypes, i);
-        
+
         if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
             rb_raise(rb_eTypeError, "wrong type.  Expected (FFI::Type)");
         }
-        Data_Get_Struct(rbType, Type, paramTypes[i]);
+        TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
 
         switch (paramTypes[i]->nativeType) {
             case NATIVE_INT8:
             case NATIVE_INT16:
             case NATIVE_INT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("INT32"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
                 break;
             case NATIVE_UINT8:
             case NATIVE_UINT16:
             case NATIVE_UINT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("UINT32"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
                 break;
-            
+
             case NATIVE_FLOAT32:
                 rbType = rb_const_get(rbffi_TypeClass, rb_intern("DOUBLE"));
-                Data_Get_Struct(rbType, Type, paramTypes[i]);
+                TypedData_Get_Struct(rbType, Type, &rbffi_type_data_type, paramTypes[i]);
+                break;
+
+            case NATIVE_FUNCTION:
+                if (!rb_obj_is_kind_of(rbType, rbffi_FunctionTypeClass)) {
+                    VALUE typeName = rb_funcall2(rbType, rb_intern("inspect"), 0, NULL);
+                    rb_raise(rb_eTypeError, "Incorrect parameter type (%s)", RSTRING_PTR(typeName));
+                }
+                callbackParameters[callbackCount++] = rbType;
                 break;
 
             default:
                 break;
         }
-        
-        
+
+
         ffiParamTypes[i] = paramTypes[i]->ffiType;
         if (ffiParamTypes[i] == NULL) {
             rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]->nativeType);
@@ -253,14 +291,10 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     }
 
     rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
-        ffiValues, NULL, 0, invoker->rbEnums);
-    
+        ffiValues, callbackParameters, callbackCount, invoker->rbEnums);
+
     rbffi_frame_push(&frame);
-#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
-    /* In Call.c, blocking: true is supported on older ruby variants
-     * without rb_thread_call_without_gvl by allocating on the heap instead
-     * of the stack. Since this functionality is being added later,
-     * we’re skipping support for old rubies here. */
+
     if(unlikely(invoker->blocking)) {
         rbffi_blocking_call_t* bc;
         bc = ALLOCA_N(rbffi_blocking_call_t, 1);
@@ -275,13 +309,11 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     } else {
         ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
     }
-#else
-    ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
-#endif
+
     rbffi_frame_pop(&frame);
-    
+
     rbffi_save_errno();
-    
+
     if (RTEST(frame.exc) && frame.exc != Qnil) {
         rb_exc_raise(frame.exc);
     }
@@ -289,6 +321,14 @@ variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
     return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval);
 }
 
+static VALUE
+variadic_return_type(VALUE self)
+{
+    VariadicInvoker* invoker;
+
+    TypedData_Get_Struct(self, VariadicInvoker, &variadic_data_type, invoker);
+    return invoker->rbReturnType;
+}
 
 void
 rbffi_Variadic_Init(VALUE moduleFFI)
@@ -300,5 +340,6 @@ rbffi_Variadic_Init(VALUE moduleFFI)
 
     rb_define_method(classVariadicInvoker, "initialize", variadic_initialize, 4);
     rb_define_method(classVariadicInvoker, "invoke", variadic_invoke, 2);
+    rb_define_method(classVariadicInvoker, "return_type", variadic_return_type, 0);
 }
 

data/ext/ffi_c/compat.h

@@ -32,26 +32,6 @@
 
 #include <ruby.h>
 
-#ifndef RARRAY_LEN
-#  define RARRAY_LEN(ary) RARRAY(ary)->len
-#endif
-
-#ifndef RARRAY_PTR
-#  define RARRAY_PTR(ary) RARRAY(ary)->ptr
-#endif
-
-#ifndef RSTRING_LEN
-#  define RSTRING_LEN(s) RSTRING(s)->len
-#endif
-
-#ifndef RSTRING_PTR
-#  define RSTRING_PTR(s) RSTRING(s)->ptr
-#endif
-
-#ifndef NUM2ULL
-#  define NUM2ULL(x) rb_num2ull((VALUE)x)
-#endif
-
 #ifndef roundup
 #  define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))
 #endif
@@ -64,6 +44,10 @@
 #  define unlikely(x) (x)
 #endif
 
+#ifdef _MSC_VER
+#define ffi_type_longdouble ffi_type_double
+#endif
+
 #ifndef MAX
 #  define MAX(a, b) ((a) < (b) ? (b) : (a))
 #endif
@@ -71,8 +55,28 @@
 #  define MIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
-#ifndef RB_GC_GUARD
-#  define RB_GC_GUARD(x) (x)
+
+
+/* For compatibility with ruby < 2.7 */
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define ffi_compact_callback(x) .dcompact = (x),
+#define ffi_gc_location(x) x = rb_gc_location(x)
+#else
+#define rb_gc_mark_movable(x) rb_gc_mark(x)
+#define ffi_compact_callback(x)
+#define ffi_gc_location(x)
+#endif
+
+
+/* For compatibility with ruby < 3.0 */
+#ifndef RUBY_TYPED_FROZEN_SHAREABLE
+#define FFI_RUBY_TYPED_FROZEN_SHAREABLE 0
+#else
+#define FFI_RUBY_TYPED_FROZEN_SHAREABLE RUBY_TYPED_FROZEN_SHAREABLE
+#endif
+
+#ifndef HAVE_RB_EXT_RACTOR_SAFE
+#define rb_ractor_make_shareable(self) rb_obj_freeze(self);
 #endif
 
 #endif /* RBFFI_COMPAT_H */

data/ext/ffi_c/extconf.rb

@@ -1,8 +1,31 @@
 #!/usr/bin/env ruby
 
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   require 'mkmf'
   require 'rbconfig'
+
+  def system_libffi_usable?
+    # We need pkg_config or ffi.h
+    libffi_ok = pkg_config("libffi") ||
+        have_header("ffi.h") ||
+        find_header("ffi.h", "/usr/local/include", "/usr/include/ffi",
+                    "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/ffi",
+                    "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/ffi") ||
+        (find_header("ffi.h", `xcrun --sdk macosx --show-sdk-path`.strip + "/usr/include/ffi") rescue false)
+
+    # Ensure we can link to ffi_prep_closure_loc
+    libffi_ok &&= have_library("ffi", "ffi_prep_closure_loc", [ "ffi.h" ]) ||
+                  have_library("libffi", "ffi_prep_closure_loc", [ "ffi.h" ]) ||
+                  have_library("libffi-8", "ffi_prep_closure_loc", [ "ffi.h" ])
+
+    if RbConfig::CONFIG['host_os'] =~ /mswin/
+      have_library('libffi_convenience')
+      have_library('shlwapi')
+    end
+
+    libffi_ok
+  end
+
   dir_config("ffi_c")
 
   # recent versions of ruby add restrictive ansi and warning flags on a whim - kill them all
@@ -10,60 +33,80 @@ if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
   $CFLAGS.gsub!(/[\s+]-ansi/, '')
   $CFLAGS.gsub!(/[\s+]-std=[^\s]+/, '')
   # solaris 10 needs -c99 for <stdbool.h>
-  $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
-
-  if ENV['RUBY_CC_VERSION'].nil? && (pkg_config("libffi") ||
-     have_header("ffi.h") ||
-     find_header("ffi.h", "/usr/local/include", "/usr/include/ffi"))
+  $CFLAGS << " -g -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
+  if enable_config("debug")
+    $CPPFLAGS += " #{RbConfig::CONFIG["debugflags"]}"
+    $LDFLAGS += " #{RbConfig::CONFIG["debugflags"]}"
+  end
 
-    # We need at least ffi_call and ffi_closure_alloc
-    libffi_ok = have_library("ffi", "ffi_call", [ "ffi.h" ]) ||
-                have_library("libffi", "ffi_call", [ "ffi.h" ])
-    libffi_ok &&= have_func("ffi_closure_alloc")
+  # Check whether we use system libffi
+  system_libffi = enable_config('system-libffi', :try)
 
-    # Check if the raw api is available.
-    $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
+  if system_libffi == :try
+    system_libffi = ENV['RUBY_CC_VERSION'].nil? && system_libffi_usable?
+  elsif system_libffi
+    abort "system libffi is not usable" unless system_libffi_usable?
   end
 
-  have_header('shlwapi.h')
-  have_header('ruby/thread.h') # for compat with ruby < 2.0
-  have_func('rb_thread_blocking_region')
-  have_func('rb_thread_call_with_gvl')
-  have_func('rb_thread_call_without_gvl')
-
-  if libffi_ok
+  if system_libffi
     have_func('ffi_prep_cif_var')
+    $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
   else
     $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+    $defs << "-DUSE_INTERNAL_LIBFFI"
+
+    # Ensure libffi symbols aren't exported when using static libffi.
+    # This is to avoid interference with other gems like fiddle.
+    # See https://github.com/ffi/ffi/issues/835
+    append_ldflags "-Wl,--exclude-libs,ALL"
+  end
+
+  have_func 'rb_gc_mark_movable' # since ruby-2.7
+
+  # Some linux archs need explicit linking to pthread, see https://github.com/ffi/ffi/issues/893
+  append_ldflags "-pthread"
+
+  ffi_alloc_default = RbConfig::CONFIG['host_os'] =~ /darwin/i && RbConfig::CONFIG['host'] =~ /arm|aarch64/i
+  ffi_alloc_default = ffi_alloc_default || RbConfig::CONFIG['host'] =~ /hppa/i
+  if enable_config('libffi-alloc', ffi_alloc_default)
+    $defs << "-DUSE_FFI_ALLOC"
   end
 
   $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
-  $defs << "-DUSE_INTERNAL_LIBFFI" unless libffi_ok
-  $defs << "-DRUBY_1_9" if RUBY_VERSION >= "1.9.0"
-  $defs << "-DFFI_BUILDING" if RbConfig::CONFIG['host_os'] =~ /mswin/ # for compatibility with newer libffi
 
   create_header
-  
-  $LOCAL_LIBS << " ./libffi/.libs/libffi_convenience.lib" if !libffi_ok && RbConfig::CONFIG['host_os'] =~ /mswin/
-
   create_makefile("ffi_c")
-  unless libffi_ok
+
+  unless system_libffi
     File.open("Makefile", "a") do |mf|
-      mf.puts "LIBFFI_HOST=--host=#{RbConfig::CONFIG['host_alias']}" if RbConfig::CONFIG.has_key?("host_alias")
-      if RbConfig::CONFIG['host_os'].downcase =~ /darwin/
+      if enable_config("debug")
+        mf.puts "LIBFFI_DEBUG=--enable-debug CPPFLAGS='#{RbConfig::CONFIG["debugflags"]}' LDFLAGS='#{RbConfig::CONFIG["debugflags"]}'"
+      end
+
+      if RbConfig::CONFIG['host_alias'] == "i386-w64-mingw32"
+        host = "i686-w64-mingw32" # Work around host name without matching compiler name in rake-compiler-dock-1.3.0 on platform x86-mingw32
+      elsif RbConfig::CONFIG.has_key?("host_alias")
+        host = RbConfig::CONFIG['host_alias']
+      end
+      mf.puts "LIBFFI_HOST=--host=#{host}" if host
+
+      if RbConfig::CONFIG['host_os'] =~ /darwin/i
+        if RbConfig::CONFIG['host'] =~ /arm|aarch64/i
+          mf.puts "LIBFFI_HOST=--host=aarch64-apple-#{RbConfig::CONFIG['host_os']}"
+        end
         mf.puts "include ${srcdir}/libffi.darwin.mk"
-      elsif RbConfig::CONFIG['host_os'].downcase =~ /bsd/
+      elsif RbConfig::CONFIG['host_os'] =~ /bsd/i
         mf.puts '.include "${srcdir}/libffi.bsd.mk"'
-      elsif RbConfig::CONFIG['host_os'].downcase =~ /mswin64/
+      elsif RbConfig::CONFIG['host_os'] =~ /mswin64/i
         mf.puts '!include $(srcdir)/libffi.vc64.mk'
-      elsif RbConfig::CONFIG['host_os'].downcase =~ /mswin32/
+      elsif RbConfig::CONFIG['host_os'] =~ /mswin32/i
         mf.puts '!include $(srcdir)/libffi.vc.mk'
       else
         mf.puts "include ${srcdir}/libffi.mk"
       end
     end
   end
-  
+
 else
   File.open("Makefile", "w") do |mf|
     mf.puts "# Dummy makefile for non-mri rubies"

data/ext/ffi_c/ffi.c

@@ -40,13 +40,12 @@
 #include "MemoryPointer.h"
 #include "Struct.h"
 #include "StructByValue.h"
-#include "StructByReference.h"
 #include "DynamicLibrary.h"
 #include "Platform.h"
 #include "Types.h"
 #include "LastError.h"
 #include "Function.h"
-#include "Closure.h"
+#include "ClosurePool.h"
 #include "MethodHandle.h"
 #include "Call.h"
 #include "ArrayType.h"
@@ -59,9 +58,13 @@ VALUE rbffi_FFIModule = Qnil;
 static VALUE moduleFFI = Qnil;
 
 void
-Init_ffi_c(void) 
+Init_ffi_c(void)
 {
-    /* 
+    #ifdef HAVE_RB_EXT_RACTOR_SAFE
+        rb_ext_ractor_safe(1);
+    #endif
+
+    /*
      * Document-module: FFI
      *
      * This module embbed type constants from {FFI::NativeType}.
@@ -70,16 +73,14 @@ Init_ffi_c(void)
     rb_global_variable(&rbffi_FFIModule);
 
     rbffi_Thread_Init(rbffi_FFIModule);
-    
+
     /* FFI::Type needs to be initialized before most other classes */
     rbffi_Type_Init(moduleFFI);
 
-    rbffi_DataConverter_Init(moduleFFI);
-
     rbffi_ArrayType_Init(moduleFFI);
     rbffi_LastError_Init(moduleFFI);
     rbffi_Call_Init(moduleFFI);
-    rbffi_Closure_Init(moduleFFI);
+    rbffi_ClosurePool_Init(moduleFFI);
     rbffi_MethodHandle_Init(moduleFFI);
     rbffi_Platform_Init(moduleFFI);
     rbffi_AbstractMemory_Init(moduleFFI);
@@ -88,11 +89,9 @@ Init_ffi_c(void)
     rbffi_MemoryPointer_Init(moduleFFI);
     rbffi_Buffer_Init(moduleFFI);
     rbffi_StructByValue_Init(moduleFFI);
-    rbffi_StructByReference_Init(moduleFFI);
     rbffi_Struct_Init(moduleFFI);
     rbffi_DynamicLibrary_Init(moduleFFI);
     rbffi_Variadic_Init(moduleFFI);
     rbffi_Types_Init(moduleFFI);
     rbffi_MappedType_Init(moduleFFI);
 }
-

data/ext/ffi_c/libffi/.appveyor/site.exp

@@ -0,0 +1,16 @@
+# Copyright (C) 2021  Anthony Green
+
+lappend boards_dir $::env(SITEDIR)
+
+verbose "Global Config File: target_triplet is $target_triplet" 1
+global target_list
+
+case "$target_triplet" in {
+    { "aarch*cygwin*" } {
+	set target_list "unix-noexec"
+    }
+    { "arm*cygwin*" } {
+	set target_list "unix-noexec"
+    }
+}
+

data/ext/ffi_c/libffi/.appveyor/unix-noexec.exp

@@ -0,0 +1,7 @@
+load_generic_config "remote"
+
+proc noexec_load { dest prog args } {
+  return "unsupported"  
+}
+
+set_board_info protocol "noexec"